algebra.order.monoid.to_mul_bot ⟷ Mathlib.Algebra.Order.Monoid.ToMulBot

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,9 +3,9 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
-import Mathbin.Algebra.Order.WithZero
-import Mathbin.Algebra.Order.Monoid.WithTop
-import Mathbin.Algebra.Order.Monoid.TypeTags
+import Algebra.Order.WithZero
+import Algebra.Order.Monoid.WithTop
+import Algebra.Order.Monoid.TypeTags
 
 #align_import algebra.order.monoid.to_mul_bot from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,16 +2,13 @@
 Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
-
-! This file was ported from Lean 3 source module algebra.order.monoid.to_mul_bot
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Order.WithZero
 import Mathbin.Algebra.Order.Monoid.WithTop
 import Mathbin.Algebra.Order.Monoid.TypeTags
 
+#align_import algebra.order.monoid.to_mul_bot from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
 > Any changes to this file require a corresponding PR to mathlib4.

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -31,48 +31,64 @@ attribute [local semireducible] WithZero
 
 variable [Add α]
 
+#print WithZero.toMulBot /-
 /-- Making an additive monoid multiplicative then adding a zero is the same as adding a bottom
 element then making it multiplicative. -/
 def toMulBot : WithZero (Multiplicative α) ≃* Multiplicative (WithBot α) :=
   MulEquiv.refl _
 #align with_zero.to_mul_bot WithZero.toMulBot
+-/
 
+#print WithZero.toMulBot_zero /-
 @[simp]
 theorem toMulBot_zero : toMulBot (0 : WithZero (Multiplicative α)) = Multiplicative.ofAdd ⊥ :=
   rfl
 #align with_zero.to_mul_bot_zero WithZero.toMulBot_zero
+-/
 
+#print WithZero.toMulBot_coe /-
 @[simp]
 theorem toMulBot_coe (x : Multiplicative α) :
     toMulBot ↑x = Multiplicative.ofAdd (x.toAdd : WithBot α) :=
   rfl
 #align with_zero.to_mul_bot_coe WithZero.toMulBot_coe
+-/
 
+#print WithZero.toMulBot_symm_bot /-
 @[simp]
 theorem toMulBot_symm_bot : toMulBot.symm (Multiplicative.ofAdd (⊥ : WithBot α)) = 0 :=
   rfl
 #align with_zero.to_mul_bot_symm_bot WithZero.toMulBot_symm_bot
+-/
 
+#print WithZero.toMulBot_coe_ofAdd /-
 @[simp]
 theorem toMulBot_coe_ofAdd (x : α) :
     toMulBot.symm (Multiplicative.ofAdd (x : WithBot α)) = Multiplicative.ofAdd x :=
   rfl
 #align with_zero.to_mul_bot_coe_of_add WithZero.toMulBot_coe_ofAdd
+-/
 
 variable [Preorder α] (a b : WithZero (Multiplicative α))
 
+#print WithZero.toMulBot_strictMono /-
 theorem toMulBot_strictMono : StrictMono (@toMulBot α _) := fun x y => id
 #align with_zero.to_mul_bot_strict_mono WithZero.toMulBot_strictMono
+-/
 
+#print WithZero.toMulBot_le /-
 @[simp]
 theorem toMulBot_le : toMulBot a ≤ toMulBot b ↔ a ≤ b :=
   Iff.rfl
 #align with_zero.to_mul_bot_le WithZero.toMulBot_le
+-/
 
+#print WithZero.toMulBot_lt /-
 @[simp]
 theorem toMulBot_lt : toMulBot a < toMulBot b ↔ a < b :=
   Iff.rfl
 #align with_zero.to_mul_bot_lt WithZero.toMulBot_lt
+-/
 
 end WithZero
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -31,55 +31,28 @@ attribute [local semireducible] WithZero
 
 variable [Add α]
 
-/- warning: with_zero.to_mul_bot -> WithZero.toMulBot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))
-Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot WithZero.toMulBotₓ'. -/
 /-- Making an additive monoid multiplicative then adding a zero is the same as adding a bottom
 element then making it multiplicative. -/
 def toMulBot : WithZero (Multiplicative α) ≃* Multiplicative (WithBot α) :=
   MulEquiv.refl _
 #align with_zero.to_mul_bot WithZero.toMulBot
 
-/- warning: with_zero.to_mul_bot_zero -> WithZero.toMulBot_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} (Multiplicative.{u1} (WithBot.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (OfNat.mk.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.zero.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.toOfNat0.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.toOfNat0.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_zero WithZero.toMulBot_zeroₓ'. -/
 @[simp]
 theorem toMulBot_zero : toMulBot (0 : WithZero (Multiplicative α)) = Multiplicative.ofAdd ⊥ :=
   rfl
 #align with_zero.to_mul_bot_zero WithZero.toMulBot_zero
 
-/- warning: with_zero.to_mul_bot_coe -> WithZero.toMulBot_coe is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_coe WithZero.toMulBot_coeₓ'. -/
 @[simp]
 theorem toMulBot_coe (x : Multiplicative α) :
     toMulBot ↑x = Multiplicative.ofAdd (x.toAdd : WithBot α) :=
   rfl
 #align with_zero.to_mul_bot_coe WithZero.toMulBot_coe
 
-/- warning: with_zero.to_mul_bot_symm_bot -> WithZero.toMulBot_symm_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} (WithZero.{u1} (Multiplicative.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) => (Multiplicative.{u1} (WithBot.{u1} α)) -> (WithZero.{u1} (Multiplicative.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (OfNat.mk.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.zero.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (fun (_x : Multiplicative.{u1} (WithBot.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))))))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) 0 (Zero.toOfNat0.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (WithZero.zero.{u1} (Multiplicative.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_symm_bot WithZero.toMulBot_symm_botₓ'. -/
 @[simp]
 theorem toMulBot_symm_bot : toMulBot.symm (Multiplicative.ofAdd (⊥ : WithBot α)) = 0 :=
   rfl
 #align with_zero.to_mul_bot_symm_bot WithZero.toMulBot_symm_bot
 
-/- warning: with_zero.to_mul_bot_coe_of_add -> WithZero.toMulBot_coe_ofAdd is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : α), Eq.{succ u1} (WithZero.{u1} (Multiplicative.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) => (Multiplicative.{u1} (WithBot.{u1} α)) -> (WithZero.{u1} (Multiplicative.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.hasCoeT.{u1} (Multiplicative.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) => α -> (Multiplicative.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (Multiplicative.{u1} α)) (Multiplicative.ofAdd.{u1} α) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (WithBot.some.{u1} α x))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (fun (_x : Multiplicative.{u1} (WithBot.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))))))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (WithBot.some.{u1} α x))) (WithZero.coe.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => Multiplicative.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => Multiplicative.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) (Multiplicative.ofAdd.{u1} α) x))
-Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_coe_of_add WithZero.toMulBot_coe_ofAddₓ'. -/
 @[simp]
 theorem toMulBot_coe_ofAdd (x : α) :
     toMulBot.symm (Multiplicative.ofAdd (x : WithBot α)) = Multiplicative.ofAdd x :=
@@ -88,32 +61,14 @@ theorem toMulBot_coe_ofAdd (x : α) :
 
 variable [Preorder α] (a b : WithZero (Multiplicative α))
 
-/- warning: with_zero.to_mul_bot_strict_mono -> WithZero.toMulBot_strictMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α], StrictMono.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2)) (Multiplicative.preorder.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α], StrictMono.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2)) (Multiplicative.preorder.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1))
-Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_strict_mono WithZero.toMulBot_strictMonoₓ'. -/
 theorem toMulBot_strictMono : StrictMono (@toMulBot α _) := fun x y => id
 #align with_zero.to_mul_bot_strict_mono WithZero.toMulBot_strictMono
 
-/- warning: with_zero.to_mul_bot_le -> WithZero.toMulBot_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] (a : WithZero.{u1} (Multiplicative.{u1} α)) (b : WithZero.{u1} (Multiplicative.{u1} α)), Iff (LE.le.{u1} (Multiplicative.{u1} (WithBot.{u1} α)) (Multiplicative.hasLe.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) a) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) b)) (LE.le.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Preorder.toHasLe.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] (a : WithZero.{u1} (Multiplicative.{u1} α)) (b : WithZero.{u1} (Multiplicative.{u1} α)), Iff (LE.le.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) a) (instForAllLEMultiplicative.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) b)) (LE.le.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Preorder.toLE.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2))) a b)
-Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_le WithZero.toMulBot_leₓ'. -/
 @[simp]
 theorem toMulBot_le : toMulBot a ≤ toMulBot b ↔ a ≤ b :=
   Iff.rfl
 #align with_zero.to_mul_bot_le WithZero.toMulBot_le
 
-/- warning: with_zero.to_mul_bot_lt -> WithZero.toMulBot_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] (a : WithZero.{u1} (Multiplicative.{u1} α)) (b : WithZero.{u1} (Multiplicative.{u1} α)), Iff (LT.lt.{u1} (Multiplicative.{u1} (WithBot.{u1} α)) (Multiplicative.hasLt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) a) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) b)) (LT.lt.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Preorder.toHasLt.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] (a : WithZero.{u1} (Multiplicative.{u1} α)) (b : WithZero.{u1} (Multiplicative.{u1} α)), Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) a) (instForAllLTMultiplicative.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) b)) (LT.lt.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Preorder.toLT.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2))) a b)
-Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_lt WithZero.toMulBot_ltₓ'. -/
 @[simp]
 theorem toMulBot_lt : toMulBot a < toMulBot b ↔ a < b :=
   Iff.rfl

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -55,10 +55,7 @@ theorem toMulBot_zero : toMulBot (0 : WithZero (Multiplicative α)) = Multiplica
 #align with_zero.to_mul_bot_zero WithZero.toMulBot_zero
 
 /- warning: with_zero.to_mul_bot_coe -> WithZero.toMulBot_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : Multiplicative.{u1} α), Eq.{succ u1} (Multiplicative.{u1} (WithBot.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.hasCoeT.{u1} (Multiplicative.{u1} α)))) x)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) => (Multiplicative.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.toAdd.{u1} α) x)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : Multiplicative.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.coe.{u1} (Multiplicative.{u1} α) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (fun (_x : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1)))))) (WithZero.toMulBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1) (WithZero.coe.{u1} (Multiplicative.{u1} α) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)))) (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (fun (_x : WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithBot.some.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.{u1} α) (fun (_x : Multiplicative.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.toAdd.{u1} α) x)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_coe WithZero.toMulBot_coeₓ'. -/
 @[simp]
 theorem toMulBot_coe (x : Multiplicative α) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

@@ -47,7 +47,7 @@ def toMulBot : WithZero (Multiplicative α) ≃* Multiplicative (WithBot α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} (Multiplicative.{u1} (WithBot.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (OfNat.mk.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.zero.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.toOfNat0.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.toOfNat0.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.toOfNat0.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.toOfNat0.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))
 Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_zero WithZero.toMulBot_zeroₓ'. -/
 @[simp]
 theorem toMulBot_zero : toMulBot (0 : WithZero (Multiplicative α)) = Multiplicative.ofAdd ⊥ :=
@@ -58,7 +58,7 @@ theorem toMulBot_zero : toMulBot (0 : WithZero (Multiplicative α)) = Multiplica
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : Multiplicative.{u1} α), Eq.{succ u1} (Multiplicative.{u1} (WithBot.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.hasCoeT.{u1} (Multiplicative.{u1} α)))) x)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) => (Multiplicative.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.toAdd.{u1} α) x)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : Multiplicative.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.coe.{u1} (Multiplicative.{u1} α) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (fun (_x : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1)))))) (WithZero.toMulBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1) (WithZero.coe.{u1} (Multiplicative.{u1} α) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)))) (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (fun (_x : WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithBot.some.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.{u1} α) (fun (_x : Multiplicative.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.toAdd.{u1} α) x)))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : Multiplicative.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.coe.{u1} (Multiplicative.{u1} α) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (fun (_x : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1)))))) (WithZero.toMulBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) _inst_1) (WithZero.coe.{u1} (Multiplicative.{u1} α) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)))) (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (fun (_x : WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x)))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x))) (WithBot.some.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.{u1} α) (fun (_x : Multiplicative.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Multiplicative.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.toAdd.{u1} α) x)))
 Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_coe WithZero.toMulBot_coeₓ'. -/
 @[simp]
 theorem toMulBot_coe (x : Multiplicative α) :
@@ -70,7 +70,7 @@ theorem toMulBot_coe (x : Multiplicative α) :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} (WithZero.{u1} (Multiplicative.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) => (Multiplicative.{u1} (WithBot.{u1} α)) -> (WithZero.{u1} (Multiplicative.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (OfNat.mk.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.zero.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (fun (_x : Multiplicative.{u1} (WithBot.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))))))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) 0 (Zero.toOfNat0.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (WithZero.zero.{u1} (Multiplicative.{u1} α))))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (fun (_x : Multiplicative.{u1} (WithBot.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))))))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) 0 (Zero.toOfNat0.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (WithZero.zero.{u1} (Multiplicative.{u1} α))))
 Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_symm_bot WithZero.toMulBot_symm_botₓ'. -/
 @[simp]
 theorem toMulBot_symm_bot : toMulBot.symm (Multiplicative.ofAdd (⊥ : WithBot α)) = 0 :=
@@ -81,7 +81,7 @@ theorem toMulBot_symm_bot : toMulBot.symm (Multiplicative.ofAdd (⊥ : WithBot 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : α), Eq.{succ u1} (WithZero.{u1} (Multiplicative.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) => (Multiplicative.{u1} (WithBot.{u1} α)) -> (WithZero.{u1} (Multiplicative.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.hasCoeT.{u1} (Multiplicative.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) => α -> (Multiplicative.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (Multiplicative.{u1} α)) (Multiplicative.ofAdd.{u1} α) x))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (WithBot.some.{u1} α x))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (fun (_x : Multiplicative.{u1} (WithBot.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))))))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (WithBot.some.{u1} α x))) (WithZero.coe.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => Multiplicative.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => Multiplicative.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) (Multiplicative.ofAdd.{u1} α) x))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (WithBot.some.{u1} α x))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (fun (_x : Multiplicative.{u1} (WithBot.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))))))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (WithBot.some.{u1} α x))) (WithZero.coe.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => Multiplicative.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => Multiplicative.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) (Multiplicative.ofAdd.{u1} α) x))
 Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_coe_of_add WithZero.toMulBot_coe_ofAddₓ'. -/
 @[simp]
 theorem toMulBot_coe_ofAdd (x : α) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

@@ -102,7 +102,7 @@ theorem toMulBot_strictMono : StrictMono (@toMulBot α _) := fun x y => id
 
 /- warning: with_zero.to_mul_bot_le -> WithZero.toMulBot_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] (a : WithZero.{u1} (Multiplicative.{u1} α)) (b : WithZero.{u1} (Multiplicative.{u1} α)), Iff (LE.le.{u1} (Multiplicative.{u1} (WithBot.{u1} α)) (Multiplicative.hasLe.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) a) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) b)) (LE.le.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Preorder.toLE.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2))) a b)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] (a : WithZero.{u1} (Multiplicative.{u1} α)) (b : WithZero.{u1} (Multiplicative.{u1} α)), Iff (LE.le.{u1} (Multiplicative.{u1} (WithBot.{u1} α)) (Multiplicative.hasLe.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) a) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) b)) (LE.le.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Preorder.toHasLe.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2))) a b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] (a : WithZero.{u1} (Multiplicative.{u1} α)) (b : WithZero.{u1} (Multiplicative.{u1} α)), Iff (LE.le.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) a) (instForAllLEMultiplicative.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) b)) (LE.le.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Preorder.toLE.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2))) a b)
 Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_le WithZero.toMulBot_leₓ'. -/
@@ -113,7 +113,7 @@ theorem toMulBot_le : toMulBot a ≤ toMulBot b ↔ a ≤ b :=
 
 /- warning: with_zero.to_mul_bot_lt -> WithZero.toMulBot_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] (a : WithZero.{u1} (Multiplicative.{u1} α)) (b : WithZero.{u1} (Multiplicative.{u1} α)), Iff (LT.lt.{u1} (Multiplicative.{u1} (WithBot.{u1} α)) (Multiplicative.hasLt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) a) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) b)) (LT.lt.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Preorder.toLT.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2))) a b)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] (a : WithZero.{u1} (Multiplicative.{u1} α)) (b : WithZero.{u1} (Multiplicative.{u1} α)), Iff (LT.lt.{u1} (Multiplicative.{u1} (WithBot.{u1} α)) (Multiplicative.hasLt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) a) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) b)) (LT.lt.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Preorder.toHasLt.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2))) a b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] (a : WithZero.{u1} (Multiplicative.{u1} α)) (b : WithZero.{u1} (Multiplicative.{u1} α)), Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) a) (instForAllLTMultiplicative.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) b)) (LT.lt.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Preorder.toLT.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.preorder.{u1} (Multiplicative.{u1} α) (Multiplicative.preorder.{u1} α _inst_2))) a b)
 Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_lt WithZero.toMulBot_ltₓ'. -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

@@ -47,7 +47,7 @@ def toMulBot : WithZero (Multiplicative α) ≃* Multiplicative (WithBot α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} (Multiplicative.{u1} (WithBot.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (OfNat.mk.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.zero.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.toOfNat0.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.toOfNat0.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.toOfNat0.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (fun (_x : WithZero.{u1} (Multiplicative.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} α)) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1))) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)))))) (WithZero.toMulBot.{u1} α _inst_1) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.toOfNat0.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))
 Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_zero WithZero.toMulBot_zeroₓ'. -/
 @[simp]
 theorem toMulBot_zero : toMulBot (0 : WithZero (Multiplicative α)) = Multiplicative.ofAdd ⊥ :=
@@ -58,7 +58,7 @@ theorem toMulBot_zero : toMulBot (0 : WithZero (Multiplicative α)) = Multiplica
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : Multiplicative.{u1} α), Eq.{succ u1} (Multiplicative.{u1} (WithBot.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (fun (_x : MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) => (WithZero.{u1} (Multiplicative.{u1} α)) -> (Multiplicative.{u1} (WithBot.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (WithZero.toMulBot.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.hasCoeT.{u1} (Multiplicative.{u1} α)))) x)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) => (Multiplicative.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.toAdd.{u1} α) x)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : Multiplicative.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (WithZero.coe.{u1} (Multiplicative.{u1} α) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (fun (_x : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1)))))) (WithZero.toMulBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) _inst_1) (WithZero.coe.{u1} (Multiplicative.{u1} α) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)))) (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (fun (_x : WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x)))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x))) (WithBot.some.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.{u1} α) (fun (_x : Multiplicative.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Multiplicative.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.toAdd.{u1} α) x)))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : Multiplicative.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.coe.{u1} (Multiplicative.{u1} α) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (fun (_x : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.mul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (WithBot.add.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1)))))) (WithZero.toMulBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) _inst_1) (WithZero.coe.{u1} (Multiplicative.{u1} α) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)))) (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (fun (_x : WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) => Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)) (Multiplicative.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x)))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x))) (WithBot.some.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.{u1} α) (fun (_x : Multiplicative.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Multiplicative.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Multiplicative.{u1} α) α) (Multiplicative.toAdd.{u1} α) x)))
 Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_coe WithZero.toMulBot_coeₓ'. -/
 @[simp]
 theorem toMulBot_coe (x : Multiplicative α) :
@@ -70,7 +70,7 @@ theorem toMulBot_coe (x : Multiplicative α) :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} (WithZero.{u1} (Multiplicative.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) => (Multiplicative.{u1} (WithBot.{u1} α)) -> (WithZero.{u1} (Multiplicative.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (OfNat.ofNat.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (OfNat.mk.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) 0 (Zero.zero.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.zero.{u1} (Multiplicative.{u1} α)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (fun (_x : Multiplicative.{u1} (WithBot.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))))))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) 0 (Zero.toOfNat0.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (WithZero.zero.{u1} (Multiplicative.{u1} α))))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (fun (_x : Multiplicative.{u1} (WithBot.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))))))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) 0 (Zero.toOfNat0.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (WithZero.zero.{u1} (Multiplicative.{u1} α))))
 Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_symm_bot WithZero.toMulBot_symm_botₓ'. -/
 @[simp]
 theorem toMulBot_symm_bot : toMulBot.symm (Multiplicative.ofAdd (⊥ : WithBot α)) = 0 :=
@@ -81,7 +81,7 @@ theorem toMulBot_symm_bot : toMulBot.symm (Multiplicative.ofAdd (⊥ : WithBot 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : α), Eq.{succ u1} (WithZero.{u1} (Multiplicative.{u1} α)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) => (Multiplicative.{u1} (WithBot.{u1} α)) -> (WithZero.{u1} (Multiplicative.{u1} α))) (MulEquiv.hasCoeToFun.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1)))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toHasMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.hasMul.{u1} α _inst_1))) (Multiplicative.hasMul.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) => (WithBot.{u1} α) -> (Multiplicative.{u1} (WithBot.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Multiplicative.{u1} α) (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.hasCoeT.{u1} (Multiplicative.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) => α -> (Multiplicative.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (Multiplicative.{u1} α)) (Multiplicative.ofAdd.{u1} α) x))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (WithBot.some.{u1} α x))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (fun (_x : Multiplicative.{u1} (WithBot.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))))))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (WithBot.some.{u1} α x))) (WithZero.coe.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => Multiplicative.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => Multiplicative.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) (Multiplicative.ofAdd.{u1} α) x))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (a : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (WithBot.some.{u1} α x))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (fun (_x : Multiplicative.{u1} (WithBot.{u1} α)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Multiplicative.{u1} (WithBot.{u1} α)) => WithZero.{u1} (Multiplicative.{u1} α)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1)))) (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Multiplicative.{u1} (WithBot.{u1} α)) (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))))))) (MulEquiv.symm.{u1, u1} (WithZero.{u1} (Multiplicative.{u1} α)) (Multiplicative.{u1} (WithBot.{u1} α)) (MulZeroClass.toMul.{u1} (WithZero.{u1} (Multiplicative.{u1} α)) (WithZero.mulZeroClass.{u1} (Multiplicative.{u1} α) (Multiplicative.mul.{u1} α _inst_1))) (Multiplicative.mul.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) (WithZero.toMulBot.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => Multiplicative.{u1} (WithBot.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (Multiplicative.{u1} (WithBot.{u1} α))) (Multiplicative.ofAdd.{u1} (WithBot.{u1} α)) (WithBot.some.{u1} α x))) (WithZero.coe.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => Multiplicative.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => Multiplicative.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (Multiplicative.{u1} α)) (Multiplicative.ofAdd.{u1} α) x))
 Case conversion may be inaccurate. Consider using '#align with_zero.to_mul_bot_coe_of_add WithZero.toMulBot_coe_ofAddₓ'. -/
 @[simp]
 theorem toMulBot_coe_ofAdd (x : α) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

Everything under Algebra.Group should be additivisable. Therefore I move the GroupWithZero instances for WithZero from Algebra.Group.WithOne.Defs and the whole of Algebra.Group.WithOne.Units to a new file Algebra.GroupWithZero.WithZero. I credit Mario for https://github.com/leanprover-community/mathlib/commit/ad92a9ba47f417916aab365d13db653fa8991a84 and Johan for https://github.com/leanprover-community/mathlib/pull/762.

Use the opportunity to slightly clean up the code:

• Replace := by where in instance declarations
• Add missing explicit arguments to coe lemmas
• Add missing section ... end

@@ -3,7 +3,7 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
-import Mathlib.Algebra.Order.Monoid.WithZero
+import Mathlib.Algebra.Order.GroupWithZero.Canonical
 import Mathlib.Algebra.Order.Monoid.TypeTags
 import Mathlib.Algebra.Order.Monoid.WithTop
 import Mathlib.Algebra.Group.Equiv.Basic

Reconstitute the file Algebra.Order.Monoid.WithZero from three files:

• Algebra.Order.Monoid.WithZero.Defs
• Algebra.Order.Monoid.WithZero.Basic
• Algebra.Order.WithZero

Avoid importing it in many files. Most uses were just to get le_zero_iff to work on Nat.

Before

After

@@ -3,7 +3,7 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
-import Mathlib.Algebra.Order.Monoid.WithZero.Defs
+import Mathlib.Algebra.Order.Monoid.WithZero
 import Mathlib.Algebra.Order.Monoid.TypeTags
 import Mathlib.Algebra.Order.Monoid.WithTop
 import Mathlib.Algebra.Group.Equiv.Basic

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -3,9 +3,10 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
-import Mathlib.Algebra.Order.WithZero
-import Mathlib.Algebra.Order.Monoid.WithTop
+import Mathlib.Algebra.Order.Monoid.WithZero.Defs
 import Mathlib.Algebra.Order.Monoid.TypeTags
+import Mathlib.Algebra.Order.Monoid.WithTop
+import Mathlib.Algebra.Group.Equiv.Basic
 
 #align_import algebra.order.monoid.to_mul_bot from "leanprover-community/mathlib"@"ee0c179cd3c8a45aa5bffbf1b41d8dbede452865"
 

This eliminates (fun a ↦ β) α in the type when applying a FunLike.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -36,7 +36,7 @@ theorem toMulBot_zero : toMulBot (0 : WithZero (Multiplicative α)) = Multiplica
 
 @[simp]
 theorem toMulBot_coe (x : Multiplicative α) :
-    toMulBot ↑x = Multiplicative.ofAdd (Multiplicative.toAdd x : WithBot α) :=
+    toMulBot ↑x = Multiplicative.ofAdd (↑(Multiplicative.toAdd x) : WithBot α) :=
   rfl
 #align with_zero.to_mul_bot_coe WithZero.toMulBot_coe
 

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,16 +2,13 @@
 Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
-
-! This file was ported from Lean 3 source module algebra.order.monoid.to_mul_bot
-! leanprover-community/mathlib commit ee0c179cd3c8a45aa5bffbf1b41d8dbede452865
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.WithZero
 import Mathlib.Algebra.Order.Monoid.WithTop
 import Mathlib.Algebra.Order.Monoid.TypeTags
 
+#align_import algebra.order.monoid.to_mul_bot from "leanprover-community/mathlib"@"ee0c179cd3c8a45aa5bffbf1b41d8dbede452865"
+
 /-!
 Making an additive monoid multiplicative then adding a zero is the same as adding a bottom
 element then making it multiplicative.

The script used to do this is included. The yaml file was obtained from https://raw.githubusercontent.com/wiki/leanprover-community/mathlib/mathlib4-port-status.md

@@ -2,6 +2,11 @@
 Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
+
+! This file was ported from Lean 3 source module algebra.order.monoid.to_mul_bot
+! leanprover-community/mathlib commit ee0c179cd3c8a45aa5bffbf1b41d8dbede452865
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.WithZero
 import Mathlib.Algebra.Order.Monoid.WithTop