algebra.ring.boolean_ring ⟷ Mathlib.Algebra.Ring.BooleanRing

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -3,7 +3,7 @@ Copyright (c) 2021 Bryan Gin-ge Chen. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Bryan Gin-ge Chen, Yaël Dillies
 -/
-import Algebra.PunitInstances
+import Algebra.PUnitInstances
 import Tactic.Abel
 import Tactic.Ring
 import Order.Hom.Lattice

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -76,7 +76,7 @@ theorem add_self : a + a = 0 :=
       a + a = (a + a) * (a + a) := by rw [mul_self]
       _ = a * a + a * a + (a * a + a * a) := by rw [add_mul, mul_add]
       _ = a + a + (a + a) := by rw [mul_self]
-  rwa [self_eq_add_left] at this 
+  rwa [self_eq_add_left] at this
 #align add_self add_self
 -/
 
@@ -108,7 +108,7 @@ theorem mul_add_mul : a * b + b * a = 0 :=
       _ = a * a + a * b + (b * a + b * b) := by rw [add_mul, mul_add, mul_add]
       _ = a + a * b + (b * a + b) := by simp only [mul_self]
       _ = a + b + (a * b + b * a) := by abel
-  rwa [self_eq_add_right] at this 
+  rwa [self_eq_add_right] at this
 #align mul_add_mul mul_add_mul
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -57,7 +57,7 @@ section BooleanRing
 
 variable [BooleanRing α] (a b : α)
 
-instance : IsIdempotent α (· * ·) :=
+instance : Std.IdempotentOp α (· * ·) :=
   ⟨BooleanRing.hMul_self⟩
 
 #print mul_self /-

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

@@ -3,10 +3,10 @@ Copyright (c) 2021 Bryan Gin-ge Chen. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Bryan Gin-ge Chen, Yaël Dillies
 -/
-import Mathbin.Algebra.PunitInstances
-import Mathbin.Tactic.Abel
-import Mathbin.Tactic.Ring
-import Mathbin.Order.Hom.Lattice
+import Algebra.PunitInstances
+import Tactic.Abel
+import Tactic.Ring
+import Order.Hom.Lattice
 
 #align_import algebra.ring.boolean_ring from "leanprover-community/mathlib"@"6cf5900728239efa287df7761ec2a1ac9cf39b29"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

@@ -49,7 +49,7 @@ variable {α β γ : Type _}
 #print BooleanRing /-
 /-- A Boolean ring is a ring where multiplication is idempotent. -/
 class BooleanRing (α) extends Ring α where
-  mul_self : ∀ a : α, a * a = a
+  hMul_self : ∀ a : α, a * a = a
 #align boolean_ring BooleanRing
 -/
 
@@ -58,12 +58,12 @@ section BooleanRing
 variable [BooleanRing α] (a b : α)
 
 instance : IsIdempotent α (· * ·) :=
-  ⟨BooleanRing.mul_self⟩
+  ⟨BooleanRing.hMul_self⟩
 
 #print mul_self /-
 @[simp]
 theorem mul_self : a * a = a :=
-  BooleanRing.mul_self _
+  BooleanRing.hMul_self _
 #align mul_self mul_self
 -/
 
@@ -581,7 +581,7 @@ def BooleanAlgebra.toBooleanRing : BooleanRing α :=
     one := ⊤
     one_mul := fun _ => top_inf_eq
     mul_one := fun _ => inf_top_eq
-    mul_self := fun b => inf_idem }
+    hMul_self := fun b => inf_idem }
 #align boolean_algebra.to_boolean_ring BooleanAlgebra.toBooleanRing
 -/
 
@@ -748,5 +748,5 @@ instance : BooleanRing Bool where
   mul_one := Bool.and_true
   left_distrib := and_xor_distrib_left
   right_distrib := and_xor_distrib_right
-  mul_self := Bool.and_self
+  hMul_self := Bool.and_self
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

@@ -682,7 +682,7 @@ protected def BoundedLatticeHom.asBoolRing (f : BoundedLatticeHom α β) :
   toFun := toBoolRing ∘ f ∘ ofBoolRing
   map_zero' := f.map_bot'
   map_one' := f.map_top'
-  map_add' := map_symm_diff' f
+  map_add' := map_symmDiff' f
   map_mul' := f.map_inf'
 #align bounded_lattice_hom.as_boolring BoundedLatticeHom.asBoolRing
 -/

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

@@ -2,17 +2,14 @@
 Copyright (c) 2021 Bryan Gin-ge Chen. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Bryan Gin-ge Chen, Yaël Dillies
-
-! This file was ported from Lean 3 source module algebra.ring.boolean_ring
-! leanprover-community/mathlib commit 6cf5900728239efa287df7761ec2a1ac9cf39b29
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.PunitInstances
 import Mathbin.Tactic.Abel
 import Mathbin.Tactic.Ring
 import Mathbin.Order.Hom.Lattice
 
+#align_import algebra.ring.boolean_ring from "leanprover-community/mathlib"@"6cf5900728239efa287df7761ec2a1ac9cf39b29"
+
 /-!
 # Boolean rings
 

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

@@ -63,11 +63,14 @@ variable [BooleanRing α] (a b : α)
 instance : IsIdempotent α (· * ·) :=
   ⟨BooleanRing.mul_self⟩
 
+#print mul_self /-
 @[simp]
 theorem mul_self : a * a = a :=
   BooleanRing.mul_self _
 #align mul_self mul_self
+-/
 
+#print add_self /-
 @[simp]
 theorem add_self : a + a = 0 :=
   by
@@ -78,7 +81,9 @@ theorem add_self : a + a = 0 :=
       _ = a + a + (a + a) := by rw [mul_self]
   rwa [self_eq_add_left] at this 
 #align add_self add_self
+-/
 
+#print neg_eq /-
 @[simp]
 theorem neg_eq : -a = a :=
   calc
@@ -86,13 +91,17 @@ theorem neg_eq : -a = a :=
     _ = -a + -a + a := by rw [← neg_add_self, add_assoc]
     _ = a := by rw [add_self, zero_add]
 #align neg_eq neg_eq
+-/
 
+#print add_eq_zero' /-
 theorem add_eq_zero' : a + b = 0 ↔ a = b :=
   calc
     a + b = 0 ↔ a = -b := add_eq_zero_iff_eq_neg
     _ ↔ a = b := by rw [neg_eq]
 #align add_eq_zero' add_eq_zero'
+-/
 
+#print mul_add_mul /-
 @[simp]
 theorem mul_add_mul : a * b + b * a = 0 :=
   by
@@ -104,14 +113,19 @@ theorem mul_add_mul : a * b + b * a = 0 :=
       _ = a + b + (a * b + b * a) := by abel
   rwa [self_eq_add_right] at this 
 #align mul_add_mul mul_add_mul
+-/
 
+#print sub_eq_add /-
 @[simp]
 theorem sub_eq_add : a - b = a + b := by rw [sub_eq_add_neg, add_right_inj, neg_eq]
 #align sub_eq_add sub_eq_add
+-/
 
+#print mul_one_add_self /-
 @[simp]
 theorem mul_one_add_self : a * (1 + a) = 0 := by rw [mul_add, mul_one, mul_self, add_self]
 #align mul_one_add_self mul_one_add_self
+-/
 
 #print BooleanRing.toCommRing /-
 -- Note [lower instance priority]
@@ -254,6 +268,7 @@ theorem inf_sup_self (a b : α) : a ⊓ (a ⊔ b) = a :=
 #align boolean_ring.inf_sup_self BooleanRing.inf_sup_self
 -/
 
+#print BooleanRing.le_sup_inf_aux /-
 theorem le_sup_inf_aux (a b c : α) : (a + b + a * b) * (a + c + a * c) = a + b * c + a * (b * c) :=
   calc
     (a + b + a * b) * (a + c + a * c) =
@@ -262,6 +277,7 @@ theorem le_sup_inf_aux (a b c : α) : (a + b + a * b) * (a + c + a * c) = a + b
       by ring
     _ = a + b * c + a * (b * c) := by simp only [mul_self, add_self, add_zero]
 #align boolean_ring.le_sup_inf_aux BooleanRing.le_sup_inf_aux
+-/
 
 #print BooleanRing.le_sup_inf /-
 theorem le_sup_inf (a b c : α) : (a ⊔ b) ⊓ (a ⊔ c) ⊔ (a ⊔ b ⊓ c) = a ⊔ b ⊓ c := by
@@ -366,11 +382,13 @@ theorem ofBoolAlg_symmDiff (a b : AsBoolAlg α) : ofBoolAlg (a ∆ b) = ofBoolAl
 #align of_boolalg_symm_diff ofBoolAlg_symmDiff
 -/
 
+#print ofBoolAlg_mul_ofBoolAlg_eq_left_iff /-
 @[simp]
 theorem ofBoolAlg_mul_ofBoolAlg_eq_left_iff {a b : AsBoolAlg α} :
     ofBoolAlg a * ofBoolAlg b = ofBoolAlg a ↔ a ≤ b :=
   @inf_eq_left (AsBoolAlg α) _ _ _
 #align of_boolalg_mul_of_boolalg_eq_left_iff ofBoolAlg_mul_ofBoolAlg_eq_left_iff
+-/
 
 #print toBoolAlg_zero /-
 @[simp]
@@ -432,11 +450,13 @@ theorem RingHom.asBoolAlg_id : (RingHom.id α).AsBoolAlg = BoundedLatticeHom.id
 #align ring_hom.as_boolalg_id RingHom.asBoolAlg_id
 -/
 
+#print RingHom.asBoolAlg_comp /-
 @[simp]
 theorem RingHom.asBoolAlg_comp (g : β →+* γ) (f : α →+* β) :
     (g.comp f).AsBoolAlg = g.AsBoolAlg.comp f.AsBoolAlg :=
   rfl
 #align ring_hom.as_boolalg_comp RingHom.asBoolAlg_comp
+-/
 
 end RingToAlgebra
 
@@ -677,11 +697,13 @@ theorem BoundedLatticeHom.asBoolRing_id : (BoundedLatticeHom.id α).AsBoolRing =
 #align bounded_lattice_hom.as_boolring_id BoundedLatticeHom.asBoolRing_id
 -/
 
+#print BoundedLatticeHom.asBoolRing_comp /-
 @[simp]
 theorem BoundedLatticeHom.asBoolRing_comp (g : BoundedLatticeHom β γ) (f : BoundedLatticeHom α β) :
     (g.comp f).AsBoolRing = g.AsBoolRing.comp f.AsBoolRing :=
   rfl
 #align bounded_lattice_hom.as_boolring_comp BoundedLatticeHom.asBoolRing_comp
+-/
 
 end AlgebraToRing
 
@@ -698,6 +720,7 @@ def OrderIso.asBoolAlgAsBoolRing (α : Type _) [BooleanAlgebra α] : AsBoolAlg (
 #align order_iso.as_boolalg_as_boolring OrderIso.asBoolAlgAsBoolRing
 -/
 
+#print RingEquiv.asBoolRingAsBoolAlg /-
 /-- Ring isomorphism between `α` considered as a Boolean algebra considered as a Boolean ring and
 `α`. -/
 @[simps]
@@ -706,6 +729,7 @@ def RingEquiv.asBoolRingAsBoolAlg (α : Type _) [BooleanRing α] : AsBoolRing (A
     map_mul' := fun a b => rfl
     map_add' := ofBoolAlg_symmDiff }
 #align ring_equiv.as_boolring_as_boolalg RingEquiv.asBoolRingAsBoolAlg
+-/
 
 open Bool
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

@@ -76,7 +76,6 @@ theorem add_self : a + a = 0 :=
       a + a = (a + a) * (a + a) := by rw [mul_self]
       _ = a * a + a * a + (a * a + a * a) := by rw [add_mul, mul_add]
       _ = a + a + (a + a) := by rw [mul_self]
-      
   rwa [self_eq_add_left] at this 
 #align add_self add_self
 
@@ -86,14 +85,12 @@ theorem neg_eq : -a = a :=
     -a = -a + 0 := by rw [add_zero]
     _ = -a + -a + a := by rw [← neg_add_self, add_assoc]
     _ = a := by rw [add_self, zero_add]
-    
 #align neg_eq neg_eq
 
 theorem add_eq_zero' : a + b = 0 ↔ a = b :=
   calc
     a + b = 0 ↔ a = -b := add_eq_zero_iff_eq_neg
     _ ↔ a = b := by rw [neg_eq]
-    
 #align add_eq_zero' add_eq_zero'
 
 @[simp]
@@ -105,7 +102,6 @@ theorem mul_add_mul : a * b + b * a = 0 :=
       _ = a * a + a * b + (b * a + b * b) := by rw [add_mul, mul_add, mul_add]
       _ = a + a * b + (b * a + b) := by simp only [mul_self]
       _ = a + b + (a * b + b * a) := by abel
-      
   rwa [self_eq_add_right] at this 
 #align mul_add_mul mul_add_mul
 
@@ -265,7 +261,6 @@ theorem le_sup_inf_aux (a b c : α) : (a + b + a * b) * (a + c + a * c) = a + b
           (a * b * c + a * a * b * c) :=
       by ring
     _ = a + b * c + a * (b * c) := by simp only [mul_self, add_self, add_zero]
-    
 #align boolean_ring.le_sup_inf_aux BooleanRing.le_sup_inf_aux
 
 #print BooleanRing.le_sup_inf /-
@@ -363,7 +358,6 @@ private theorem of_boolalg_symm_diff_aux (a b : α) : (a + b + a * b) * (1 + a *
     (a + b + a * b) * (1 + a * b) = a + b + (a * b + a * b * (a * b)) + (a * (b * b) + a * a * b) :=
       by ring
     _ = a + b := by simp only [mul_self, add_self, add_zero]
-    
 
 #print ofBoolAlg_symmDiff /-
 @[simp]

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

@@ -77,7 +77,7 @@ theorem add_self : a + a = 0 :=
       _ = a * a + a * a + (a * a + a * a) := by rw [add_mul, mul_add]
       _ = a + a + (a + a) := by rw [mul_self]
       
-  rwa [self_eq_add_left] at this
+  rwa [self_eq_add_left] at this 
 #align add_self add_self
 
 @[simp]
@@ -106,7 +106,7 @@ theorem mul_add_mul : a * b + b * a = 0 :=
       _ = a + a * b + (b * a + b) := by simp only [mul_self]
       _ = a + b + (a * b + b * a) := by abel
       
-  rwa [self_eq_add_right] at this
+  rwa [self_eq_add_right] at this 
 #align mul_add_mul mul_add_mul
 
 @[simp]
@@ -575,8 +575,8 @@ def BooleanAlgebra.toBooleanRing : BooleanRing α :=
 -/
 
 scoped[BooleanRingOfBooleanAlgebra]
-  attribute [instance 100]
-    GeneralizedBooleanAlgebra.toNonUnitalCommRing BooleanAlgebra.toBooleanRing
+  attribute [instance 100] GeneralizedBooleanAlgebra.toNonUnitalCommRing
+    BooleanAlgebra.toBooleanRing
 
 instance : BooleanRing (AsBoolRing α) :=
   @BooleanAlgebra.toBooleanRing α _

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

@@ -625,11 +625,13 @@ theorem ofBoolRing_mul (a b : AsBoolRing α) : ofBoolRing (a * b) = ofBoolRing a
 #align of_boolring_mul ofBoolRing_mul
 -/
 
+#print ofBoolRing_le_ofBoolRing_iff /-
 @[simp]
 theorem ofBoolRing_le_ofBoolRing_iff {a b : AsBoolRing α} :
     ofBoolRing a ≤ ofBoolRing b ↔ a * b = a :=
   inf_eq_left.symm
 #align of_boolring_le_of_boolring_iff ofBoolRing_le_ofBoolRing_iff
+-/
 
 #print toBoolRing_bot /-
 @[simp]
@@ -692,6 +694,7 @@ end AlgebraToRing
 /-! ### Equivalence between Boolean rings and Boolean algebras -/
 
 
+#print OrderIso.asBoolAlgAsBoolRing /-
 /-- Order isomorphism between `α` considered as a Boolean ring considered as a Boolean algebra and
 `α`. -/
 @[simps]
@@ -699,6 +702,7 @@ def OrderIso.asBoolAlgAsBoolRing (α : Type _) [BooleanAlgebra α] : AsBoolAlg (
   ⟨ofBoolAlg.trans ofBoolRing, fun a b =>
     ofBoolRing_le_ofBoolRing_iff.trans ofBoolAlg_mul_ofBoolAlg_eq_left_iff⟩
 #align order_iso.as_boolalg_as_boolring OrderIso.asBoolAlgAsBoolRing
+-/
 
 /-- Ring isomorphism between `α` considered as a Boolean algebra considered as a Boolean ring and
 `α`. -/

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

@@ -63,23 +63,11 @@ variable [BooleanRing α] (a b : α)
 instance : IsIdempotent α (· * ·) :=
   ⟨BooleanRing.mul_self⟩
 
-/- warning: mul_self -> mul_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a a) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a a) a
-Case conversion may be inaccurate. Consider using '#align mul_self mul_selfₓ'. -/
 @[simp]
 theorem mul_self : a * a = a :=
   BooleanRing.mul_self _
 #align mul_self mul_self
 
-/- warning: add_self -> add_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a a) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a a) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α (Ring.toSemiring.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align add_self add_selfₓ'. -/
 @[simp]
 theorem add_self : a + a = 0 :=
   by
@@ -92,12 +80,6 @@ theorem add_self : a + a = 0 :=
   rwa [self_eq_add_left] at this
 #align add_self add_self
 
-/- warning: neg_eq -> neg_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))) a) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (Neg.neg.{u1} α (Ring.toNeg.{u1} α (BooleanRing.toRing.{u1} α _inst_1)) a) a
-Case conversion may be inaccurate. Consider using '#align neg_eq neg_eqₓ'. -/
 @[simp]
 theorem neg_eq : -a = a :=
   calc
@@ -107,12 +89,6 @@ theorem neg_eq : -a = a :=
     
 #align neg_eq neg_eq
 
-/- warning: add_eq_zero' -> add_eq_zero' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Iff (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))))))) (Eq.{succ u1} α a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Iff (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α (Ring.toSemiring.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (Eq.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align add_eq_zero' add_eq_zero'ₓ'. -/
 theorem add_eq_zero' : a + b = 0 ↔ a = b :=
   calc
     a + b = 0 ↔ a = -b := add_eq_zero_iff_eq_neg
@@ -120,12 +96,6 @@ theorem add_eq_zero' : a + b = 0 ↔ a = b :=
     
 #align add_eq_zero' add_eq_zero'
 
-/- warning: mul_add_mul -> mul_add_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) b a)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) b a)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α (Ring.toSemiring.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align mul_add_mul mul_add_mulₓ'. -/
 @[simp]
 theorem mul_add_mul : a * b + b * a = 0 :=
   by
@@ -139,22 +109,10 @@ theorem mul_add_mul : a * b + b * a = 0 :=
   rwa [self_eq_add_right] at this
 #align mul_add_mul mul_add_mul
 
-/- warning: sub_eq_add -> sub_eq_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (Ring.toSub.{u1} α (BooleanRing.toRing.{u1} α _inst_1))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a b)
-Case conversion may be inaccurate. Consider using '#align sub_eq_add sub_eq_addₓ'. -/
 @[simp]
 theorem sub_eq_add : a - b = a + b := by rw [sub_eq_add_neg, add_right_inj, neg_eq]
 #align sub_eq_add sub_eq_add
 
-/- warning: mul_one_add_self -> mul_one_add_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))))) a)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Semiring.toOne.{u1} α (Ring.toSemiring.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α (Ring.toSemiring.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align mul_one_add_self mul_one_add_selfₓ'. -/
 @[simp]
 theorem mul_one_add_self : a * (1 + a) = 0 := by rw [mul_add, mul_one, mul_self, add_self]
 #align mul_one_add_self mul_one_add_self
@@ -300,12 +258,6 @@ theorem inf_sup_self (a b : α) : a ⊓ (a ⊔ b) = a :=
 #align boolean_ring.inf_sup_self BooleanRing.inf_sup_self
 -/
 
-/- warning: boolean_ring.le_sup_inf_aux -> BooleanRing.le_sup_inf_aux is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α) (c : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a b)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a c))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) b c)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α) (c : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a b)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a c))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) b c)))
-Case conversion may be inaccurate. Consider using '#align boolean_ring.le_sup_inf_aux BooleanRing.le_sup_inf_auxₓ'. -/
 theorem le_sup_inf_aux (a b c : α) : (a + b + a * b) * (a + c + a * c) = a + b * c + a * (b * c) :=
   calc
     (a + b + a * b) * (a + c + a * c) =
@@ -420,12 +372,6 @@ theorem ofBoolAlg_symmDiff (a b : AsBoolAlg α) : ofBoolAlg (a ∆ b) = ofBoolAl
 #align of_boolalg_symm_diff ofBoolAlg_symmDiff
 -/
 
-/- warning: of_boolalg_mul_of_boolalg_eq_left_iff -> ofBoolAlg_mul_ofBoolAlg_eq_left_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] {a : AsBoolAlg.{u1} α} {b : AsBoolAlg.{u1} α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) b)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a)) (LE.le.{u1} (AsBoolAlg.{u1} α) (Preorder.toHasLe.{u1} (AsBoolAlg.{u1} α) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} α) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)))))))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] {a : AsBoolAlg.{u1} α} {b : AsBoolAlg.{u1} α}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) b) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (instHMul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (NonUnitalNonAssocRing.toMul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (NonAssocRing.toNonUnitalNonAssocRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (BooleanRing.toRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) b)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a)) (LE.le.{u1} (AsBoolAlg.{u1} α) (Preorder.toLE.{u1} (AsBoolAlg.{u1} α) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} α) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1))))))))) a b)
-Case conversion may be inaccurate. Consider using '#align of_boolalg_mul_of_boolalg_eq_left_iff ofBoolAlg_mul_ofBoolAlg_eq_left_iffₓ'. -/
 @[simp]
 theorem ofBoolAlg_mul_ofBoolAlg_eq_left_iff {a b : AsBoolAlg α} :
     ofBoolAlg a * ofBoolAlg b = ofBoolAlg a ↔ a ≤ b :=
@@ -492,12 +438,6 @@ theorem RingHom.asBoolAlg_id : (RingHom.id α).AsBoolAlg = BoundedLatticeHom.id
 #align ring_hom.as_boolalg_id RingHom.asBoolAlg_id
 -/
 
-/- warning: ring_hom.as_boolalg_comp -> RingHom.asBoolAlg_comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : BooleanRing.{u1} α] [_inst_2 : BooleanRing.{u2} β] [_inst_3 : BooleanRing.{u3} γ] (g : RingHom.{u2, u3} β γ (NonAssocRing.toNonAssocSemiring.{u2} β (Ring.toNonAssocRing.{u2} β (BooleanRing.toRing.{u2} β _inst_2))) (NonAssocRing.toNonAssocSemiring.{u3} γ (Ring.toNonAssocRing.{u3} γ (BooleanRing.toRing.{u3} γ _inst_3)))) (f : RingHom.{u1, u2} α β (NonAssocRing.toNonAssocSemiring.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} β (Ring.toNonAssocRing.{u2} β (BooleanRing.toRing.{u2} β _inst_2)))), Eq.{max (succ u1) (succ u3)} (BoundedLatticeHom.{u1, u3} (AsBoolAlg.{u1} α) (AsBoolAlg.{u3} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)))) (GeneralizedCoheytingAlgebra.toLattice.{u3} (AsBoolAlg.{u3} γ) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} (AsBoolAlg.{u3} γ) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} (AsBoolAlg.{u3} γ) (AsBoolAlg.booleanAlgebra.{u3} γ _inst_3)))) (BooleanAlgebra.toBoundedOrder.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)) (BooleanAlgebra.toBoundedOrder.{u3} (AsBoolAlg.{u3} γ) (AsBoolAlg.booleanAlgebra.{u3} γ _inst_3))) (RingHom.asBoolAlg.{u1, u3} α γ _inst_1 _inst_3 (RingHom.comp.{u1, u2, u3} α β γ (NonAssocRing.toNonAssocSemiring.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} β (Ring.toNonAssocRing.{u2} β (BooleanRing.toRing.{u2} β _inst_2))) (NonAssocRing.toNonAssocSemiring.{u3} γ (Ring.toNonAssocRing.{u3} γ (BooleanRing.toRing.{u3} γ _inst_3))) g f)) (BoundedLatticeHom.comp.{u1, u2, u3} (AsBoolAlg.{u1} α) (AsBoolAlg.{u2} β) (AsBoolAlg.{u3} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)))) (GeneralizedCoheytingAlgebra.toLattice.{u2} (AsBoolAlg.{u2} β) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} (AsBoolAlg.{u2} β) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} (AsBoolAlg.{u2} β) (AsBoolAlg.booleanAlgebra.{u2} β _inst_2)))) (GeneralizedCoheytingAlgebra.toLattice.{u3} (AsBoolAlg.{u3} γ) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} (AsBoolAlg.{u3} γ) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} (AsBoolAlg.{u3} γ) (AsBoolAlg.booleanAlgebra.{u3} γ _inst_3)))) (BooleanAlgebra.toBoundedOrder.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)) (BooleanAlgebra.toBoundedOrder.{u2} (AsBoolAlg.{u2} β) (AsBoolAlg.booleanAlgebra.{u2} β _inst_2)) (BooleanAlgebra.toBoundedOrder.{u3} (AsBoolAlg.{u3} γ) (AsBoolAlg.booleanAlgebra.{u3} γ _inst_3)) (RingHom.asBoolAlg.{u2, u3} β γ _inst_2 _inst_3 g) (RingHom.asBoolAlg.{u1, u2} α β _inst_1 _inst_2 f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u3}} {γ : Type.{u2}} [_inst_1 : BooleanRing.{u1} α] [_inst_2 : BooleanRing.{u3} β] [_inst_3 : BooleanRing.{u2} γ] (g : RingHom.{u3, u2} β γ (Semiring.toNonAssocSemiring.{u3} β (CommSemiring.toSemiring.{u3} β (CommRing.toCommSemiring.{u3} β (BooleanRing.toCommRing.{u3} β _inst_2)))) (Semiring.toNonAssocSemiring.{u2} γ (CommSemiring.toSemiring.{u2} γ (CommRing.toCommSemiring.{u2} γ (BooleanRing.toCommRing.{u2} γ _inst_3))))) (f : RingHom.{u1, u3} α β (Semiring.toNonAssocSemiring.{u1} α (CommSemiring.toSemiring.{u1} α (CommRing.toCommSemiring.{u1} α (BooleanRing.toCommRing.{u1} α _inst_1)))) (Semiring.toNonAssocSemiring.{u3} β (CommSemiring.toSemiring.{u3} β (CommRing.toCommSemiring.{u3} β (BooleanRing.toCommRing.{u3} β _inst_2))))), Eq.{max (succ u1) (succ u2)} (BoundedLatticeHom.{u1, u2} (AsBoolAlg.{u1} α) (AsBoolAlg.{u2} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1))))) (GeneralizedCoheytingAlgebra.toLattice.{u2} (AsBoolAlg.{u2} γ) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (BooleanAlgebra.toBiheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (instBooleanAlgebraAsBoolAlg.{u2} γ _inst_3))))) (BooleanAlgebra.toBoundedOrder.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1)) (BooleanAlgebra.toBoundedOrder.{u2} (AsBoolAlg.{u2} γ) (instBooleanAlgebraAsBoolAlg.{u2} γ _inst_3))) (RingHom.asBoolAlg.{u1, u2} α γ _inst_1 _inst_3 (RingHom.comp.{u1, u3, u2} α β γ (Semiring.toNonAssocSemiring.{u1} α (CommSemiring.toSemiring.{u1} α (CommRing.toCommSemiring.{u1} α (BooleanRing.toCommRing.{u1} α _inst_1)))) (Semiring.toNonAssocSemiring.{u3} β (CommSemiring.toSemiring.{u3} β (CommRing.toCommSemiring.{u3} β (BooleanRing.toCommRing.{u3} β _inst_2)))) (Semiring.toNonAssocSemiring.{u2} γ (CommSemiring.toSemiring.{u2} γ (CommRing.toCommSemiring.{u2} γ (BooleanRing.toCommRing.{u2} γ _inst_3)))) g f)) (BoundedLatticeHom.comp.{u1, u3, u2} (AsBoolAlg.{u1} α) (AsBoolAlg.{u3} β) (AsBoolAlg.{u2} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1))))) (GeneralizedCoheytingAlgebra.toLattice.{u3} (AsBoolAlg.{u3} β) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u3} (AsBoolAlg.{u3} β) (BiheytingAlgebra.toCoheytingAlgebra.{u3} (AsBoolAlg.{u3} β) (BooleanAlgebra.toBiheytingAlgebra.{u3} (AsBoolAlg.{u3} β) (instBooleanAlgebraAsBoolAlg.{u3} β _inst_2))))) (GeneralizedCoheytingAlgebra.toLattice.{u2} (AsBoolAlg.{u2} γ) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (BooleanAlgebra.toBiheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (instBooleanAlgebraAsBoolAlg.{u2} γ _inst_3))))) (BooleanAlgebra.toBoundedOrder.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1)) (BooleanAlgebra.toBoundedOrder.{u3} (AsBoolAlg.{u3} β) (instBooleanAlgebraAsBoolAlg.{u3} β _inst_2)) (BooleanAlgebra.toBoundedOrder.{u2} (AsBoolAlg.{u2} γ) (instBooleanAlgebraAsBoolAlg.{u2} γ _inst_3)) (RingHom.asBoolAlg.{u3, u2} β γ _inst_2 _inst_3 g) (RingHom.asBoolAlg.{u1, u3} α β _inst_1 _inst_2 f))
-Case conversion may be inaccurate. Consider using '#align ring_hom.as_boolalg_comp RingHom.asBoolAlg_compₓ'. -/
 @[simp]
 theorem RingHom.asBoolAlg_comp (g : β →+* γ) (f : α →+* β) :
     (g.comp f).AsBoolAlg = g.AsBoolAlg.comp f.AsBoolAlg :=
@@ -685,12 +625,6 @@ theorem ofBoolRing_mul (a b : AsBoolRing α) : ofBoolRing (a * b) = ofBoolRing a
 #align of_boolring_mul ofBoolRing_mul
 -/
 
-/- warning: of_boolring_le_of_boolring_iff -> ofBoolRing_le_ofBoolRing_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} α] {a : AsBoolRing.{u1} α} {b : AsBoolRing.{u1} α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (GeneralizedCoheytingAlgebra.toLattice.{u1} α (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} α _inst_1))))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) => (AsBoolRing.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) => (AsBoolRing.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) b)) (Eq.{succ u1} (AsBoolRing.{u1} α) (HMul.hMul.{u1, u1, u1} (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (instHMul.{u1} (AsBoolRing.{u1} α) (Distrib.toHasMul.{u1} (AsBoolRing.{u1} α) (Ring.toDistrib.{u1} (AsBoolRing.{u1} α) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} α) (AsBoolRing.booleanRing.{u1} α _inst_1))))) a b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} α] {a : AsBoolRing.{u1} α} {b : AsBoolRing.{u1} α}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (Preorder.toLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (SemilatticeInf.toPartialOrder.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (Lattice.toSemilatticeInf.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (GeneralizedCoheytingAlgebra.toLattice.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (BiheytingAlgebra.toCoheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (BooleanAlgebra.toBiheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) _inst_1)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (AsBoolRing.{u1} α) (fun (_x : AsBoolRing.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (AsBoolRing.{u1} α) (fun (_x : AsBoolRing.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) b)) (Eq.{succ u1} (AsBoolRing.{u1} α) (HMul.hMul.{u1, u1, u1} (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (instHMul.{u1} (AsBoolRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (AsBoolRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (AsBoolRing.{u1} α) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} α) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} α) (instBooleanRingAsBoolRing.{u1} α _inst_1)))))) a b) a)
-Case conversion may be inaccurate. Consider using '#align of_boolring_le_of_boolring_iff ofBoolRing_le_ofBoolRing_iffₓ'. -/
 @[simp]
 theorem ofBoolRing_le_ofBoolRing_iff {a b : AsBoolRing α} :
     ofBoolRing a ≤ ofBoolRing b ↔ a * b = a :=
@@ -747,12 +681,6 @@ theorem BoundedLatticeHom.asBoolRing_id : (BoundedLatticeHom.id α).AsBoolRing =
 #align bounded_lattice_hom.as_boolring_id BoundedLatticeHom.asBoolRing_id
 -/
 
-/- warning: bounded_lattice_hom.as_boolring_comp -> BoundedLatticeHom.asBoolRing_comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : BooleanAlgebra.{u1} α] [_inst_2 : BooleanAlgebra.{u2} β] [_inst_3 : BooleanAlgebra.{u3} γ] (g : BoundedLatticeHom.{u2, u3} β γ (GeneralizedCoheytingAlgebra.toLattice.{u2} β (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} β (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} β _inst_2))) (GeneralizedCoheytingAlgebra.toLattice.{u3} γ (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} γ (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} γ _inst_3))) (BooleanAlgebra.toBoundedOrder.{u2} β _inst_2) (BooleanAlgebra.toBoundedOrder.{u3} γ _inst_3)) (f : BoundedLatticeHom.{u1, u2} α β (GeneralizedCoheytingAlgebra.toLattice.{u1} α (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} α _inst_1))) (GeneralizedCoheytingAlgebra.toLattice.{u2} β (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} β (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} β _inst_2))) (BooleanAlgebra.toBoundedOrder.{u1} α _inst_1) (BooleanAlgebra.toBoundedOrder.{u2} β _inst_2)), Eq.{max (succ u1) (succ u3)} (RingHom.{u1, u3} (AsBoolRing.{u1} α) (AsBoolRing.{u3} γ) (NonAssocRing.toNonAssocSemiring.{u1} (AsBoolRing.{u1} α) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} α) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} α) (AsBoolRing.booleanRing.{u1} α _inst_1)))) (NonAssocRing.toNonAssocSemiring.{u3} (AsBoolRing.{u3} γ) (Ring.toNonAssocRing.{u3} (AsBoolRing.{u3} γ) (BooleanRing.toRing.{u3} (AsBoolRing.{u3} γ) (AsBoolRing.booleanRing.{u3} γ _inst_3))))) (BoundedLatticeHom.asBoolRing.{u1, u3} α γ _inst_1 _inst_3 (BoundedLatticeHom.comp.{u1, u2, u3} α β γ (GeneralizedCoheytingAlgebra.toLattice.{u1} α (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} α _inst_1))) (GeneralizedCoheytingAlgebra.toLattice.{u2} β (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} β (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} β _inst_2))) (GeneralizedCoheytingAlgebra.toLattice.{u3} γ (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} γ (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} γ _inst_3))) (BooleanAlgebra.toBoundedOrder.{u1} α _inst_1) (BooleanAlgebra.toBoundedOrder.{u2} β _inst_2) (BooleanAlgebra.toBoundedOrder.{u3} γ _inst_3) g f)) (RingHom.comp.{u1, u2, u3} (AsBoolRing.{u1} α) (AsBoolRing.{u2} β) (AsBoolRing.{u3} γ) (NonAssocRing.toNonAssocSemiring.{u1} (AsBoolRing.{u1} α) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} α) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} α) (AsBoolRing.booleanRing.{u1} α _inst_1)))) (NonAssocRing.toNonAssocSemiring.{u2} (AsBoolRing.{u2} β) (Ring.toNonAssocRing.{u2} (AsBoolRing.{u2} β) (BooleanRing.toRing.{u2} (AsBoolRing.{u2} β) (AsBoolRing.booleanRing.{u2} β _inst_2)))) (NonAssocRing.toNonAssocSemiring.{u3} (AsBoolRing.{u3} γ) (Ring.toNonAssocRing.{u3} (AsBoolRing.{u3} γ) (BooleanRing.toRing.{u3} (AsBoolRing.{u3} γ) (AsBoolRing.booleanRing.{u3} γ _inst_3)))) (BoundedLatticeHom.asBoolRing.{u2, u3} β γ _inst_2 _inst_3 g) (BoundedLatticeHom.asBoolRing.{u1, u2} α β _inst_1 _inst_2 f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u3}} {γ : Type.{u2}} [_inst_1 : BooleanAlgebra.{u1} α] [_inst_2 : BooleanAlgebra.{u3} β] [_inst_3 : BooleanAlgebra.{u2} γ] (g : BoundedLatticeHom.{u3, u2} β γ (GeneralizedCoheytingAlgebra.toLattice.{u3} β (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u3} β (BiheytingAlgebra.toCoheytingAlgebra.{u3} β (BooleanAlgebra.toBiheytingAlgebra.{u3} β _inst_2)))) (GeneralizedCoheytingAlgebra.toLattice.{u2} γ (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} γ (BiheytingAlgebra.toCoheytingAlgebra.{u2} γ (BooleanAlgebra.toBiheytingAlgebra.{u2} γ _inst_3)))) (BooleanAlgebra.toBoundedOrder.{u3} β _inst_2) (BooleanAlgebra.toBoundedOrder.{u2} γ _inst_3)) (f : BoundedLatticeHom.{u1, u3} α β (GeneralizedCoheytingAlgebra.toLattice.{u1} α (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BiheytingAlgebra.toCoheytingAlgebra.{u1} α (BooleanAlgebra.toBiheytingAlgebra.{u1} α _inst_1)))) (GeneralizedCoheytingAlgebra.toLattice.{u3} β (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u3} β (BiheytingAlgebra.toCoheytingAlgebra.{u3} β (BooleanAlgebra.toBiheytingAlgebra.{u3} β _inst_2)))) (BooleanAlgebra.toBoundedOrder.{u1} α _inst_1) (BooleanAlgebra.toBoundedOrder.{u3} β _inst_2)), Eq.{max (succ u1) (succ u2)} (RingHom.{u1, u2} (AsBoolRing.{u1} α) (AsBoolRing.{u2} γ) (Semiring.toNonAssocSemiring.{u1} (AsBoolRing.{u1} α) (CommSemiring.toSemiring.{u1} (AsBoolRing.{u1} α) (CommRing.toCommSemiring.{u1} (AsBoolRing.{u1} α) (BooleanRing.toCommRing.{u1} (AsBoolRing.{u1} α) (instBooleanRingAsBoolRing.{u1} α _inst_1))))) (Semiring.toNonAssocSemiring.{u2} (AsBoolRing.{u2} γ) (CommSemiring.toSemiring.{u2} (AsBoolRing.{u2} γ) (CommRing.toCommSemiring.{u2} (AsBoolRing.{u2} γ) (BooleanRing.toCommRing.{u2} (AsBoolRing.{u2} γ) (instBooleanRingAsBoolRing.{u2} γ _inst_3)))))) (BoundedLatticeHom.asBoolRing.{u1, u2} α γ _inst_1 _inst_3 (BoundedLatticeHom.comp.{u1, u3, u2} α β γ (GeneralizedCoheytingAlgebra.toLattice.{u1} α (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BiheytingAlgebra.toCoheytingAlgebra.{u1} α (BooleanAlgebra.toBiheytingAlgebra.{u1} α _inst_1)))) (GeneralizedCoheytingAlgebra.toLattice.{u3} β (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u3} β (BiheytingAlgebra.toCoheytingAlgebra.{u3} β (BooleanAlgebra.toBiheytingAlgebra.{u3} β _inst_2)))) (GeneralizedCoheytingAlgebra.toLattice.{u2} γ (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} γ (BiheytingAlgebra.toCoheytingAlgebra.{u2} γ (BooleanAlgebra.toBiheytingAlgebra.{u2} γ _inst_3)))) (BooleanAlgebra.toBoundedOrder.{u1} α _inst_1) (BooleanAlgebra.toBoundedOrder.{u3} β _inst_2) (BooleanAlgebra.toBoundedOrder.{u2} γ _inst_3) g f)) (RingHom.comp.{u1, u3, u2} (AsBoolRing.{u1} α) (AsBoolRing.{u3} β) (AsBoolRing.{u2} γ) (Semiring.toNonAssocSemiring.{u1} (AsBoolRing.{u1} α) (CommSemiring.toSemiring.{u1} (AsBoolRing.{u1} α) (CommRing.toCommSemiring.{u1} (AsBoolRing.{u1} α) (BooleanRing.toCommRing.{u1} (AsBoolRing.{u1} α) (instBooleanRingAsBoolRing.{u1} α _inst_1))))) (Semiring.toNonAssocSemiring.{u3} (AsBoolRing.{u3} β) (CommSemiring.toSemiring.{u3} (AsBoolRing.{u3} β) (CommRing.toCommSemiring.{u3} (AsBoolRing.{u3} β) (BooleanRing.toCommRing.{u3} (AsBoolRing.{u3} β) (instBooleanRingAsBoolRing.{u3} β _inst_2))))) (Semiring.toNonAssocSemiring.{u2} (AsBoolRing.{u2} γ) (CommSemiring.toSemiring.{u2} (AsBoolRing.{u2} γ) (CommRing.toCommSemiring.{u2} (AsBoolRing.{u2} γ) (BooleanRing.toCommRing.{u2} (AsBoolRing.{u2} γ) (instBooleanRingAsBoolRing.{u2} γ _inst_3))))) (BoundedLatticeHom.asBoolRing.{u3, u2} β γ _inst_2 _inst_3 g) (BoundedLatticeHom.asBoolRing.{u1, u3} α β _inst_1 _inst_2 f))
-Case conversion may be inaccurate. Consider using '#align bounded_lattice_hom.as_boolring_comp BoundedLatticeHom.asBoolRing_compₓ'. -/
 @[simp]
 theorem BoundedLatticeHom.asBoolRing_comp (g : BoundedLatticeHom β γ) (f : BoundedLatticeHom α β) :
     (g.comp f).AsBoolRing = g.AsBoolRing.comp f.AsBoolRing :=
@@ -764,12 +692,6 @@ end AlgebraToRing
 /-! ### Equivalence between Boolean rings and Boolean algebras -/
 
 
-/- warning: order_iso.as_boolalg_as_boolring -> OrderIso.asBoolAlgAsBoolRing is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : BooleanAlgebra.{u1} α], OrderIso.{u1, u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) α (Preorder.toHasLe.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (AsBoolAlg.booleanAlgebra.{u1} (AsBoolRing.{u1} α) (AsBoolRing.booleanRing.{u1} α _inst_1))))))))) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (GeneralizedCoheytingAlgebra.toLattice.{u1} α (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} α _inst_1)))))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : BooleanAlgebra.{u1} α], OrderIso.{u1, u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) α (Preorder.toLE.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (BooleanAlgebra.toBiheytingAlgebra.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (instBooleanAlgebraAsBoolAlg.{u1} (AsBoolRing.{u1} α) (instBooleanRingAsBoolRing.{u1} α _inst_1)))))))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (GeneralizedCoheytingAlgebra.toLattice.{u1} α (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BiheytingAlgebra.toCoheytingAlgebra.{u1} α (BooleanAlgebra.toBiheytingAlgebra.{u1} α _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align order_iso.as_boolalg_as_boolring OrderIso.asBoolAlgAsBoolRingₓ'. -/
 /-- Order isomorphism between `α` considered as a Boolean ring considered as a Boolean algebra and
 `α`. -/
 @[simps]
@@ -778,12 +700,6 @@ def OrderIso.asBoolAlgAsBoolRing (α : Type _) [BooleanAlgebra α] : AsBoolAlg (
     ofBoolRing_le_ofBoolRing_iff.trans ofBoolAlg_mul_ofBoolAlg_eq_left_iff⟩
 #align order_iso.as_boolalg_as_boolring OrderIso.asBoolAlgAsBoolRing
 
-/- warning: ring_equiv.as_boolring_as_boolalg -> RingEquiv.asBoolRingAsBoolAlg is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : BooleanRing.{u1} α], RingEquiv.{u1, u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) α (Distrib.toHasMul.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (Ring.toDistrib.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (AsBoolRing.booleanRing.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1))))) (Distrib.toHasAdd.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (Ring.toDistrib.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (AsBoolRing.booleanRing.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1))))) (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1))) (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : BooleanRing.{u1} α], RingEquiv.{u1, u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) α (NonUnitalNonAssocRing.toMul.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (instBooleanRingAsBoolRing.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1)))))) (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (Distrib.toAdd.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (NonUnitalNonAssocSemiring.toDistrib.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (instBooleanRingAsBoolRing.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1)))))))) (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align ring_equiv.as_boolring_as_boolalg RingEquiv.asBoolRingAsBoolAlgₓ'. -/
 /-- Ring isomorphism between `α` considered as a Boolean algebra considered as a Boolean ring and
 `α`. -/
 @[simps]

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

@@ -267,41 +267,27 @@ BooleanAlgebraOfBooleanRing] attribute [instance 100] BooleanRing.sup
 scoped[BooleanAlgebraOfBooleanRing] attribute [instance 100] BooleanRing.inf
 
 #print BooleanRing.sup_comm /-
-theorem sup_comm (a b : α) : a ⊔ b = b ⊔ a :=
-  by
-  dsimp only [(· ⊔ ·)]
-  ring
+theorem sup_comm (a b : α) : a ⊔ b = b ⊔ a := by dsimp only [(· ⊔ ·)]; ring
 #align boolean_ring.sup_comm BooleanRing.sup_comm
 -/
 
 #print BooleanRing.inf_comm /-
-theorem inf_comm (a b : α) : a ⊓ b = b ⊓ a :=
-  by
-  dsimp only [(· ⊓ ·)]
-  ring
+theorem inf_comm (a b : α) : a ⊓ b = b ⊓ a := by dsimp only [(· ⊓ ·)]; ring
 #align boolean_ring.inf_comm BooleanRing.inf_comm
 -/
 
 #print BooleanRing.sup_assoc /-
-theorem sup_assoc (a b c : α) : a ⊔ b ⊔ c = a ⊔ (b ⊔ c) :=
-  by
-  dsimp only [(· ⊔ ·)]
-  ring
+theorem sup_assoc (a b c : α) : a ⊔ b ⊔ c = a ⊔ (b ⊔ c) := by dsimp only [(· ⊔ ·)]; ring
 #align boolean_ring.sup_assoc BooleanRing.sup_assoc
 -/
 
 #print BooleanRing.inf_assoc /-
-theorem inf_assoc (a b c : α) : a ⊓ b ⊓ c = a ⊓ (b ⊓ c) :=
-  by
-  dsimp only [(· ⊓ ·)]
-  ring
+theorem inf_assoc (a b c : α) : a ⊓ b ⊓ c = a ⊓ (b ⊓ c) := by dsimp only [(· ⊓ ·)]; ring
 #align boolean_ring.inf_assoc BooleanRing.inf_assoc
 -/
 
 #print BooleanRing.sup_inf_self /-
-theorem sup_inf_self (a b : α) : a ⊔ a ⊓ b = a :=
-  by
-  dsimp only [(· ⊔ ·), (· ⊓ ·)]
+theorem sup_inf_self (a b : α) : a ⊔ a ⊓ b = a := by dsimp only [(· ⊔ ·), (· ⊓ ·)];
   assoc_rw [mul_self, add_self, add_zero]
 #align boolean_ring.sup_inf_self BooleanRing.sup_inf_self
 -/
@@ -331,10 +317,8 @@ theorem le_sup_inf_aux (a b c : α) : (a + b + a * b) * (a + c + a * c) = a + b
 #align boolean_ring.le_sup_inf_aux BooleanRing.le_sup_inf_aux
 
 #print BooleanRing.le_sup_inf /-
-theorem le_sup_inf (a b c : α) : (a ⊔ b) ⊓ (a ⊔ c) ⊔ (a ⊔ b ⊓ c) = a ⊔ b ⊓ c :=
-  by
-  dsimp only [(· ⊔ ·), (· ⊓ ·)]
-  rw [le_sup_inf_aux, add_self, mul_self, zero_add]
+theorem le_sup_inf (a b c : α) : (a ⊔ b) ⊓ (a ⊔ c) ⊔ (a ⊔ b ⊓ c) = a ⊔ b ⊓ c := by
+  dsimp only [(· ⊔ ·), (· ⊓ ·)]; rw [le_sup_inf_aux, add_self, mul_self, zero_add]
 #align boolean_ring.le_sup_inf BooleanRing.le_sup_inf
 -/
 
@@ -431,10 +415,8 @@ private theorem of_boolalg_symm_diff_aux (a b : α) : (a + b + a * b) * (1 + a *
 
 #print ofBoolAlg_symmDiff /-
 @[simp]
-theorem ofBoolAlg_symmDiff (a b : AsBoolAlg α) : ofBoolAlg (a ∆ b) = ofBoolAlg a + ofBoolAlg b :=
-  by
-  rw [symmDiff_eq_sup_sdiff_inf]
-  exact of_boolalg_symm_diff_aux _ _
+theorem ofBoolAlg_symmDiff (a b : AsBoolAlg α) : ofBoolAlg (a ∆ b) = ofBoolAlg a + ofBoolAlg b := by
+  rw [symmDiff_eq_sup_sdiff_inf]; exact of_boolalg_symm_diff_aux _ _
 #align of_boolalg_symm_diff ofBoolAlg_symmDiff
 -/
 

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

@@ -428,7 +428,6 @@ private theorem of_boolalg_symm_diff_aux (a b : α) : (a + b + a * b) * (1 + a *
       by ring
     _ = a + b := by simp only [mul_self, add_self, add_zero]
     
-#align of_boolalg_symm_diff_aux of_boolalg_symm_diff_aux
 
 #print ofBoolAlg_symmDiff /-
 @[simp]

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

@@ -443,7 +443,7 @@ theorem ofBoolAlg_symmDiff (a b : AsBoolAlg α) : ofBoolAlg (a ∆ b) = ofBoolAl
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] {a : AsBoolAlg.{u1} α} {b : AsBoolAlg.{u1} α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) b)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a)) (LE.le.{u1} (AsBoolAlg.{u1} α) (Preorder.toHasLe.{u1} (AsBoolAlg.{u1} α) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} α) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)))))))) a b)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] {a : AsBoolAlg.{u1} α} {b : AsBoolAlg.{u1} α}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) b) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (instHMul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (NonUnitalNonAssocRing.toMul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (NonAssocRing.toNonUnitalNonAssocRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (BooleanRing.toRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) b)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a)) (LE.le.{u1} (AsBoolAlg.{u1} α) (Preorder.toLE.{u1} (AsBoolAlg.{u1} α) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} α) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1))))))))) a b)
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] {a : AsBoolAlg.{u1} α} {b : AsBoolAlg.{u1} α}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) b) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (instHMul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (NonUnitalNonAssocRing.toMul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (NonAssocRing.toNonUnitalNonAssocRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) (BooleanRing.toRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) a) _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) b)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a)) (LE.le.{u1} (AsBoolAlg.{u1} α) (Preorder.toLE.{u1} (AsBoolAlg.{u1} α) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} α) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1))))))))) a b)
 Case conversion may be inaccurate. Consider using '#align of_boolalg_mul_of_boolalg_eq_left_iff ofBoolAlg_mul_ofBoolAlg_eq_left_iffₓ'. -/
 @[simp]
 theorem ofBoolAlg_mul_ofBoolAlg_eq_left_iff {a b : AsBoolAlg α} :
@@ -708,7 +708,7 @@ theorem ofBoolRing_mul (a b : AsBoolRing α) : ofBoolRing (a * b) = ofBoolRing a
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} α] {a : AsBoolRing.{u1} α} {b : AsBoolRing.{u1} α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (GeneralizedCoheytingAlgebra.toLattice.{u1} α (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} α _inst_1))))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) => (AsBoolRing.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) => (AsBoolRing.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) b)) (Eq.{succ u1} (AsBoolRing.{u1} α) (HMul.hMul.{u1, u1, u1} (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (instHMul.{u1} (AsBoolRing.{u1} α) (Distrib.toHasMul.{u1} (AsBoolRing.{u1} α) (Ring.toDistrib.{u1} (AsBoolRing.{u1} α) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} α) (AsBoolRing.booleanRing.{u1} α _inst_1))))) a b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} α] {a : AsBoolRing.{u1} α} {b : AsBoolRing.{u1} α}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (Preorder.toLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (SemilatticeInf.toPartialOrder.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (Lattice.toSemilatticeInf.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (GeneralizedCoheytingAlgebra.toLattice.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (BiheytingAlgebra.toCoheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (BooleanAlgebra.toBiheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) _inst_1)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (AsBoolRing.{u1} α) (fun (_x : AsBoolRing.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (AsBoolRing.{u1} α) (fun (_x : AsBoolRing.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) b)) (Eq.{succ u1} (AsBoolRing.{u1} α) (HMul.hMul.{u1, u1, u1} (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (instHMul.{u1} (AsBoolRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (AsBoolRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (AsBoolRing.{u1} α) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} α) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} α) (instBooleanRingAsBoolRing.{u1} α _inst_1)))))) a b) a)
+  forall {α : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} α] {a : AsBoolRing.{u1} α} {b : AsBoolRing.{u1} α}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (Preorder.toLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (SemilatticeInf.toPartialOrder.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (Lattice.toSemilatticeInf.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (GeneralizedCoheytingAlgebra.toLattice.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (BiheytingAlgebra.toCoheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) (BooleanAlgebra.toBiheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) a) _inst_1)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (AsBoolRing.{u1} α) (fun (_x : AsBoolRing.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (AsBoolRing.{u1} α) (fun (_x : AsBoolRing.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AsBoolRing.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) b)) (Eq.{succ u1} (AsBoolRing.{u1} α) (HMul.hMul.{u1, u1, u1} (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (instHMul.{u1} (AsBoolRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (AsBoolRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (AsBoolRing.{u1} α) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} α) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} α) (instBooleanRingAsBoolRing.{u1} α _inst_1)))))) a b) a)
 Case conversion may be inaccurate. Consider using '#align of_boolring_le_of_boolring_iff ofBoolRing_le_ofBoolRing_iffₓ'. -/
 @[simp]
 theorem ofBoolRing_le_ofBoolRing_iff {a b : AsBoolRing α} :

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

@@ -441,7 +441,7 @@ theorem ofBoolAlg_symmDiff (a b : AsBoolAlg α) : ofBoolAlg (a ∆ b) = ofBoolAl
 
 /- warning: of_boolalg_mul_of_boolalg_eq_left_iff -> ofBoolAlg_mul_ofBoolAlg_eq_left_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] {a : AsBoolAlg.{u1} α} {b : AsBoolAlg.{u1} α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) b)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a)) (LE.le.{u1} (AsBoolAlg.{u1} α) (Preorder.toLE.{u1} (AsBoolAlg.{u1} α) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} α) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)))))))) a b)
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] {a : AsBoolAlg.{u1} α} {b : AsBoolAlg.{u1} α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) b)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a)) (LE.le.{u1} (AsBoolAlg.{u1} α) (Preorder.toHasLe.{u1} (AsBoolAlg.{u1} α) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} α) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)))))))) a b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] {a : AsBoolAlg.{u1} α} {b : AsBoolAlg.{u1} α}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) b) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (instHMul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (NonUnitalNonAssocRing.toMul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (NonAssocRing.toNonUnitalNonAssocRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (BooleanRing.toRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) b)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a)) (LE.le.{u1} (AsBoolAlg.{u1} α) (Preorder.toLE.{u1} (AsBoolAlg.{u1} α) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} α) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1))))))))) a b)
 Case conversion may be inaccurate. Consider using '#align of_boolalg_mul_of_boolalg_eq_left_iff ofBoolAlg_mul_ofBoolAlg_eq_left_iffₓ'. -/
@@ -704,13 +704,17 @@ theorem ofBoolRing_mul (a b : AsBoolRing α) : ofBoolRing (a * b) = ofBoolRing a
 #align of_boolring_mul ofBoolRing_mul
 -/
 
-#print ofBoolRing_le_ofBoolRing_iff /-
+/- warning: of_boolring_le_of_boolring_iff -> ofBoolRing_le_ofBoolRing_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} α] {a : AsBoolRing.{u1} α} {b : AsBoolRing.{u1} α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (GeneralizedCoheytingAlgebra.toLattice.{u1} α (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} α _inst_1))))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) => (AsBoolRing.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) => (AsBoolRing.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) b)) (Eq.{succ u1} (AsBoolRing.{u1} α) (HMul.hMul.{u1, u1, u1} (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (instHMul.{u1} (AsBoolRing.{u1} α) (Distrib.toHasMul.{u1} (AsBoolRing.{u1} α) (Ring.toDistrib.{u1} (AsBoolRing.{u1} α) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} α) (AsBoolRing.booleanRing.{u1} α _inst_1))))) a b) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} α] {a : AsBoolRing.{u1} α} {b : AsBoolRing.{u1} α}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (Preorder.toLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (PartialOrder.toPreorder.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (SemilatticeInf.toPartialOrder.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (Lattice.toSemilatticeInf.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (GeneralizedCoheytingAlgebra.toLattice.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (BiheytingAlgebra.toCoheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) (BooleanAlgebra.toBiheytingAlgebra.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) a) _inst_1)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (AsBoolRing.{u1} α) (fun (_x : AsBoolRing.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (AsBoolRing.{u1} α) (fun (_x : AsBoolRing.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolRing.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolRing.{u1} α) α) (ofBoolRing.{u1} α) b)) (Eq.{succ u1} (AsBoolRing.{u1} α) (HMul.hMul.{u1, u1, u1} (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (AsBoolRing.{u1} α) (instHMul.{u1} (AsBoolRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (AsBoolRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (AsBoolRing.{u1} α) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} α) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} α) (instBooleanRingAsBoolRing.{u1} α _inst_1)))))) a b) a)
+Case conversion may be inaccurate. Consider using '#align of_boolring_le_of_boolring_iff ofBoolRing_le_ofBoolRing_iffₓ'. -/
 @[simp]
 theorem ofBoolRing_le_ofBoolRing_iff {a b : AsBoolRing α} :
     ofBoolRing a ≤ ofBoolRing b ↔ a * b = a :=
   inf_eq_left.symm
 #align of_boolring_le_of_boolring_iff ofBoolRing_le_ofBoolRing_iff
--/
 
 #print toBoolRing_bot /-
 @[simp]
@@ -779,7 +783,12 @@ end AlgebraToRing
 /-! ### Equivalence between Boolean rings and Boolean algebras -/
 
 
-#print OrderIso.asBoolAlgAsBoolRing /-
+/- warning: order_iso.as_boolalg_as_boolring -> OrderIso.asBoolAlgAsBoolRing is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [_inst_1 : BooleanAlgebra.{u1} α], OrderIso.{u1, u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) α (Preorder.toHasLe.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (AsBoolAlg.booleanAlgebra.{u1} (AsBoolRing.{u1} α) (AsBoolRing.booleanRing.{u1} α _inst_1))))))))) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (GeneralizedCoheytingAlgebra.toLattice.{u1} α (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} α _inst_1)))))))
+but is expected to have type
+  forall (α : Type.{u1}) [_inst_1 : BooleanAlgebra.{u1} α], OrderIso.{u1, u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) α (Preorder.toLE.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (BooleanAlgebra.toBiheytingAlgebra.{u1} (AsBoolAlg.{u1} (AsBoolRing.{u1} α)) (instBooleanAlgebraAsBoolAlg.{u1} (AsBoolRing.{u1} α) (instBooleanRingAsBoolRing.{u1} α _inst_1)))))))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (GeneralizedCoheytingAlgebra.toLattice.{u1} α (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BiheytingAlgebra.toCoheytingAlgebra.{u1} α (BooleanAlgebra.toBiheytingAlgebra.{u1} α _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align order_iso.as_boolalg_as_boolring OrderIso.asBoolAlgAsBoolRingₓ'. -/
 /-- Order isomorphism between `α` considered as a Boolean ring considered as a Boolean algebra and
 `α`. -/
 @[simps]
@@ -787,7 +796,6 @@ def OrderIso.asBoolAlgAsBoolRing (α : Type _) [BooleanAlgebra α] : AsBoolAlg (
   ⟨ofBoolAlg.trans ofBoolRing, fun a b =>
     ofBoolRing_le_ofBoolRing_iff.trans ofBoolAlg_mul_ofBoolAlg_eq_left_iff⟩
 #align order_iso.as_boolalg_as_boolring OrderIso.asBoolAlgAsBoolRing
--/
 
 /- warning: ring_equiv.as_boolring_as_boolalg -> RingEquiv.asBoolRingAsBoolAlg is a dubious translation:
 lean 3 declaration is

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Bryan Gin-ge Chen, Yaël Dillies
 
 ! This file was ported from Lean 3 source module algebra.ring.boolean_ring
-! leanprover-community/mathlib commit e8638a0fcaf73e4500469f368ef9494e495099b3
+! leanprover-community/mathlib commit 6cf5900728239efa287df7761ec2a1ac9cf39b29
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.Order.Hom.Lattice
 /-!
 # Boolean rings
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 A Boolean ring is a ring where multiplication is idempotent. They are equivalent to Boolean
 algebras.
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/2f8347015b12b0864dfaf366ec4909eb70c78740

@@ -46,10 +46,12 @@ boolean ring, boolean algebra
 
 variable {α β γ : Type _}
 
+#print BooleanRing /-
 /-- A Boolean ring is a ring where multiplication is idempotent. -/
 class BooleanRing (α) extends Ring α where
   mul_self : ∀ a : α, a * a = a
 #align boolean_ring BooleanRing
+-/
 
 section BooleanRing
 
@@ -58,11 +60,23 @@ variable [BooleanRing α] (a b : α)
 instance : IsIdempotent α (· * ·) :=
   ⟨BooleanRing.mul_self⟩
 
+/- warning: mul_self -> mul_self is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a a) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a a) a
+Case conversion may be inaccurate. Consider using '#align mul_self mul_selfₓ'. -/
 @[simp]
 theorem mul_self : a * a = a :=
   BooleanRing.mul_self _
 #align mul_self mul_self
 
+/- warning: add_self -> add_self is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a a) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a a) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α (Ring.toSemiring.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align add_self add_selfₓ'. -/
 @[simp]
 theorem add_self : a + a = 0 :=
   by
@@ -75,6 +89,12 @@ theorem add_self : a + a = 0 :=
   rwa [self_eq_add_left] at this
 #align add_self add_self
 
+/- warning: neg_eq -> neg_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))) a) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (Neg.neg.{u1} α (Ring.toNeg.{u1} α (BooleanRing.toRing.{u1} α _inst_1)) a) a
+Case conversion may be inaccurate. Consider using '#align neg_eq neg_eqₓ'. -/
 @[simp]
 theorem neg_eq : -a = a :=
   calc
@@ -84,6 +104,12 @@ theorem neg_eq : -a = a :=
     
 #align neg_eq neg_eq
 
+/- warning: add_eq_zero' -> add_eq_zero' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Iff (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))))))) (Eq.{succ u1} α a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Iff (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α (Ring.toSemiring.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (Eq.{succ u1} α a b)
+Case conversion may be inaccurate. Consider using '#align add_eq_zero' add_eq_zero'ₓ'. -/
 theorem add_eq_zero' : a + b = 0 ↔ a = b :=
   calc
     a + b = 0 ↔ a = -b := add_eq_zero_iff_eq_neg
@@ -91,6 +117,12 @@ theorem add_eq_zero' : a + b = 0 ↔ a = b :=
     
 #align add_eq_zero' add_eq_zero'
 
+/- warning: mul_add_mul -> mul_add_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) b a)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) b a)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α (Ring.toSemiring.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align mul_add_mul mul_add_mulₓ'. -/
 @[simp]
 theorem mul_add_mul : a * b + b * a = 0 :=
   by
@@ -104,19 +136,33 @@ theorem mul_add_mul : a * b + b * a = 0 :=
   rwa [self_eq_add_right] at this
 #align mul_add_mul mul_add_mul
 
+/- warning: sub_eq_add -> sub_eq_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (Ring.toSub.{u1} α (BooleanRing.toRing.{u1} α _inst_1))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a b)
+Case conversion may be inaccurate. Consider using '#align sub_eq_add sub_eq_addₓ'. -/
 @[simp]
 theorem sub_eq_add : a - b = a + b := by rw [sub_eq_add_neg, add_right_inj, neg_eq]
 #align sub_eq_add sub_eq_add
 
+/- warning: mul_one_add_self -> mul_one_add_self is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))))) a)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Semiring.toOne.{u1} α (Ring.toSemiring.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α (Ring.toSemiring.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align mul_one_add_self mul_one_add_selfₓ'. -/
 @[simp]
 theorem mul_one_add_self : a * (1 + a) = 0 := by rw [mul_add, mul_one, mul_self, add_self]
 #align mul_one_add_self mul_one_add_self
 
+#print BooleanRing.toCommRing /-
 -- Note [lower instance priority]
 instance (priority := 100) BooleanRing.toCommRing : CommRing α :=
   { (inferInstance : BooleanRing α) with
     mul_comm := fun a b => by rw [← add_eq_zero', mul_add_mul] }
 #align boolean_ring.to_comm_ring BooleanRing.toCommRing
+-/
 
 end BooleanRing
 
@@ -128,109 +174,149 @@ instance : BooleanRing PUnit :=
 
 section RingToAlgebra
 
+#print AsBoolAlg /-
 /-- Type synonym to view a Boolean ring as a Boolean algebra. -/
-def AsBoolalg (α : Type _) :=
+def AsBoolAlg (α : Type _) :=
   α
-#align as_boolalg AsBoolalg
+#align as_boolalg AsBoolAlg
+-/
 
+#print toBoolAlg /-
 /-- The "identity" equivalence between `as_boolalg α` and `α`. -/
-def toBoolalg : α ≃ AsBoolalg α :=
+def toBoolAlg : α ≃ AsBoolAlg α :=
   Equiv.refl _
-#align to_boolalg toBoolalg
+#align to_boolalg toBoolAlg
+-/
 
+#print ofBoolAlg /-
 /-- The "identity" equivalence between `α` and `as_boolalg α`. -/
-def ofBoolalg : AsBoolalg α ≃ α :=
+def ofBoolAlg : AsBoolAlg α ≃ α :=
   Equiv.refl _
-#align of_boolalg ofBoolalg
+#align of_boolalg ofBoolAlg
+-/
 
+#print toBoolAlg_symm_eq /-
 @[simp]
-theorem toBoolalg_symm_eq : (@toBoolalg α).symm = ofBoolalg :=
+theorem toBoolAlg_symm_eq : (@toBoolAlg α).symm = ofBoolAlg :=
   rfl
-#align to_boolalg_symm_eq toBoolalg_symm_eq
+#align to_boolalg_symm_eq toBoolAlg_symm_eq
+-/
 
+#print ofBoolAlg_symm_eq /-
 @[simp]
-theorem ofBoolalg_symm_eq : (@ofBoolalg α).symm = toBoolalg :=
+theorem ofBoolAlg_symm_eq : (@ofBoolAlg α).symm = toBoolAlg :=
   rfl
-#align of_boolalg_symm_eq ofBoolalg_symm_eq
+#align of_boolalg_symm_eq ofBoolAlg_symm_eq
+-/
 
+#print toBoolAlg_ofBoolAlg /-
 @[simp]
-theorem toBoolalg_ofBoolalg (a : AsBoolalg α) : toBoolalg (ofBoolalg a) = a :=
+theorem toBoolAlg_ofBoolAlg (a : AsBoolAlg α) : toBoolAlg (ofBoolAlg a) = a :=
   rfl
-#align to_boolalg_of_boolalg toBoolalg_ofBoolalg
+#align to_boolalg_of_boolalg toBoolAlg_ofBoolAlg
+-/
 
+#print ofBoolAlg_toBoolAlg /-
 @[simp]
-theorem ofBoolalg_toBoolalg (a : α) : ofBoolalg (toBoolalg a) = a :=
+theorem ofBoolAlg_toBoolAlg (a : α) : ofBoolAlg (toBoolAlg a) = a :=
   rfl
-#align of_boolalg_to_boolalg ofBoolalg_toBoolalg
+#align of_boolalg_to_boolalg ofBoolAlg_toBoolAlg
+-/
 
+#print toBoolAlg_inj /-
 @[simp]
-theorem toBoolalg_inj {a b : α} : toBoolalg a = toBoolalg b ↔ a = b :=
+theorem toBoolAlg_inj {a b : α} : toBoolAlg a = toBoolAlg b ↔ a = b :=
   Iff.rfl
-#align to_boolalg_inj toBoolalg_inj
+#align to_boolalg_inj toBoolAlg_inj
+-/
 
+#print ofBoolAlg_inj /-
 @[simp]
-theorem ofBoolalg_inj {a b : AsBoolalg α} : ofBoolalg a = ofBoolalg b ↔ a = b :=
+theorem ofBoolAlg_inj {a b : AsBoolAlg α} : ofBoolAlg a = ofBoolAlg b ↔ a = b :=
   Iff.rfl
-#align of_boolalg_inj ofBoolalg_inj
+#align of_boolalg_inj ofBoolAlg_inj
+-/
 
-instance [Inhabited α] : Inhabited (AsBoolalg α) :=
+instance [Inhabited α] : Inhabited (AsBoolAlg α) :=
   ‹Inhabited α›
 
 variable [BooleanRing α] [BooleanRing β] [BooleanRing γ]
 
 namespace BooleanRing
 
+#print BooleanRing.sup /-
 /-- The join operation in a Boolean ring is `x + y + x * y`. -/
-def hasSup : Sup α :=
+def sup : Sup α :=
   ⟨fun x y => x + y + x * y⟩
-#align boolean_ring.has_sup BooleanRing.hasSup
+#align boolean_ring.has_sup BooleanRing.sup
+-/
 
+#print BooleanRing.inf /-
 /-- The meet operation in a Boolean ring is `x * y`. -/
-def hasInf : Inf α :=
+def inf : Inf α :=
   ⟨(· * ·)⟩
-#align boolean_ring.has_inf BooleanRing.hasInf
+#align boolean_ring.has_inf BooleanRing.inf
+-/
 
 scoped[-- Note [lower instance priority]
-BooleanAlgebraOfBooleanRing] attribute [instance 100] BooleanRing.hasSup
+BooleanAlgebraOfBooleanRing] attribute [instance 100] BooleanRing.sup
 
-scoped[BooleanAlgebraOfBooleanRing] attribute [instance 100] BooleanRing.hasInf
+scoped[BooleanAlgebraOfBooleanRing] attribute [instance 100] BooleanRing.inf
 
+#print BooleanRing.sup_comm /-
 theorem sup_comm (a b : α) : a ⊔ b = b ⊔ a :=
   by
   dsimp only [(· ⊔ ·)]
   ring
 #align boolean_ring.sup_comm BooleanRing.sup_comm
+-/
 
+#print BooleanRing.inf_comm /-
 theorem inf_comm (a b : α) : a ⊓ b = b ⊓ a :=
   by
   dsimp only [(· ⊓ ·)]
   ring
 #align boolean_ring.inf_comm BooleanRing.inf_comm
+-/
 
+#print BooleanRing.sup_assoc /-
 theorem sup_assoc (a b c : α) : a ⊔ b ⊔ c = a ⊔ (b ⊔ c) :=
   by
   dsimp only [(· ⊔ ·)]
   ring
 #align boolean_ring.sup_assoc BooleanRing.sup_assoc
+-/
 
+#print BooleanRing.inf_assoc /-
 theorem inf_assoc (a b c : α) : a ⊓ b ⊓ c = a ⊓ (b ⊓ c) :=
   by
   dsimp only [(· ⊓ ·)]
   ring
 #align boolean_ring.inf_assoc BooleanRing.inf_assoc
+-/
 
+#print BooleanRing.sup_inf_self /-
 theorem sup_inf_self (a b : α) : a ⊔ a ⊓ b = a :=
   by
   dsimp only [(· ⊔ ·), (· ⊓ ·)]
   assoc_rw [mul_self, add_self, add_zero]
 #align boolean_ring.sup_inf_self BooleanRing.sup_inf_self
+-/
 
+#print BooleanRing.inf_sup_self /-
 theorem inf_sup_self (a b : α) : a ⊓ (a ⊔ b) = a :=
   by
   dsimp only [(· ⊔ ·), (· ⊓ ·)]
   rw [mul_add, mul_add, mul_self, ← mul_assoc, mul_self, add_assoc, add_self, add_zero]
 #align boolean_ring.inf_sup_self BooleanRing.inf_sup_self
+-/
 
+/- warning: boolean_ring.le_sup_inf_aux -> BooleanRing.le_sup_inf_aux is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α) (c : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a b)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a c))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) b c)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] (a : α) (b : α) (c : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a b)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a c))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))) b c)))
+Case conversion may be inaccurate. Consider using '#align boolean_ring.le_sup_inf_aux BooleanRing.le_sup_inf_auxₓ'. -/
 theorem le_sup_inf_aux (a b c : α) : (a + b + a * b) * (a + c + a * c) = a + b * c + a * (b * c) :=
   calc
     (a + b + a * b) * (a + c + a * c) =
@@ -241,12 +327,15 @@ theorem le_sup_inf_aux (a b c : α) : (a + b + a * b) * (a + c + a * c) = a + b
     
 #align boolean_ring.le_sup_inf_aux BooleanRing.le_sup_inf_aux
 
+#print BooleanRing.le_sup_inf /-
 theorem le_sup_inf (a b c : α) : (a ⊔ b) ⊓ (a ⊔ c) ⊔ (a ⊔ b ⊓ c) = a ⊔ b ⊓ c :=
   by
   dsimp only [(· ⊔ ·), (· ⊓ ·)]
   rw [le_sup_inf_aux, add_self, mul_self, zero_add]
 #align boolean_ring.le_sup_inf BooleanRing.le_sup_inf
+-/
 
+#print BooleanRing.toBooleanAlgebra /-
 /-- The Boolean algebra structure on a Boolean ring.
 
 The data is defined so that:
@@ -278,44 +367,57 @@ def toBooleanAlgebra : BooleanAlgebra α :=
       norm_num [mul_add, mul_self]
       rw [← add_assoc, add_self] }
 #align boolean_ring.to_boolean_algebra BooleanRing.toBooleanAlgebra
+-/
 
 scoped[BooleanAlgebraOfBooleanRing] attribute [instance 100] BooleanRing.toBooleanAlgebra
 
 end BooleanRing
 
-instance : BooleanAlgebra (AsBoolalg α) :=
+instance : BooleanAlgebra (AsBoolAlg α) :=
   @BooleanRing.toBooleanAlgebra α _
 
+#print ofBoolAlg_top /-
 @[simp]
-theorem ofBoolalg_top : ofBoolalg (⊤ : AsBoolalg α) = 1 :=
+theorem ofBoolAlg_top : ofBoolAlg (⊤ : AsBoolAlg α) = 1 :=
   rfl
-#align of_boolalg_top ofBoolalg_top
+#align of_boolalg_top ofBoolAlg_top
+-/
 
+#print ofBoolAlg_bot /-
 @[simp]
-theorem ofBoolalg_bot : ofBoolalg (⊥ : AsBoolalg α) = 0 :=
+theorem ofBoolAlg_bot : ofBoolAlg (⊥ : AsBoolAlg α) = 0 :=
   rfl
-#align of_boolalg_bot ofBoolalg_bot
+#align of_boolalg_bot ofBoolAlg_bot
+-/
 
+#print ofBoolAlg_sup /-
 @[simp]
-theorem ofBoolalg_sup (a b : AsBoolalg α) :
-    ofBoolalg (a ⊔ b) = ofBoolalg a + ofBoolalg b + ofBoolalg a * ofBoolalg b :=
+theorem ofBoolAlg_sup (a b : AsBoolAlg α) :
+    ofBoolAlg (a ⊔ b) = ofBoolAlg a + ofBoolAlg b + ofBoolAlg a * ofBoolAlg b :=
   rfl
-#align of_boolalg_sup ofBoolalg_sup
+#align of_boolalg_sup ofBoolAlg_sup
+-/
 
+#print ofBoolAlg_inf /-
 @[simp]
-theorem ofBoolalg_inf (a b : AsBoolalg α) : ofBoolalg (a ⊓ b) = ofBoolalg a * ofBoolalg b :=
+theorem ofBoolAlg_inf (a b : AsBoolAlg α) : ofBoolAlg (a ⊓ b) = ofBoolAlg a * ofBoolAlg b :=
   rfl
-#align of_boolalg_inf ofBoolalg_inf
+#align of_boolalg_inf ofBoolAlg_inf
+-/
 
+#print ofBoolAlg_compl /-
 @[simp]
-theorem ofBoolalg_compl (a : AsBoolalg α) : ofBoolalg (aᶜ) = 1 + ofBoolalg a :=
+theorem ofBoolAlg_compl (a : AsBoolAlg α) : ofBoolAlg (aᶜ) = 1 + ofBoolAlg a :=
   rfl
-#align of_boolalg_compl ofBoolalg_compl
+#align of_boolalg_compl ofBoolAlg_compl
+-/
 
+#print ofBoolAlg_sdiff /-
 @[simp]
-theorem ofBoolalg_sdiff (a b : AsBoolalg α) : ofBoolalg (a \ b) = ofBoolalg a * (1 + ofBoolalg b) :=
+theorem ofBoolAlg_sdiff (a b : AsBoolAlg α) : ofBoolAlg (a \ b) = ofBoolAlg a * (1 + ofBoolAlg b) :=
   rfl
-#align of_boolalg_sdiff ofBoolalg_sdiff
+#align of_boolalg_sdiff ofBoolAlg_sdiff
+-/
 
 private theorem of_boolalg_symm_diff_aux (a b : α) : (a + b + a * b) * (1 + a * b) = a + b :=
   calc
@@ -325,51 +427,70 @@ private theorem of_boolalg_symm_diff_aux (a b : α) : (a + b + a * b) * (1 + a *
     
 #align of_boolalg_symm_diff_aux of_boolalg_symm_diff_aux
 
+#print ofBoolAlg_symmDiff /-
 @[simp]
-theorem ofBoolalg_symmDiff (a b : AsBoolalg α) : ofBoolalg (a ∆ b) = ofBoolalg a + ofBoolalg b :=
+theorem ofBoolAlg_symmDiff (a b : AsBoolAlg α) : ofBoolAlg (a ∆ b) = ofBoolAlg a + ofBoolAlg b :=
   by
   rw [symmDiff_eq_sup_sdiff_inf]
   exact of_boolalg_symm_diff_aux _ _
-#align of_boolalg_symm_diff ofBoolalg_symmDiff
+#align of_boolalg_symm_diff ofBoolAlg_symmDiff
+-/
 
+/- warning: of_boolalg_mul_of_boolalg_eq_left_iff -> ofBoolAlg_mul_ofBoolAlg_eq_left_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] {a : AsBoolAlg.{u1} α} {b : AsBoolAlg.{u1} α}, Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) b)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) => (AsBoolAlg.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a)) (LE.le.{u1} (AsBoolAlg.{u1} α) (Preorder.toLE.{u1} (AsBoolAlg.{u1} α) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} α) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)))))))) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : BooleanRing.{u1} α] {a : AsBoolAlg.{u1} α} {b : AsBoolAlg.{u1} α}, Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) b) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (instHMul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (NonUnitalNonAssocRing.toMul.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (NonAssocRing.toNonUnitalNonAssocRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (Ring.toNonAssocRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) (BooleanRing.toRing.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) a) _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) b)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (AsBoolAlg.{u1} α) (fun (_x : AsBoolAlg.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AsBoolAlg.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (AsBoolAlg.{u1} α) α) (ofBoolAlg.{u1} α) a)) (LE.le.{u1} (AsBoolAlg.{u1} α) (Preorder.toLE.{u1} (AsBoolAlg.{u1} α) (PartialOrder.toPreorder.{u1} (AsBoolAlg.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (AsBoolAlg.{u1} α) (Lattice.toSemilatticeInf.{u1} (AsBoolAlg.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1))))))))) a b)
+Case conversion may be inaccurate. Consider using '#align of_boolalg_mul_of_boolalg_eq_left_iff ofBoolAlg_mul_ofBoolAlg_eq_left_iffₓ'. -/
 @[simp]
-theorem ofBoolalg_mul_ofBoolalg_eq_left_iff {a b : AsBoolalg α} :
-    ofBoolalg a * ofBoolalg b = ofBoolalg a ↔ a ≤ b :=
-  @inf_eq_left (AsBoolalg α) _ _ _
-#align of_boolalg_mul_of_boolalg_eq_left_iff ofBoolalg_mul_ofBoolalg_eq_left_iff
+theorem ofBoolAlg_mul_ofBoolAlg_eq_left_iff {a b : AsBoolAlg α} :
+    ofBoolAlg a * ofBoolAlg b = ofBoolAlg a ↔ a ≤ b :=
+  @inf_eq_left (AsBoolAlg α) _ _ _
+#align of_boolalg_mul_of_boolalg_eq_left_iff ofBoolAlg_mul_ofBoolAlg_eq_left_iff
 
+#print toBoolAlg_zero /-
 @[simp]
-theorem toBoolalg_zero : toBoolalg (0 : α) = ⊥ :=
+theorem toBoolAlg_zero : toBoolAlg (0 : α) = ⊥ :=
   rfl
-#align to_boolalg_zero toBoolalg_zero
+#align to_boolalg_zero toBoolAlg_zero
+-/
 
+#print toBoolAlg_one /-
 @[simp]
-theorem toBoolalg_one : toBoolalg (1 : α) = ⊤ :=
+theorem toBoolAlg_one : toBoolAlg (1 : α) = ⊤ :=
   rfl
-#align to_boolalg_one toBoolalg_one
+#align to_boolalg_one toBoolAlg_one
+-/
 
+#print toBoolAlg_mul /-
 @[simp]
-theorem toBoolalg_mul (a b : α) : toBoolalg (a * b) = toBoolalg a ⊓ toBoolalg b :=
+theorem toBoolAlg_mul (a b : α) : toBoolAlg (a * b) = toBoolAlg a ⊓ toBoolAlg b :=
   rfl
-#align to_boolalg_mul toBoolalg_mul
+#align to_boolalg_mul toBoolAlg_mul
+-/
 
+#print toBoolAlg_add_add_mul /-
 -- `to_boolalg_add` simplifies the LHS but this lemma is eligible to `dsimp`
 @[simp, nolint simp_nf]
-theorem toBoolalg_add_add_mul (a b : α) : toBoolalg (a + b + a * b) = toBoolalg a ⊔ toBoolalg b :=
+theorem toBoolAlg_add_add_mul (a b : α) : toBoolAlg (a + b + a * b) = toBoolAlg a ⊔ toBoolAlg b :=
   rfl
-#align to_boolalg_add_add_mul toBoolalg_add_add_mul
+#align to_boolalg_add_add_mul toBoolAlg_add_add_mul
+-/
 
+#print toBoolAlg_add /-
 @[simp]
-theorem toBoolalg_add (a b : α) : toBoolalg (a + b) = toBoolalg a ∆ toBoolalg b :=
-  (ofBoolalg_symmDiff _ _).symm
-#align to_boolalg_add toBoolalg_add
+theorem toBoolAlg_add (a b : α) : toBoolAlg (a + b) = toBoolAlg a ∆ toBoolAlg b :=
+  (ofBoolAlg_symmDiff _ _).symm
+#align to_boolalg_add toBoolAlg_add
+-/
 
+#print RingHom.asBoolAlg /-
 /-- Turn a ring homomorphism from Boolean rings `α` to `β` into a bounded lattice homomorphism
 from `α` to `β` considered as Boolean algebras. -/
 @[simps]
-protected def RingHom.asBoolalg (f : α →+* β) : BoundedLatticeHom (AsBoolalg α) (AsBoolalg β)
+protected def RingHom.asBoolAlg (f : α →+* β) : BoundedLatticeHom (AsBoolAlg α) (AsBoolAlg β)
     where
-  toFun := toBoolalg ∘ f ∘ ofBoolalg
+  toFun := toBoolAlg ∘ f ∘ ofBoolAlg
   map_sup' a b := by
     dsimp
     simp_rw [map_add f, map_mul f]
@@ -377,18 +498,27 @@ protected def RingHom.asBoolalg (f : α →+* β) : BoundedLatticeHom (AsBoolalg
   map_inf' := f.map_mul'
   map_top' := f.map_one'
   map_bot' := f.map_zero'
-#align ring_hom.as_boolalg RingHom.asBoolalg
+#align ring_hom.as_boolalg RingHom.asBoolAlg
+-/
 
+#print RingHom.asBoolAlg_id /-
 @[simp]
-theorem RingHom.asBoolalg_id : (RingHom.id α).AsBoolalg = BoundedLatticeHom.id _ :=
+theorem RingHom.asBoolAlg_id : (RingHom.id α).AsBoolAlg = BoundedLatticeHom.id _ :=
   rfl
-#align ring_hom.as_boolalg_id RingHom.asBoolalg_id
+#align ring_hom.as_boolalg_id RingHom.asBoolAlg_id
+-/
 
+/- warning: ring_hom.as_boolalg_comp -> RingHom.asBoolAlg_comp is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : BooleanRing.{u1} α] [_inst_2 : BooleanRing.{u2} β] [_inst_3 : BooleanRing.{u3} γ] (g : RingHom.{u2, u3} β γ (NonAssocRing.toNonAssocSemiring.{u2} β (Ring.toNonAssocRing.{u2} β (BooleanRing.toRing.{u2} β _inst_2))) (NonAssocRing.toNonAssocSemiring.{u3} γ (Ring.toNonAssocRing.{u3} γ (BooleanRing.toRing.{u3} γ _inst_3)))) (f : RingHom.{u1, u2} α β (NonAssocRing.toNonAssocSemiring.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} β (Ring.toNonAssocRing.{u2} β (BooleanRing.toRing.{u2} β _inst_2)))), Eq.{max (succ u1) (succ u3)} (BoundedLatticeHom.{u1, u3} (AsBoolAlg.{u1} α) (AsBoolAlg.{u3} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)))) (GeneralizedCoheytingAlgebra.toLattice.{u3} (AsBoolAlg.{u3} γ) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} (AsBoolAlg.{u3} γ) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} (AsBoolAlg.{u3} γ) (AsBoolAlg.booleanAlgebra.{u3} γ _inst_3)))) (BooleanAlgebra.toBoundedOrder.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)) (BooleanAlgebra.toBoundedOrder.{u3} (AsBoolAlg.{u3} γ) (AsBoolAlg.booleanAlgebra.{u3} γ _inst_3))) (RingHom.asBoolAlg.{u1, u3} α γ _inst_1 _inst_3 (RingHom.comp.{u1, u2, u3} α β γ (NonAssocRing.toNonAssocSemiring.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} β (Ring.toNonAssocRing.{u2} β (BooleanRing.toRing.{u2} β _inst_2))) (NonAssocRing.toNonAssocSemiring.{u3} γ (Ring.toNonAssocRing.{u3} γ (BooleanRing.toRing.{u3} γ _inst_3))) g f)) (BoundedLatticeHom.comp.{u1, u2, u3} (AsBoolAlg.{u1} α) (AsBoolAlg.{u2} β) (AsBoolAlg.{u3} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)))) (GeneralizedCoheytingAlgebra.toLattice.{u2} (AsBoolAlg.{u2} β) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} (AsBoolAlg.{u2} β) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} (AsBoolAlg.{u2} β) (AsBoolAlg.booleanAlgebra.{u2} β _inst_2)))) (GeneralizedCoheytingAlgebra.toLattice.{u3} (AsBoolAlg.{u3} γ) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} (AsBoolAlg.{u3} γ) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} (AsBoolAlg.{u3} γ) (AsBoolAlg.booleanAlgebra.{u3} γ _inst_3)))) (BooleanAlgebra.toBoundedOrder.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1)) (BooleanAlgebra.toBoundedOrder.{u2} (AsBoolAlg.{u2} β) (AsBoolAlg.booleanAlgebra.{u2} β _inst_2)) (BooleanAlgebra.toBoundedOrder.{u3} (AsBoolAlg.{u3} γ) (AsBoolAlg.booleanAlgebra.{u3} γ _inst_3)) (RingHom.asBoolAlg.{u2, u3} β γ _inst_2 _inst_3 g) (RingHom.asBoolAlg.{u1, u2} α β _inst_1 _inst_2 f))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u3}} {γ : Type.{u2}} [_inst_1 : BooleanRing.{u1} α] [_inst_2 : BooleanRing.{u3} β] [_inst_3 : BooleanRing.{u2} γ] (g : RingHom.{u3, u2} β γ (Semiring.toNonAssocSemiring.{u3} β (CommSemiring.toSemiring.{u3} β (CommRing.toCommSemiring.{u3} β (BooleanRing.toCommRing.{u3} β _inst_2)))) (Semiring.toNonAssocSemiring.{u2} γ (CommSemiring.toSemiring.{u2} γ (CommRing.toCommSemiring.{u2} γ (BooleanRing.toCommRing.{u2} γ _inst_3))))) (f : RingHom.{u1, u3} α β (Semiring.toNonAssocSemiring.{u1} α (CommSemiring.toSemiring.{u1} α (CommRing.toCommSemiring.{u1} α (BooleanRing.toCommRing.{u1} α _inst_1)))) (Semiring.toNonAssocSemiring.{u3} β (CommSemiring.toSemiring.{u3} β (CommRing.toCommSemiring.{u3} β (BooleanRing.toCommRing.{u3} β _inst_2))))), Eq.{max (succ u1) (succ u2)} (BoundedLatticeHom.{u1, u2} (AsBoolAlg.{u1} α) (AsBoolAlg.{u2} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1))))) (GeneralizedCoheytingAlgebra.toLattice.{u2} (AsBoolAlg.{u2} γ) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (BooleanAlgebra.toBiheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (instBooleanAlgebraAsBoolAlg.{u2} γ _inst_3))))) (BooleanAlgebra.toBoundedOrder.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1)) (BooleanAlgebra.toBoundedOrder.{u2} (AsBoolAlg.{u2} γ) (instBooleanAlgebraAsBoolAlg.{u2} γ _inst_3))) (RingHom.asBoolAlg.{u1, u2} α γ _inst_1 _inst_3 (RingHom.comp.{u1, u3, u2} α β γ (Semiring.toNonAssocSemiring.{u1} α (CommSemiring.toSemiring.{u1} α (CommRing.toCommSemiring.{u1} α (BooleanRing.toCommRing.{u1} α _inst_1)))) (Semiring.toNonAssocSemiring.{u3} β (CommSemiring.toSemiring.{u3} β (CommRing.toCommSemiring.{u3} β (BooleanRing.toCommRing.{u3} β _inst_2)))) (Semiring.toNonAssocSemiring.{u2} γ (CommSemiring.toSemiring.{u2} γ (CommRing.toCommSemiring.{u2} γ (BooleanRing.toCommRing.{u2} γ _inst_3)))) g f)) (BoundedLatticeHom.comp.{u1, u3, u2} (AsBoolAlg.{u1} α) (AsBoolAlg.{u3} β) (AsBoolAlg.{u2} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (AsBoolAlg.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1))))) (GeneralizedCoheytingAlgebra.toLattice.{u3} (AsBoolAlg.{u3} β) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u3} (AsBoolAlg.{u3} β) (BiheytingAlgebra.toCoheytingAlgebra.{u3} (AsBoolAlg.{u3} β) (BooleanAlgebra.toBiheytingAlgebra.{u3} (AsBoolAlg.{u3} β) (instBooleanAlgebraAsBoolAlg.{u3} β _inst_2))))) (GeneralizedCoheytingAlgebra.toLattice.{u2} (AsBoolAlg.{u2} γ) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (BooleanAlgebra.toBiheytingAlgebra.{u2} (AsBoolAlg.{u2} γ) (instBooleanAlgebraAsBoolAlg.{u2} γ _inst_3))))) (BooleanAlgebra.toBoundedOrder.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1)) (BooleanAlgebra.toBoundedOrder.{u3} (AsBoolAlg.{u3} β) (instBooleanAlgebraAsBoolAlg.{u3} β _inst_2)) (BooleanAlgebra.toBoundedOrder.{u2} (AsBoolAlg.{u2} γ) (instBooleanAlgebraAsBoolAlg.{u2} γ _inst_3)) (RingHom.asBoolAlg.{u3, u2} β γ _inst_2 _inst_3 g) (RingHom.asBoolAlg.{u1, u3} α β _inst_1 _inst_2 f))
+Case conversion may be inaccurate. Consider using '#align ring_hom.as_boolalg_comp RingHom.asBoolAlg_compₓ'. -/
 @[simp]
-theorem RingHom.asBoolalg_comp (g : β →+* γ) (f : α →+* β) :
-    (g.comp f).AsBoolalg = g.AsBoolalg.comp f.AsBoolalg :=
+theorem RingHom.asBoolAlg_comp (g : β →+* γ) (f : α →+* β) :
+    (g.comp f).AsBoolAlg = g.AsBoolAlg.comp f.AsBoolAlg :=
   rfl
-#align ring_hom.as_boolalg_comp RingHom.asBoolalg_comp
+#align ring_hom.as_boolalg_comp RingHom.asBoolAlg_comp
 
 end RingToAlgebra
 
@@ -397,54 +527,73 @@ end RingToAlgebra
 
 section AlgebraToRing
 
+#print AsBoolRing /-
 /-- Type synonym to view a Boolean ring as a Boolean algebra. -/
-def AsBoolring (α : Type _) :=
+def AsBoolRing (α : Type _) :=
   α
-#align as_boolring AsBoolring
+#align as_boolring AsBoolRing
+-/
 
+#print toBoolRing /-
 /-- The "identity" equivalence between `as_boolring α` and `α`. -/
-def toBoolring : α ≃ AsBoolring α :=
+def toBoolRing : α ≃ AsBoolRing α :=
   Equiv.refl _
-#align to_boolring toBoolring
+#align to_boolring toBoolRing
+-/
 
+#print ofBoolRing /-
 /-- The "identity" equivalence between `α` and `as_boolring α`. -/
-def ofBoolring : AsBoolring α ≃ α :=
+def ofBoolRing : AsBoolRing α ≃ α :=
   Equiv.refl _
-#align of_boolring ofBoolring
+#align of_boolring ofBoolRing
+-/
 
+#print toBoolRing_symm_eq /-
 @[simp]
-theorem toBoolring_symm_eq : (@toBoolring α).symm = ofBoolring :=
+theorem toBoolRing_symm_eq : (@toBoolRing α).symm = ofBoolRing :=
   rfl
-#align to_boolring_symm_eq toBoolring_symm_eq
+#align to_boolring_symm_eq toBoolRing_symm_eq
+-/
 
+#print ofBoolRing_symm_eq /-
 @[simp]
-theorem ofBoolring_symm_eq : (@ofBoolring α).symm = toBoolring :=
+theorem ofBoolRing_symm_eq : (@ofBoolRing α).symm = toBoolRing :=
   rfl
-#align of_boolring_symm_eq ofBoolring_symm_eq
+#align of_boolring_symm_eq ofBoolRing_symm_eq
+-/
 
+#print toBoolRing_ofBoolRing /-
 @[simp]
-theorem toBoolring_ofBoolring (a : AsBoolring α) : toBoolring (ofBoolring a) = a :=
+theorem toBoolRing_ofBoolRing (a : AsBoolRing α) : toBoolRing (ofBoolRing a) = a :=
   rfl
-#align to_boolring_of_boolring toBoolring_ofBoolring
+#align to_boolring_of_boolring toBoolRing_ofBoolRing
+-/
 
+#print ofBoolRing_toBoolRing /-
 @[simp]
-theorem ofBoolring_toBoolring (a : α) : ofBoolring (toBoolring a) = a :=
+theorem ofBoolRing_toBoolRing (a : α) : ofBoolRing (toBoolRing a) = a :=
   rfl
-#align of_boolring_to_boolring ofBoolring_toBoolring
+#align of_boolring_to_boolring ofBoolRing_toBoolRing
+-/
 
+#print toBoolRing_inj /-
 @[simp]
-theorem toBoolring_inj {a b : α} : toBoolring a = toBoolring b ↔ a = b :=
+theorem toBoolRing_inj {a b : α} : toBoolRing a = toBoolRing b ↔ a = b :=
   Iff.rfl
-#align to_boolring_inj toBoolring_inj
+#align to_boolring_inj toBoolRing_inj
+-/
 
+#print ofBoolRing_inj /-
 @[simp]
-theorem ofBoolring_inj {a b : AsBoolring α} : ofBoolring a = ofBoolring b ↔ a = b :=
+theorem ofBoolRing_inj {a b : AsBoolRing α} : ofBoolRing a = ofBoolRing b ↔ a = b :=
   Iff.rfl
-#align of_boolring_inj ofBoolring_inj
+#align of_boolring_inj ofBoolRing_inj
+-/
 
-instance [Inhabited α] : Inhabited (AsBoolring α) :=
+instance [Inhabited α] : Inhabited (AsBoolRing α) :=
   ‹Inhabited α›
 
+#print GeneralizedBooleanAlgebra.toNonUnitalCommRing /-
 -- See note [reducible non-instances]
 /-- Every generalized Boolean algebra has the structure of a non unital commutative ring with the
 following data:
@@ -473,12 +622,14 @@ def GeneralizedBooleanAlgebra.toNonUnitalCommRing [GeneralizedBooleanAlgebra α]
   left_distrib := inf_symmDiff_distrib_left
   right_distrib := inf_symmDiff_distrib_right
 #align generalized_boolean_algebra.to_non_unital_comm_ring GeneralizedBooleanAlgebra.toNonUnitalCommRing
+-/
 
-instance [GeneralizedBooleanAlgebra α] : NonUnitalCommRing (AsBoolring α) :=
+instance [GeneralizedBooleanAlgebra α] : NonUnitalCommRing (AsBoolRing α) :=
   @GeneralizedBooleanAlgebra.toNonUnitalCommRing α _
 
 variable [BooleanAlgebra α] [BooleanAlgebra β] [BooleanAlgebra γ]
 
+#print BooleanAlgebra.toBooleanRing /-
 -- See note [reducible non-instances]
 /-- Every Boolean algebra has the structure of a Boolean ring with the following data:
 
@@ -497,117 +648,158 @@ def BooleanAlgebra.toBooleanRing : BooleanRing α :=
     mul_one := fun _ => inf_top_eq
     mul_self := fun b => inf_idem }
 #align boolean_algebra.to_boolean_ring BooleanAlgebra.toBooleanRing
+-/
 
 scoped[BooleanRingOfBooleanAlgebra]
   attribute [instance 100]
     GeneralizedBooleanAlgebra.toNonUnitalCommRing BooleanAlgebra.toBooleanRing
 
-instance : BooleanRing (AsBoolring α) :=
+instance : BooleanRing (AsBoolRing α) :=
   @BooleanAlgebra.toBooleanRing α _
 
+#print ofBoolRing_zero /-
 @[simp]
-theorem ofBoolring_zero : ofBoolring (0 : AsBoolring α) = ⊥ :=
+theorem ofBoolRing_zero : ofBoolRing (0 : AsBoolRing α) = ⊥ :=
   rfl
-#align of_boolring_zero ofBoolring_zero
+#align of_boolring_zero ofBoolRing_zero
+-/
 
+#print ofBoolRing_one /-
 @[simp]
-theorem ofBoolring_one : ofBoolring (1 : AsBoolring α) = ⊤ :=
+theorem ofBoolRing_one : ofBoolRing (1 : AsBoolRing α) = ⊤ :=
   rfl
-#align of_boolring_one ofBoolring_one
+#align of_boolring_one ofBoolRing_one
+-/
 
+#print ofBoolRing_neg /-
 -- `sub_eq_add` proves this lemma but it is eligible for `dsimp`
 @[simp, nolint simp_nf]
-theorem ofBoolring_neg (a : AsBoolring α) : ofBoolring (-a) = ofBoolring a :=
+theorem ofBoolRing_neg (a : AsBoolRing α) : ofBoolRing (-a) = ofBoolRing a :=
   rfl
-#align of_boolring_neg ofBoolring_neg
+#align of_boolring_neg ofBoolRing_neg
+-/
 
+#print ofBoolRing_add /-
 @[simp]
-theorem ofBoolring_add (a b : AsBoolring α) : ofBoolring (a + b) = ofBoolring a ∆ ofBoolring b :=
+theorem ofBoolRing_add (a b : AsBoolRing α) : ofBoolRing (a + b) = ofBoolRing a ∆ ofBoolRing b :=
   rfl
-#align of_boolring_add ofBoolring_add
+#align of_boolring_add ofBoolRing_add
+-/
 
+#print ofBoolRing_sub /-
 -- `sub_eq_add` simplifies the LHS but this lemma is eligible for `dsimp`
 @[simp, nolint simp_nf]
-theorem ofBoolring_sub (a b : AsBoolring α) : ofBoolring (a - b) = ofBoolring a ∆ ofBoolring b :=
+theorem ofBoolRing_sub (a b : AsBoolRing α) : ofBoolRing (a - b) = ofBoolRing a ∆ ofBoolRing b :=
   rfl
-#align of_boolring_sub ofBoolring_sub
+#align of_boolring_sub ofBoolRing_sub
+-/
 
+#print ofBoolRing_mul /-
 @[simp]
-theorem ofBoolring_mul (a b : AsBoolring α) : ofBoolring (a * b) = ofBoolring a ⊓ ofBoolring b :=
+theorem ofBoolRing_mul (a b : AsBoolRing α) : ofBoolRing (a * b) = ofBoolRing a ⊓ ofBoolRing b :=
   rfl
-#align of_boolring_mul ofBoolring_mul
+#align of_boolring_mul ofBoolRing_mul
+-/
 
+#print ofBoolRing_le_ofBoolRing_iff /-
 @[simp]
-theorem ofBoolring_le_ofBoolring_iff {a b : AsBoolring α} :
-    ofBoolring a ≤ ofBoolring b ↔ a * b = a :=
+theorem ofBoolRing_le_ofBoolRing_iff {a b : AsBoolRing α} :
+    ofBoolRing a ≤ ofBoolRing b ↔ a * b = a :=
   inf_eq_left.symm
-#align of_boolring_le_of_boolring_iff ofBoolring_le_ofBoolring_iff
+#align of_boolring_le_of_boolring_iff ofBoolRing_le_ofBoolRing_iff
+-/
 
+#print toBoolRing_bot /-
 @[simp]
-theorem toBoolring_bot : toBoolring (⊥ : α) = 0 :=
+theorem toBoolRing_bot : toBoolRing (⊥ : α) = 0 :=
   rfl
-#align to_boolring_bot toBoolring_bot
+#align to_boolring_bot toBoolRing_bot
+-/
 
+#print toBoolRing_top /-
 @[simp]
-theorem toBoolring_top : toBoolring (⊤ : α) = 1 :=
+theorem toBoolRing_top : toBoolRing (⊤ : α) = 1 :=
   rfl
-#align to_boolring_top toBoolring_top
+#align to_boolring_top toBoolRing_top
+-/
 
+#print toBoolRing_inf /-
 @[simp]
-theorem toBoolring_inf (a b : α) : toBoolring (a ⊓ b) = toBoolring a * toBoolring b :=
+theorem toBoolRing_inf (a b : α) : toBoolRing (a ⊓ b) = toBoolRing a * toBoolRing b :=
   rfl
-#align to_boolring_inf toBoolring_inf
+#align to_boolring_inf toBoolRing_inf
+-/
 
+#print toBoolRing_symmDiff /-
 @[simp]
-theorem toBoolring_symmDiff (a b : α) : toBoolring (a ∆ b) = toBoolring a + toBoolring b :=
+theorem toBoolRing_symmDiff (a b : α) : toBoolRing (a ∆ b) = toBoolRing a + toBoolRing b :=
   rfl
-#align to_boolring_symm_diff toBoolring_symmDiff
+#align to_boolring_symm_diff toBoolRing_symmDiff
+-/
 
+#print BoundedLatticeHom.asBoolRing /-
 /-- Turn a bounded lattice homomorphism from Boolean algebras `α` to `β` into a ring homomorphism
 from `α` to `β` considered as Boolean rings. -/
 @[simps]
-protected def BoundedLatticeHom.asBoolring (f : BoundedLatticeHom α β) :
-    AsBoolring α →+* AsBoolring β
+protected def BoundedLatticeHom.asBoolRing (f : BoundedLatticeHom α β) :
+    AsBoolRing α →+* AsBoolRing β
     where
-  toFun := toBoolring ∘ f ∘ ofBoolring
+  toFun := toBoolRing ∘ f ∘ ofBoolRing
   map_zero' := f.map_bot'
   map_one' := f.map_top'
   map_add' := map_symm_diff' f
   map_mul' := f.map_inf'
-#align bounded_lattice_hom.as_boolring BoundedLatticeHom.asBoolring
+#align bounded_lattice_hom.as_boolring BoundedLatticeHom.asBoolRing
+-/
 
+#print BoundedLatticeHom.asBoolRing_id /-
 @[simp]
-theorem BoundedLatticeHom.asBoolring_id : (BoundedLatticeHom.id α).AsBoolring = RingHom.id _ :=
+theorem BoundedLatticeHom.asBoolRing_id : (BoundedLatticeHom.id α).AsBoolRing = RingHom.id _ :=
   rfl
-#align bounded_lattice_hom.as_boolring_id BoundedLatticeHom.asBoolring_id
+#align bounded_lattice_hom.as_boolring_id BoundedLatticeHom.asBoolRing_id
+-/
 
+/- warning: bounded_lattice_hom.as_boolring_comp -> BoundedLatticeHom.asBoolRing_comp is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : BooleanAlgebra.{u1} α] [_inst_2 : BooleanAlgebra.{u2} β] [_inst_3 : BooleanAlgebra.{u3} γ] (g : BoundedLatticeHom.{u2, u3} β γ (GeneralizedCoheytingAlgebra.toLattice.{u2} β (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} β (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} β _inst_2))) (GeneralizedCoheytingAlgebra.toLattice.{u3} γ (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} γ (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} γ _inst_3))) (BooleanAlgebra.toBoundedOrder.{u2} β _inst_2) (BooleanAlgebra.toBoundedOrder.{u3} γ _inst_3)) (f : BoundedLatticeHom.{u1, u2} α β (GeneralizedCoheytingAlgebra.toLattice.{u1} α (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} α _inst_1))) (GeneralizedCoheytingAlgebra.toLattice.{u2} β (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} β (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} β _inst_2))) (BooleanAlgebra.toBoundedOrder.{u1} α _inst_1) (BooleanAlgebra.toBoundedOrder.{u2} β _inst_2)), Eq.{max (succ u1) (succ u3)} (RingHom.{u1, u3} (AsBoolRing.{u1} α) (AsBoolRing.{u3} γ) (NonAssocRing.toNonAssocSemiring.{u1} (AsBoolRing.{u1} α) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} α) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} α) (AsBoolRing.booleanRing.{u1} α _inst_1)))) (NonAssocRing.toNonAssocSemiring.{u3} (AsBoolRing.{u3} γ) (Ring.toNonAssocRing.{u3} (AsBoolRing.{u3} γ) (BooleanRing.toRing.{u3} (AsBoolRing.{u3} γ) (AsBoolRing.booleanRing.{u3} γ _inst_3))))) (BoundedLatticeHom.asBoolRing.{u1, u3} α γ _inst_1 _inst_3 (BoundedLatticeHom.comp.{u1, u2, u3} α β γ (GeneralizedCoheytingAlgebra.toLattice.{u1} α (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} α _inst_1))) (GeneralizedCoheytingAlgebra.toLattice.{u2} β (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} β (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} β _inst_2))) (GeneralizedCoheytingAlgebra.toLattice.{u3} γ (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} γ (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} γ _inst_3))) (BooleanAlgebra.toBoundedOrder.{u1} α _inst_1) (BooleanAlgebra.toBoundedOrder.{u2} β _inst_2) (BooleanAlgebra.toBoundedOrder.{u3} γ _inst_3) g f)) (RingHom.comp.{u1, u2, u3} (AsBoolRing.{u1} α) (AsBoolRing.{u2} β) (AsBoolRing.{u3} γ) (NonAssocRing.toNonAssocSemiring.{u1} (AsBoolRing.{u1} α) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} α) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} α) (AsBoolRing.booleanRing.{u1} α _inst_1)))) (NonAssocRing.toNonAssocSemiring.{u2} (AsBoolRing.{u2} β) (Ring.toNonAssocRing.{u2} (AsBoolRing.{u2} β) (BooleanRing.toRing.{u2} (AsBoolRing.{u2} β) (AsBoolRing.booleanRing.{u2} β _inst_2)))) (NonAssocRing.toNonAssocSemiring.{u3} (AsBoolRing.{u3} γ) (Ring.toNonAssocRing.{u3} (AsBoolRing.{u3} γ) (BooleanRing.toRing.{u3} (AsBoolRing.{u3} γ) (AsBoolRing.booleanRing.{u3} γ _inst_3)))) (BoundedLatticeHom.asBoolRing.{u2, u3} β γ _inst_2 _inst_3 g) (BoundedLatticeHom.asBoolRing.{u1, u2} α β _inst_1 _inst_2 f))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u3}} {γ : Type.{u2}} [_inst_1 : BooleanAlgebra.{u1} α] [_inst_2 : BooleanAlgebra.{u3} β] [_inst_3 : BooleanAlgebra.{u2} γ] (g : BoundedLatticeHom.{u3, u2} β γ (GeneralizedCoheytingAlgebra.toLattice.{u3} β (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u3} β (BiheytingAlgebra.toCoheytingAlgebra.{u3} β (BooleanAlgebra.toBiheytingAlgebra.{u3} β _inst_2)))) (GeneralizedCoheytingAlgebra.toLattice.{u2} γ (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} γ (BiheytingAlgebra.toCoheytingAlgebra.{u2} γ (BooleanAlgebra.toBiheytingAlgebra.{u2} γ _inst_3)))) (BooleanAlgebra.toBoundedOrder.{u3} β _inst_2) (BooleanAlgebra.toBoundedOrder.{u2} γ _inst_3)) (f : BoundedLatticeHom.{u1, u3} α β (GeneralizedCoheytingAlgebra.toLattice.{u1} α (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BiheytingAlgebra.toCoheytingAlgebra.{u1} α (BooleanAlgebra.toBiheytingAlgebra.{u1} α _inst_1)))) (GeneralizedCoheytingAlgebra.toLattice.{u3} β (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u3} β (BiheytingAlgebra.toCoheytingAlgebra.{u3} β (BooleanAlgebra.toBiheytingAlgebra.{u3} β _inst_2)))) (BooleanAlgebra.toBoundedOrder.{u1} α _inst_1) (BooleanAlgebra.toBoundedOrder.{u3} β _inst_2)), Eq.{max (succ u1) (succ u2)} (RingHom.{u1, u2} (AsBoolRing.{u1} α) (AsBoolRing.{u2} γ) (Semiring.toNonAssocSemiring.{u1} (AsBoolRing.{u1} α) (CommSemiring.toSemiring.{u1} (AsBoolRing.{u1} α) (CommRing.toCommSemiring.{u1} (AsBoolRing.{u1} α) (BooleanRing.toCommRing.{u1} (AsBoolRing.{u1} α) (instBooleanRingAsBoolRing.{u1} α _inst_1))))) (Semiring.toNonAssocSemiring.{u2} (AsBoolRing.{u2} γ) (CommSemiring.toSemiring.{u2} (AsBoolRing.{u2} γ) (CommRing.toCommSemiring.{u2} (AsBoolRing.{u2} γ) (BooleanRing.toCommRing.{u2} (AsBoolRing.{u2} γ) (instBooleanRingAsBoolRing.{u2} γ _inst_3)))))) (BoundedLatticeHom.asBoolRing.{u1, u2} α γ _inst_1 _inst_3 (BoundedLatticeHom.comp.{u1, u3, u2} α β γ (GeneralizedCoheytingAlgebra.toLattice.{u1} α (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BiheytingAlgebra.toCoheytingAlgebra.{u1} α (BooleanAlgebra.toBiheytingAlgebra.{u1} α _inst_1)))) (GeneralizedCoheytingAlgebra.toLattice.{u3} β (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u3} β (BiheytingAlgebra.toCoheytingAlgebra.{u3} β (BooleanAlgebra.toBiheytingAlgebra.{u3} β _inst_2)))) (GeneralizedCoheytingAlgebra.toLattice.{u2} γ (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} γ (BiheytingAlgebra.toCoheytingAlgebra.{u2} γ (BooleanAlgebra.toBiheytingAlgebra.{u2} γ _inst_3)))) (BooleanAlgebra.toBoundedOrder.{u1} α _inst_1) (BooleanAlgebra.toBoundedOrder.{u3} β _inst_2) (BooleanAlgebra.toBoundedOrder.{u2} γ _inst_3) g f)) (RingHom.comp.{u1, u3, u2} (AsBoolRing.{u1} α) (AsBoolRing.{u3} β) (AsBoolRing.{u2} γ) (Semiring.toNonAssocSemiring.{u1} (AsBoolRing.{u1} α) (CommSemiring.toSemiring.{u1} (AsBoolRing.{u1} α) (CommRing.toCommSemiring.{u1} (AsBoolRing.{u1} α) (BooleanRing.toCommRing.{u1} (AsBoolRing.{u1} α) (instBooleanRingAsBoolRing.{u1} α _inst_1))))) (Semiring.toNonAssocSemiring.{u3} (AsBoolRing.{u3} β) (CommSemiring.toSemiring.{u3} (AsBoolRing.{u3} β) (CommRing.toCommSemiring.{u3} (AsBoolRing.{u3} β) (BooleanRing.toCommRing.{u3} (AsBoolRing.{u3} β) (instBooleanRingAsBoolRing.{u3} β _inst_2))))) (Semiring.toNonAssocSemiring.{u2} (AsBoolRing.{u2} γ) (CommSemiring.toSemiring.{u2} (AsBoolRing.{u2} γ) (CommRing.toCommSemiring.{u2} (AsBoolRing.{u2} γ) (BooleanRing.toCommRing.{u2} (AsBoolRing.{u2} γ) (instBooleanRingAsBoolRing.{u2} γ _inst_3))))) (BoundedLatticeHom.asBoolRing.{u3, u2} β γ _inst_2 _inst_3 g) (BoundedLatticeHom.asBoolRing.{u1, u3} α β _inst_1 _inst_2 f))
+Case conversion may be inaccurate. Consider using '#align bounded_lattice_hom.as_boolring_comp BoundedLatticeHom.asBoolRing_compₓ'. -/
 @[simp]
-theorem BoundedLatticeHom.asBoolring_comp (g : BoundedLatticeHom β γ) (f : BoundedLatticeHom α β) :
-    (g.comp f).AsBoolring = g.AsBoolring.comp f.AsBoolring :=
+theorem BoundedLatticeHom.asBoolRing_comp (g : BoundedLatticeHom β γ) (f : BoundedLatticeHom α β) :
+    (g.comp f).AsBoolRing = g.AsBoolRing.comp f.AsBoolRing :=
   rfl
-#align bounded_lattice_hom.as_boolring_comp BoundedLatticeHom.asBoolring_comp
+#align bounded_lattice_hom.as_boolring_comp BoundedLatticeHom.asBoolRing_comp
 
 end AlgebraToRing
 
 /-! ### Equivalence between Boolean rings and Boolean algebras -/
 
 
+#print OrderIso.asBoolAlgAsBoolRing /-
 /-- Order isomorphism between `α` considered as a Boolean ring considered as a Boolean algebra and
 `α`. -/
 @[simps]
-def OrderIso.asBoolalgAsBoolring (α : Type _) [BooleanAlgebra α] : AsBoolalg (AsBoolring α) ≃o α :=
-  ⟨ofBoolalg.trans ofBoolring, fun a b =>
-    ofBoolring_le_ofBoolring_iff.trans ofBoolalg_mul_ofBoolalg_eq_left_iff⟩
-#align order_iso.as_boolalg_as_boolring OrderIso.asBoolalgAsBoolring
+def OrderIso.asBoolAlgAsBoolRing (α : Type _) [BooleanAlgebra α] : AsBoolAlg (AsBoolRing α) ≃o α :=
+  ⟨ofBoolAlg.trans ofBoolRing, fun a b =>
+    ofBoolRing_le_ofBoolRing_iff.trans ofBoolAlg_mul_ofBoolAlg_eq_left_iff⟩
+#align order_iso.as_boolalg_as_boolring OrderIso.asBoolAlgAsBoolRing
+-/
 
+/- warning: ring_equiv.as_boolring_as_boolalg -> RingEquiv.asBoolRingAsBoolAlg is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [_inst_1 : BooleanRing.{u1} α], RingEquiv.{u1, u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) α (Distrib.toHasMul.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (Ring.toDistrib.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (AsBoolRing.booleanRing.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1))))) (Distrib.toHasAdd.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (Ring.toDistrib.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (AsBoolRing.booleanRing.{u1} (AsBoolAlg.{u1} α) (AsBoolAlg.booleanAlgebra.{u1} α _inst_1))))) (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1))) (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))
+but is expected to have type
+  forall (α : Type.{u1}) [_inst_1 : BooleanRing.{u1} α], RingEquiv.{u1, u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) α (NonUnitalNonAssocRing.toMul.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (instBooleanRingAsBoolRing.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1)))))) (NonUnitalNonAssocRing.toMul.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1)))) (Distrib.toAdd.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (NonUnitalNonAssocSemiring.toDistrib.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (Ring.toNonAssocRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (BooleanRing.toRing.{u1} (AsBoolRing.{u1} (AsBoolAlg.{u1} α)) (instBooleanRingAsBoolRing.{u1} (AsBoolAlg.{u1} α) (instBooleanAlgebraAsBoolAlg.{u1} α _inst_1)))))))) (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (BooleanRing.toRing.{u1} α _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align ring_equiv.as_boolring_as_boolalg RingEquiv.asBoolRingAsBoolAlgₓ'. -/
 /-- Ring isomorphism between `α` considered as a Boolean algebra considered as a Boolean ring and
 `α`. -/
 @[simps]
-def RingEquiv.asBoolringAsBoolalg (α : Type _) [BooleanRing α] : AsBoolring (AsBoolalg α) ≃+* α :=
-  { ofBoolring.trans ofBoolalg with
+def RingEquiv.asBoolRingAsBoolAlg (α : Type _) [BooleanRing α] : AsBoolRing (AsBoolAlg α) ≃+* α :=
+  { ofBoolRing.trans ofBoolAlg with
     map_mul' := fun a b => rfl
-    map_add' := ofBoolalg_symmDiff }
-#align ring_equiv.as_boolring_as_boolalg RingEquiv.asBoolringAsBoolalg
+    map_add' := ofBoolAlg_symmDiff }
+#align ring_equiv.as_boolring_as_boolalg RingEquiv.asBoolRingAsBoolAlg
 
 open Bool
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/09079525fd01b3dda35e96adaa08d2f943e1648c

@@ -191,9 +191,9 @@ def hasInf : Inf α :=
 #align boolean_ring.has_inf BooleanRing.hasInf
 
 scoped[-- Note [lower instance priority]
-BooleanAlgebraOfBooleanRing] attribute [instance] BooleanRing.hasSup
+BooleanAlgebraOfBooleanRing] attribute [instance 100] BooleanRing.hasSup
 
-scoped[BooleanAlgebraOfBooleanRing] attribute [instance] BooleanRing.hasInf
+scoped[BooleanAlgebraOfBooleanRing] attribute [instance 100] BooleanRing.hasInf
 
 theorem sup_comm (a b : α) : a ⊔ b = b ⊔ a :=
   by
@@ -279,7 +279,7 @@ def toBooleanAlgebra : BooleanAlgebra α :=
       rw [← add_assoc, add_self] }
 #align boolean_ring.to_boolean_algebra BooleanRing.toBooleanAlgebra
 
-scoped[BooleanAlgebraOfBooleanRing] attribute [instance] BooleanRing.toBooleanAlgebra
+scoped[BooleanAlgebraOfBooleanRing] attribute [instance 100] BooleanRing.toBooleanAlgebra
 
 end BooleanRing
 
@@ -499,7 +499,8 @@ def BooleanAlgebra.toBooleanRing : BooleanRing α :=
 #align boolean_algebra.to_boolean_ring BooleanAlgebra.toBooleanRing
 
 scoped[BooleanRingOfBooleanAlgebra]
-  attribute [instance] GeneralizedBooleanAlgebra.toNonUnitalCommRing BooleanAlgebra.toBooleanRing
+  attribute [instance 100]
+    GeneralizedBooleanAlgebra.toNonUnitalCommRing BooleanAlgebra.toBooleanRing
 
 instance : BooleanRing (AsBoolring α) :=
   @BooleanAlgebra.toBooleanRing α _

mathlib commit https://github.com/leanprover-community/mathlib/commit/06a655b5fcfbda03502f9158bbf6c0f1400886f9

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Bryan Gin-ge Chen, Yaël Dillies
 
 ! This file was ported from Lean 3 source module algebra.ring.boolean_ring
-! leanprover-community/mathlib commit 70fd9563a21e7b963887c9360bd29b2393e6225a
+! leanprover-community/mathlib commit e8638a0fcaf73e4500469f368ef9494e495099b3
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -84,12 +84,12 @@ theorem neg_eq : -a = a :=
     
 #align neg_eq neg_eq
 
-theorem add_eq_zero : a + b = 0 ↔ a = b :=
+theorem add_eq_zero' : a + b = 0 ↔ a = b :=
   calc
     a + b = 0 ↔ a = -b := add_eq_zero_iff_eq_neg
     _ ↔ a = b := by rw [neg_eq]
     
-#align add_eq_zero add_eq_zero
+#align add_eq_zero' add_eq_zero'
 
 @[simp]
 theorem mul_add_mul : a * b + b * a = 0 :=
@@ -114,7 +114,8 @@ theorem mul_one_add_self : a * (1 + a) = 0 := by rw [mul_add, mul_one, mul_self,
 
 -- Note [lower instance priority]
 instance (priority := 100) BooleanRing.toCommRing : CommRing α :=
-  { (inferInstance : BooleanRing α) with mul_comm := fun a b => by rw [← add_eq_zero, mul_add_mul] }
+  { (inferInstance : BooleanRing α) with
+    mul_comm := fun a b => by rw [← add_eq_zero', mul_add_mul] }
 #align boolean_ring.to_comm_ring BooleanRing.toCommRing
 
 end BooleanRing

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

@@ -265,7 +265,7 @@ def toBooleanAlgebra : BooleanAlgebra α :=
     top := 1
     le_top := fun a => show a + 1 + a * 1 = 1 by assoc_rw [mul_one, add_comm, add_self, add_zero]
     bot := 0
-    bot_le := fun a => show 0 + a + 0 * a = a by rw [zero_mul, zero_add, add_zero]
+    bot_le := fun a => show 0 + a + 0 * a = a by rw [MulZeroClass.zero_mul, zero_add, add_zero]
     compl := fun a => 1 + a
     inf_compl_le_bot := fun a =>
       show a * (1 + a) + 0 + a * (1 + a) * 0 = 0 by norm_num [mul_add, mul_self, add_self]

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

@@ -180,12 +180,12 @@ variable [BooleanRing α] [BooleanRing β] [BooleanRing γ]
 namespace BooleanRing
 
 /-- The join operation in a Boolean ring is `x + y + x * y`. -/
-def hasSup : HasSup α :=
+def hasSup : Sup α :=
   ⟨fun x y => x + y + x * y⟩
 #align boolean_ring.has_sup BooleanRing.hasSup
 
 /-- The meet operation in a Boolean ring is `x * y`. -/
-def hasInf : HasInf α :=
+def hasInf : Inf α :=
   ⟨(· * ·)⟩
 #align boolean_ring.has_inf BooleanRing.hasInf
 

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

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -248,7 +248,7 @@ def toBooleanAlgebra : BooleanAlgebra α :=
   { Lattice.mk' sup_comm sup_assoc inf_comm inf_assoc sup_inf_self inf_sup_self with
     le_sup_inf := le_sup_inf
     top := 1
-    le_top := fun a => show a + 1 + a * 1 = 1 by rw [mul_one, (add_comm a 1),
+    le_top := fun a => show a + 1 + a * 1 = 1 by rw [mul_one, add_comm a 1,
                                                      add_assoc, add_self, add_zero]
     bot := 0
     bot_le := fun a => show 0 + a + 0 * a = a by rw [zero_mul, zero_add, add_zero]

This PR removes the default values for nsmul and zsmul, forcing the user to populate them manually. The previous behavior can be obtained by writing nsmul := nsmulRec and zsmul := zsmulRec, which is now in the docstring for these fields.

The motivation here is to make it more obvious when module diamonds are being introduced, or at least where they might be hiding; you can now simply search for nsmulRec in the source code.

Arguably we should do the same thing for intCast, natCast, pow, and zpow too, but diamonds are less common in those fields, so I'll leave them to a subsequent PR.

Co-authored-by: Matthew Ballard <matt@mrb.email>

@@ -452,6 +452,8 @@ def GeneralizedBooleanAlgebra.toNonUnitalCommRing [GeneralizedBooleanAlgebra α]
   mul_comm := inf_comm
   left_distrib := inf_symmDiff_distrib_left
   right_distrib := inf_symmDiff_distrib_right
+  nsmul := letI : Zero α := ⟨⊥⟩; letI : Add α := ⟨(· ∆ ·)⟩; nsmulRec
+  zsmul := letI : Zero α := ⟨⊥⟩; letI : Add α := ⟨(· ∆ ·)⟩; letI : Neg α := ⟨id⟩; zsmulRec
 #align generalized_boolean_algebra.to_non_unital_comm_ring GeneralizedBooleanAlgebra.toNonUnitalCommRing
 
 instance [GeneralizedBooleanAlgebra α] : NonUnitalCommRing (AsBoolRing α) :=
@@ -588,19 +590,25 @@ def RingEquiv.asBoolRingAsBoolAlg (α : Type*) [BooleanRing α] : AsBoolRing (As
 
 open Bool
 
+instance : Zero Bool where zero := false
+
+instance : One Bool where one := true
+
+instance : Add Bool where add := xor
+
+instance : Neg Bool where neg := id
+
+instance : Sub Bool where sub := xor
+
+instance : Mul Bool where mul := and
+
 instance : BooleanRing Bool where
-  add := xor
   add_assoc := xor_assoc
-  zero := false
   zero_add := Bool.false_xor
   add_zero := Bool.xor_false
-  neg := id
-  sub := xor
   sub_eq_add_neg _ _ := rfl
   add_left_neg := Bool.xor_self
   add_comm := xor_comm
-  one := true
-  mul := and
   mul_assoc := and_assoc
   one_mul := Bool.true_and
   mul_one := Bool.and_true
@@ -609,3 +617,5 @@ instance : BooleanRing Bool where
   mul_self := Bool.and_self
   zero_mul a := rfl
   mul_zero a := by cases a <;> rfl
+  nsmul := nsmulRec
+  zsmul := zsmulRec

Classifies by adding issue number #11215 to porting notes claiming "TODO".

@@ -183,7 +183,7 @@ def inf : Inf α :=
   ⟨(· * ·)⟩
 #align boolean_ring.has_inf BooleanRing.inf
 
--- Porting note: TODO: add priority 100. lower instance priority
+-- Porting note (#11215): TODO: add priority 100. lower instance priority
 scoped [BooleanAlgebraOfBooleanRing] attribute [instance] BooleanRing.sup
 scoped [BooleanAlgebraOfBooleanRing] attribute [instance] BooleanRing.inf
 open BooleanAlgebraOfBooleanRing
@@ -263,7 +263,7 @@ def toBooleanAlgebra : BooleanAlgebra α :=
       rw [← add_assoc, add_self] }
 #align boolean_ring.to_boolean_algebra BooleanRing.toBooleanAlgebra
 
--- Porting note: TODO: add priority 100. lower instance priority
+-- Porting note (#11215): TODO: add priority 100. lower instance priority
 scoped[BooleanAlgebraOfBooleanRing] attribute [instance] BooleanRing.toBooleanAlgebra
 
 end BooleanRing

Those lemmas have historically been very annoying to use in rw since all their arguments were implicit. One too many people complained about it on Zulip, so I'm changing them.

Downstream code broken by this change can fix it by adding appropriately many _s.

Also marks CauSeq.ext @[ext].

Order.BoundedOrder

• top_sup_eq
• sup_top_eq
• bot_sup_eq
• sup_bot_eq
• top_inf_eq
• inf_top_eq
• bot_inf_eq
• inf_bot_eq

Order.Lattice

• sup_idem
• sup_comm
• sup_assoc
• sup_left_idem
• sup_right_idem
• inf_idem
• inf_comm
• inf_assoc
• inf_left_idem
• inf_right_idem
• sup_inf_left
• sup_inf_right
• inf_sup_left
• inf_sup_right

Order.MinMax

• max_min_distrib_left
• max_min_distrib_right
• min_max_distrib_left
• min_max_distrib_right

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -442,14 +442,14 @@ def GeneralizedBooleanAlgebra.toNonUnitalCommRing [GeneralizedBooleanAlgebra α]
   zero := ⊥
   zero_add := bot_symmDiff
   add_zero := symmDiff_bot
-  zero_mul _ := bot_inf_eq
-  mul_zero _ := inf_bot_eq
+  zero_mul := bot_inf_eq
+  mul_zero := inf_bot_eq
   neg := id
   add_left_neg := symmDiff_self
   add_comm := symmDiff_comm
   mul := (· ⊓ ·)
-  mul_assoc _ _ _ := inf_assoc
-  mul_comm _ _ := inf_comm
+  mul_assoc := inf_assoc
+  mul_comm := inf_comm
   left_distrib := inf_symmDiff_distrib_left
   right_distrib := inf_symmDiff_distrib_right
 #align generalized_boolean_algebra.to_non_unital_comm_ring GeneralizedBooleanAlgebra.toNonUnitalCommRing
@@ -469,12 +469,12 @@ variable [BooleanAlgebra α] [BooleanAlgebra β] [BooleanAlgebra γ]
 * `1` unfolds to `⊤`
 -/
 @[reducible]
-def BooleanAlgebra.toBooleanRing : BooleanRing α :=
-  { GeneralizedBooleanAlgebra.toNonUnitalCommRing with
-    one := ⊤
-    one_mul := fun _ => top_inf_eq
-    mul_one := fun _ => inf_top_eq
-    mul_self := fun b => inf_idem }
+def BooleanAlgebra.toBooleanRing : BooleanRing α where
+  __ := GeneralizedBooleanAlgebra.toNonUnitalCommRing
+  one := ⊤
+  one_mul := top_inf_eq
+  mul_one := inf_top_eq
+  mul_self := inf_idem
 #align boolean_algebra.to_boolean_ring BooleanAlgebra.toBooleanRing
 
 scoped[BooleanRingOfBooleanAlgebra]

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to simp can prove this or simp can simplify this.

@@ -156,12 +156,12 @@ theorem ofBoolAlg_toBoolAlg (a : α) : ofBoolAlg (toBoolAlg a) = a :=
   rfl
 #align of_boolalg_to_boolalg ofBoolAlg_toBoolAlg
 
--- Porting note: simp can prove this -- @[simp]
+-- Porting note (#10618): simp can prove this -- @[simp]
 theorem toBoolAlg_inj {a b : α} : toBoolAlg a = toBoolAlg b ↔ a = b :=
   Iff.rfl
 #align to_boolalg_inj toBoolAlg_inj
 
--- Porting note: simp can prove this -- @[simp]
+-- Porting note (#10618): simp can prove this -- @[simp]
 theorem ofBoolAlg_inj {a b : AsBoolAlg α} : ofBoolAlg a = ofBoolAlg b ↔ a = b :=
   Iff.rfl
 #align of_boolalg_inj ofBoolAlg_inj
@@ -412,12 +412,12 @@ theorem ofBoolRing_toBoolRing (a : α) : ofBoolRing (toBoolRing a) = a :=
   rfl
 #align of_boolring_to_boolring ofBoolRing_toBoolRing
 
--- Porting note: simp can prove this -- @[simp]
+-- Porting note (#10618): simp can prove this -- @[simp]
 theorem toBoolRing_inj {a b : α} : toBoolRing a = toBoolRing b ↔ a = b :=
   Iff.rfl
 #align to_boolring_inj toBoolRing_inj
 
--- Porting note: simp can prove this -- @[simp]
+-- Porting note (#10618): simp can prove this -- @[simp]
 theorem ofBoolRing_inj {a b : AsBoolRing α} : ofBoolRing a = ofBoolRing b ↔ a = b :=
   Iff.rfl
 #align of_boolring_inj ofBoolRing_inj

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Joachim Breitner <mail@joachim-breitner.de>

@@ -54,7 +54,7 @@ section BooleanRing
 
 variable [BooleanRing α] (a b : α)
 
-instance : IsIdempotent α (· * ·) :=
+instance : Std.IdempotentOp (α := α) (· * ·) :=
   ⟨BooleanRing.mul_self⟩
 
 @[simp]

Those notations are not scoped whereas the file is very low in the import hierarchy.

@@ -40,6 +40,7 @@ purposes and because it is easier than dealing with
 boolean ring, boolean algebra
 -/
 
+open scoped symmDiff
 
 variable {α β γ : Type*}
 

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>

@@ -342,7 +342,7 @@ theorem toBoolAlg_add_add_mul (a b : α) : toBoolAlg (a + b + a * b) = toBoolAlg
 
 @[simp]
 theorem toBoolAlg_add (a b : α) : toBoolAlg (a + b) = toBoolAlg a ∆ toBoolAlg b :=
-  (ofBoolAlg_symmDiff _ _).symm
+  (ofBoolAlg_symmDiff a b).symm
 #align to_boolalg_add toBoolAlg_add
 
 /-- Turn a ring homomorphism from Boolean rings `α` to `β` into a bounded lattice homomorphism

norm_num was passing the wrong syntax node to elabSimpArgs when elaborating, which essentially had the effect of ignoring all arguments it was passed, i.e. norm_num [add_comm] would not try to commute addition in the simp step. The fix itself is very simple (though not obvious to debug!), probably using TSyntax more would help avoid such issues in future.

Due to this bug many norm_num [blah] became rw [blah]; norm_num or similar, sometimes with porting notes, sometimes not, we fix these porting notes and other regressions during the port also.

Interestingly cancel_denoms uses norm_num [<- mul_assoc] internally, so cancel_denoms also got stronger with this change.

@@ -56,14 +56,12 @@ variable [BooleanRing α] (a b : α)
 instance : IsIdempotent α (· * ·) :=
   ⟨BooleanRing.mul_self⟩
 
--- Porting note: simpNF linter complains. This causes lemmas in other files not to be in simpNF
--- @[simp]
+@[simp]
 theorem mul_self : a * a = a :=
   BooleanRing.mul_self _
 #align mul_self mul_self
 
--- Porting note: simpNF linter complains. This causes lemmas in other files not to be in simpNF
--- @[simp]
+@[simp]
 theorem add_self : a + a = 0 := by
   have : a + a = a + a + (a + a) :=
     calc
@@ -73,8 +71,7 @@ theorem add_self : a + a = 0 := by
   rwa [self_eq_add_left] at this
 #align add_self add_self
 
--- Porting note: simpNF linter complains. This causes lemmas in other files not to be in simpNF
--- @[simp]
+@[simp]
 theorem neg_eq : -a = a :=
   calc
     -a = -a + 0 := by rw [add_zero]
@@ -88,8 +85,7 @@ theorem add_eq_zero' : a + b = 0 ↔ a = b :=
     _ ↔ a = b := by rw [neg_eq]
 #align add_eq_zero' add_eq_zero'
 
--- Porting note: simpNF linter complains. This causes lemmas in other files not to be in simpNF
--- @[simp]
+@[simp]
 theorem mul_add_mul : a * b + b * a = 0 := by
   have : a + b = a + b + (a * b + b * a) :=
     calc
@@ -100,8 +96,7 @@ theorem mul_add_mul : a * b + b * a = 0 := by
   rwa [self_eq_add_right] at this
 #align mul_add_mul mul_add_mul
 
--- Porting note: simpNF linter complains. This causes lemmas in other files not to be in simpNF
--- @[simp]
+@[simp]
 theorem sub_eq_add : a - b = a + b := by rw [sub_eq_add_neg, add_right_inj, neg_eq]
 #align sub_eq_add sub_eq_add
 
@@ -263,7 +258,7 @@ def toBooleanAlgebra : BooleanAlgebra α :=
       change
         1 + (a + (1 + a) + a * (1 + a)) + 1 * (a + (1 + a) + a * (1 + a)) =
           a + (1 + a) + a * (1 + a)
-      norm_num [mul_add, mul_self]
+      norm_num [mul_add, mul_self, add_self]
       rw [← add_assoc, add_self] }
 #align boolean_ring.to_boolean_algebra BooleanRing.toBooleanAlgebra
 

Search&replace MulZeroClass.mul_zero -> mul_zero, MulZeroClass.zero_mul -> zero_mul.

These were introduced by Mathport, as the full name of mul_zero is actually MulZeroClass.mul_zero (it's exported with the short name).

@@ -255,7 +255,7 @@ def toBooleanAlgebra : BooleanAlgebra α :=
     le_top := fun a => show a + 1 + a * 1 = 1 by rw [mul_one, (add_comm a 1),
                                                      add_assoc, add_self, add_zero]
     bot := 0
-    bot_le := fun a => show 0 + a + 0 * a = a by rw [MulZeroClass.zero_mul, zero_add, add_zero]
+    bot_le := fun a => show 0 + a + 0 * a = a by rw [zero_mul, zero_add, add_zero]
     compl := fun a => 1 + a
     inf_compl_le_bot := fun a =>
       show a * (1 + a) + 0 + a * (1 + a) * 0 = 0 by norm_num [mul_add, mul_self, add_self]

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -41,7 +41,7 @@ boolean ring, boolean algebra
 -/
 
 
-variable {α β γ : Type _}
+variable {α β γ : Type*}
 
 /-- A Boolean ring is a ring where multiplication is idempotent. -/
 class BooleanRing (α) extends Ring α where
@@ -126,7 +126,7 @@ instance : BooleanRing PUnit :=
 section RingToAlgebra
 
 /-- Type synonym to view a Boolean ring as a Boolean algebra. -/
-def AsBoolAlg (α : Type _) :=
+def AsBoolAlg (α : Type*) :=
   α
 #align as_boolalg AsBoolAlg
 
@@ -382,7 +382,7 @@ end RingToAlgebra
 section AlgebraToRing
 
 /-- Type synonym to view a Boolean ring as a Boolean algebra. -/
-def AsBoolRing (α : Type _) :=
+def AsBoolRing (α : Type*) :=
   α
 #align as_boolring AsBoolRing
 
@@ -576,7 +576,7 @@ end AlgebraToRing
 /-- Order isomorphism between `α` considered as a Boolean ring considered as a Boolean algebra and
 `α`. -/
 @[simps!]
-def OrderIso.asBoolAlgAsBoolRing (α : Type _) [BooleanAlgebra α] : AsBoolAlg (AsBoolRing α) ≃o α :=
+def OrderIso.asBoolAlgAsBoolRing (α : Type*) [BooleanAlgebra α] : AsBoolAlg (AsBoolRing α) ≃o α :=
   ⟨ofBoolAlg.trans ofBoolRing,
    ofBoolRing_le_ofBoolRing_iff.trans ofBoolAlg_mul_ofBoolAlg_eq_left_iff⟩
 #align order_iso.as_boolalg_as_boolring OrderIso.asBoolAlgAsBoolRing
@@ -584,7 +584,7 @@ def OrderIso.asBoolAlgAsBoolRing (α : Type _) [BooleanAlgebra α] : AsBoolAlg (
 /-- Ring isomorphism between `α` considered as a Boolean algebra considered as a Boolean ring and
 `α`. -/
 @[simps!]
-def RingEquiv.asBoolRingAsBoolAlg (α : Type _) [BooleanRing α] : AsBoolRing (AsBoolAlg α) ≃+* α :=
+def RingEquiv.asBoolRingAsBoolAlg (α : Type*) [BooleanRing α] : AsBoolRing (AsBoolAlg α) ≃+* α :=
   { ofBoolRing.trans ofBoolAlg with
     map_mul' := fun _a _b => rfl
     map_add' := ofBoolAlg_symmDiff }

Also some minor loosely-related other changes.

@@ -306,7 +306,7 @@ theorem ofBoolAlg_sdiff (a b : AsBoolAlg α) : ofBoolAlg (a \ b) = ofBoolAlg a *
   rfl
 #align of_boolalg_sdiff ofBoolAlg_sdiff
 
-private theorem of_boolalg_symm_diff_aux (a b : α) : (a + b + a * b) * (1 + a * b) = a + b :=
+private theorem of_boolalg_symmDiff_aux (a b : α) : (a + b + a * b) * (1 + a * b) = a + b :=
   calc
     (a + b + a * b) * (1 + a * b) = a + b + (a * b + a * b * (a * b)) + (a * (b * b) + a * a * b) :=
       by ring
@@ -315,7 +315,7 @@ private theorem of_boolalg_symm_diff_aux (a b : α) : (a + b + a * b) * (1 + a *
 @[simp]
 theorem ofBoolAlg_symmDiff (a b : AsBoolAlg α) : ofBoolAlg (a ∆ b) = ofBoolAlg a + ofBoolAlg b := by
   rw [symmDiff_eq_sup_sdiff_inf]
-  exact of_boolalg_symm_diff_aux _ _
+  exact of_boolalg_symmDiff_aux _ _
 #align of_boolalg_symm_diff ofBoolAlg_symmDiff
 
 @[simp]
@@ -553,7 +553,7 @@ protected def BoundedLatticeHom.asBoolRing (f : BoundedLatticeHom α β) :
   toFun := toBoolRing ∘ f ∘ ofBoolRing
   map_zero' := f.map_bot'
   map_one' := f.map_top'
-  map_add' := map_symm_diff' f
+  map_add' := map_symmDiff' f
   map_mul' := f.map_inf'
 #align bounded_lattice_hom.as_boolring BoundedLatticeHom.asBoolRing
 

• depends on: #5966

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

@@ -2,17 +2,14 @@
 Copyright (c) 2021 Bryan Gin-ge Chen. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Bryan Gin-ge Chen, Yaël Dillies
-
-! This file was ported from Lean 3 source module algebra.ring.boolean_ring
-! leanprover-community/mathlib commit e8638a0fcaf73e4500469f368ef9494e495099b3
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.PUnitInstances
 import Mathlib.Tactic.Abel
 import Mathlib.Tactic.Ring
 import Mathlib.Order.Hom.Lattice
 
+#align_import algebra.ring.boolean_ring from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
+
 /-!
 # Boolean rings
 

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -300,7 +300,7 @@ theorem ofBoolAlg_inf (a b : AsBoolAlg α) : ofBoolAlg (a ⊓ b) = ofBoolAlg a *
 #align of_boolalg_inf ofBoolAlg_inf
 
 @[simp]
-theorem ofBoolAlg_compl (a : AsBoolAlg α) : ofBoolAlg (aᶜ) = 1 + ofBoolAlg a :=
+theorem ofBoolAlg_compl (a : AsBoolAlg α) : ofBoolAlg aᶜ = 1 + ofBoolAlg a :=
   rfl
 #align of_boolalg_compl ofBoolAlg_compl
 

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -342,7 +342,7 @@ theorem toBoolAlg_mul (a b : α) : toBoolAlg (a * b) = toBoolAlg a ⊓ toBoolAlg
   rfl
 #align to_boolalg_mul toBoolAlg_mul
 
--- `to_boolalg_add` simplifies the LHS but this lemma is eligible to `dsimp`
+-- `toBoolAlg_add` simplifies the LHS but this lemma is eligible to `dsimp`
 @[simp, nolint simpNF]
 theorem toBoolAlg_add_add_mul (a b : α) : toBoolAlg (a + b + a * b) = toBoolAlg a ⊔ toBoolAlg b :=
   rfl
@@ -389,12 +389,12 @@ def AsBoolRing (α : Type _) :=
   α
 #align as_boolring AsBoolRing
 
-/-- The "identity" equivalence between `as_boolring α` and `α`. -/
+/-- The "identity" equivalence between `AsBoolRing α` and `α`. -/
 def toBoolRing : α ≃ AsBoolRing α :=
   Equiv.refl _
 #align to_boolring toBoolRing
 
-/-- The "identity" equivalence between `α` and `as_boolring α`. -/
+/-- The "identity" equivalence between `α` and `AsBoolRing α`. -/
 def ofBoolRing : AsBoolRing α ≃ α :=
   Equiv.refl _
 #align of_boolring ofBoolRing

This makes a mathlib4 version of mathlib3's tactic.basic, now called Mathlib.Tactic.Common, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.

This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -12,7 +12,6 @@ import Mathlib.Algebra.PUnitInstances
 import Mathlib.Tactic.Abel
 import Mathlib.Tactic.Ring
 import Mathlib.Order.Hom.Lattice
-import Mathlib.Tactic.ScopedNS
 
 /-!
 # Boolean rings

@@ -24,7 +24,7 @@ algebras.
 
 * `BooleanRing`: a typeclass for rings where multiplication is idempotent.
 * `BooleanRing.toBooleanAlgebra`: Turn a Boolean ring into a Boolean algebra.
-* `BooleanAlgebra.ToBooleanRing`: Turn a Boolean algebra into a Boolean ring.
+* `BooleanAlgebra.toBooleanRing`: Turn a Boolean algebra into a Boolean ring.
 * `AsBoolAlg`: Type-synonym for the Boolean algebra associated to a Boolean ring.
 * `AsBoolRing`: Type-synonym for the Boolean ring associated to a Boolean algebra.
 
@@ -74,7 +74,6 @@ theorem add_self : a + a = 0 := by
       a + a = (a + a) * (a + a) := by rw [mul_self]
       _ = a * a + a * a + (a * a + a * a) := by rw [add_mul, mul_add]
       _ = a + a + (a + a) := by rw [mul_self]
-
   rwa [self_eq_add_left] at this
 #align add_self add_self
 
@@ -85,14 +84,12 @@ theorem neg_eq : -a = a :=
     -a = -a + 0 := by rw [add_zero]
     _ = -a + -a + a := by rw [← neg_add_self, add_assoc]
     _ = a := by rw [add_self, zero_add]
-
 #align neg_eq neg_eq
 
 theorem add_eq_zero' : a + b = 0 ↔ a = b :=
   calc
     a + b = 0 ↔ a = -b := add_eq_zero_iff_eq_neg
     _ ↔ a = b := by rw [neg_eq]
-
 #align add_eq_zero' add_eq_zero'
 
 -- Porting note: simpNF linter complains. This causes lemmas in other files not to be in simpNF
@@ -104,7 +101,6 @@ theorem mul_add_mul : a * b + b * a = 0 := by
       _ = a * a + a * b + (b * a + b * b) := by rw [add_mul, mul_add, mul_add]
       _ = a + a * b + (b * a + b) := by simp only [mul_self]
       _ = a + b + (a * b + b * a) := by abel
-
   rwa [self_eq_add_right] at this
 #align mul_add_mul mul_add_mul
 
@@ -138,12 +134,12 @@ def AsBoolAlg (α : Type _) :=
   α
 #align as_boolalg AsBoolAlg
 
-/-- The "identity" equivalence between `as_boolalg α` and `α`. -/
+/-- The "identity" equivalence between `AsBoolAlg α` and `α`. -/
 def toBoolAlg : α ≃ AsBoolAlg α :=
   Equiv.refl _
 #align to_boolalg toBoolAlg
 
-/-- The "identity" equivalence between `α` and `as_boolalg α`. -/
+/-- The "identity" equivalence between `α` and `AsBoolAlg α`. -/
 def ofBoolAlg : AsBoolAlg α ≃ α :=
   Equiv.refl _
 #align of_boolalg ofBoolAlg
@@ -482,8 +478,7 @@ variable [BooleanAlgebra α] [BooleanAlgebra β] [BooleanAlgebra γ]
 -/
 @[reducible]
 def BooleanAlgebra.toBooleanRing : BooleanRing α :=
-  {
-    GeneralizedBooleanAlgebra.toNonUnitalCommRing with
+  { GeneralizedBooleanAlgebra.toNonUnitalCommRing with
     one := ⊤
     one_mul := fun _ => top_inf_eq
     mul_one := fun _ => inf_top_eq

Co-authored-by: casavaca <96765450+casavaca@users.noreply.github.com> Co-authored-by: Jon Eugster <eugster.jon@gmail.com>