order.copy ⟷ Mathlib.Order.Copy

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

@@ -3,7 +3,7 @@ Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathbin.Order.ConditionallyCompleteLattice.Basic
+import Order.ConditionallyCompleteLattice.Basic
 
 #align_import order.copy from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
 

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

@@ -2,14 +2,11 @@
 Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module order.copy
-! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.ConditionallyCompleteLattice.Basic
 
+#align_import order.copy from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
+
 /-!
 # Tooling to make copies of lattice structures
 

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

@@ -28,6 +28,7 @@ universe u
 
 variable {α : Type u}
 
+#print BoundedOrder.copy /-
 /-- A function to create a provable equal copy of a bounded order
 with possibly different definitional equalities. -/
 def BoundedOrder.copy {h : LE α} {h' : LE α} (c : @BoundedOrder α h') (top : α)
@@ -39,7 +40,9 @@ def BoundedOrder.copy {h : LE α} {h' : LE α} (c : @BoundedOrder α h') (top :
       bot .. }
   all_goals abstract subst_vars; cases c; simp_rw [le_eq]; assumption
 #align bounded_order.copy BoundedOrder.copy
+-/
 
+#print Lattice.copy /-
 /-- A function to create a provable equal copy of a lattice
 with possibly different definitional equalities. -/
 def Lattice.copy (c : Lattice α) (le : α → α → Prop) (eq_le : le = @Lattice.Le α c)
@@ -52,7 +55,9 @@ def Lattice.copy (c : Lattice α) (le : α → α → Prop) (eq_le : le = @Latti
       inf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align lattice.copy Lattice.copy
+-/
 
+#print DistribLattice.copy /-
 /-- A function to create a provable equal copy of a distributive lattice
 with possibly different definitional equalities. -/
 def DistribLattice.copy (c : DistribLattice α) (le : α → α → Prop)
@@ -65,7 +70,9 @@ def DistribLattice.copy (c : DistribLattice α) (le : α → α → Prop)
       inf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align distrib_lattice.copy DistribLattice.copy
+-/
 
+#print CompleteLattice.copy /-
 /-- A function to create a provable equal copy of a complete lattice
 with possibly different definitional equalities. -/
 def CompleteLattice.copy (c : CompleteLattice α) (le : α → α → Prop)
@@ -89,7 +96,9 @@ def CompleteLattice.copy (c : CompleteLattice α) (le : α → α → Prop)
       sInf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align complete_lattice.copy CompleteLattice.copy
+-/
 
+#print Frame.copy /-
 /-- A function to create a provable equal copy of a frame with possibly different definitional
 equalities. -/
 def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = @Frame.Le α c) (top : α)
@@ -111,7 +120,9 @@ def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = @Frame.Le
       sInf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align frame.copy Frame.copy
+-/
 
+#print Coframe.copy /-
 /-- A function to create a provable equal copy of a coframe with possibly different definitional
 equalities. -/
 def Coframe.copy (c : Coframe α) (le : α → α → Prop) (eq_le : le = @Coframe.Le α c) (top : α)
@@ -133,7 +144,9 @@ def Coframe.copy (c : Coframe α) (le : α → α → Prop) (eq_le : le = @Cofra
       sInf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align coframe.copy Coframe.copy
+-/
 
+#print CompleteDistribLattice.copy /-
 /-- A function to create a provable equal copy of a complete distributive lattice
 with possibly different definitional equalities. -/
 def CompleteDistribLattice.copy (c : CompleteDistribLattice α) (le : α → α → Prop)
@@ -150,7 +163,9 @@ def CompleteDistribLattice.copy (c : CompleteDistribLattice α) (le : α → α
     Coframe.copy (@CompleteDistribLattice.toCoframe α c) le eq_le top eq_top bot eq_bot sup eq_sup
       inf eq_inf Sup eq_Sup Inf eq_Inf with }
 #align complete_distrib_lattice.copy CompleteDistribLattice.copy
+-/
 
+#print ConditionallyCompleteLattice.copy /-
 /-- A function to create a provable equal copy of a conditionally complete lattice
 with possibly different definitional equalities. -/
 def ConditionallyCompleteLattice.copy (c : ConditionallyCompleteLattice α) (le : α → α → Prop)
@@ -168,4 +183,5 @@ def ConditionallyCompleteLattice.copy (c : ConditionallyCompleteLattice α) (le
       sInf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align conditionally_complete_lattice.copy ConditionallyCompleteLattice.copy
+-/
 

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

@@ -36,7 +36,7 @@ def BoundedOrder.copy {h : LE α} {h' : LE α} (c : @BoundedOrder α h') (top :
   by
   refine'
     { top
-      bot.. }
+      bot .. }
   all_goals abstract subst_vars; cases c; simp_rw [le_eq]; assumption
 #align bounded_order.copy BoundedOrder.copy
 
@@ -49,7 +49,7 @@ def Lattice.copy (c : Lattice α) (le : α → α → Prop) (eq_le : le = @Latti
   refine'
     { le
       sup
-      inf.. }
+      inf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align lattice.copy Lattice.copy
 
@@ -62,7 +62,7 @@ def DistribLattice.copy (c : DistribLattice α) (le : α → α → Prop)
   refine'
     { le
       sup
-      inf.. }
+      inf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align distrib_lattice.copy DistribLattice.copy
 
@@ -86,7 +86,7 @@ def CompleteLattice.copy (c : CompleteLattice α) (le : α → α → Prop)
       sup
       inf
       sSup
-      sInf.. }
+      sInf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align complete_lattice.copy CompleteLattice.copy
 
@@ -108,7 +108,7 @@ def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = @Frame.Le
       sup
       inf
       sSup
-      sInf.. }
+      sInf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align frame.copy Frame.copy
 
@@ -130,7 +130,7 @@ def Coframe.copy (c : Coframe α) (le : α → α → Prop) (eq_le : le = @Cofra
       sup
       inf
       sSup
-      sInf.. }
+      sInf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align coframe.copy Coframe.copy
 
@@ -165,7 +165,7 @@ def ConditionallyCompleteLattice.copy (c : ConditionallyCompleteLattice α) (le
       sup
       inf
       sSup
-      sInf.. }
+      sInf .. }
   all_goals abstract subst_vars; cases c; assumption
 #align conditionally_complete_lattice.copy ConditionallyCompleteLattice.copy
 

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

@@ -28,12 +28,6 @@ universe u
 
 variable {α : Type u}
 
-/- warning: bounded_order.copy -> BoundedOrder.copy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {h : LE.{u1} α} {h' : LE.{u1} α} (c : BoundedOrder.{u1} α h') (top : α), (Eq.{succ u1} α top (BoundedOrder.top.{u1} α h' c)) -> (forall (bot : α), (Eq.{succ u1} α bot (BoundedOrder.bot.{u1} α h' c)) -> (forall (x : α) (y : α), Iff (LE.le.{u1} α h x y) (LE.le.{u1} α h' x y)) -> (BoundedOrder.{u1} α h))
-but is expected to have type
-  forall {α : Type.{u1}} {h : LE.{u1} α} {h' : LE.{u1} α} (c : BoundedOrder.{u1} α h') (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (OrderTop.toTop.{u1} α h' (BoundedOrder.toOrderTop.{u1} α h' c))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (OrderBot.toBot.{u1} α h' (BoundedOrder.toOrderBot.{u1} α h' c))))) -> (forall (x : α) (y : α), Iff (LE.le.{u1} α h x y) (LE.le.{u1} α h' x y)) -> (BoundedOrder.{u1} α h))
-Case conversion may be inaccurate. Consider using '#align bounded_order.copy BoundedOrder.copyₓ'. -/
 /-- A function to create a provable equal copy of a bounded order
 with possibly different definitional equalities. -/
 def BoundedOrder.copy {h : LE α} {h' : LE α} (c : @BoundedOrder α h') (top : α)
@@ -46,12 +40,6 @@ def BoundedOrder.copy {h : LE α} {h' : LE α} (c : @BoundedOrder α h') (top :
   all_goals abstract subst_vars; cases c; simp_rw [le_eq]; assumption
 #align bounded_order.copy BoundedOrder.copy
 
-/- warning: lattice.copy -> Lattice.copy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (c : Lattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (Lattice.Le.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Lattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Lattice.inf.{u1} α c)) -> (Lattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} (c : Lattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α c))))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α c))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α c)))) -> (Lattice.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align lattice.copy Lattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a lattice
 with possibly different definitional equalities. -/
 def Lattice.copy (c : Lattice α) (le : α → α → Prop) (eq_le : le = @Lattice.Le α c)
@@ -65,12 +53,6 @@ def Lattice.copy (c : Lattice α) (le : α → α → Prop) (eq_le : le = @Latti
   all_goals abstract subst_vars; cases c; assumption
 #align lattice.copy Lattice.copy
 
-/- warning: distrib_lattice.copy -> DistribLattice.copy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (c : DistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (DistribLattice.Le.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (DistribLattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (DistribLattice.inf.{u1} α c)) -> (DistribLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} (c : DistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α c)))))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (DistribLattice.toLattice.{u1} α c)))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (DistribLattice.toLattice.{u1} α c))))) -> (DistribLattice.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align distrib_lattice.copy DistribLattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a distributive lattice
 with possibly different definitional equalities. -/
 def DistribLattice.copy (c : DistribLattice α) (le : α → α → Prop)
@@ -84,12 +66,6 @@ def DistribLattice.copy (c : DistribLattice α) (le : α → α → Prop)
   all_goals abstract subst_vars; cases c; assumption
 #align distrib_lattice.copy DistribLattice.copy
 
-/- warning: complete_lattice.copy -> CompleteLattice.copy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (c : CompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (CompleteLattice.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (CompleteLattice.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (CompleteLattice.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (CompleteLattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (CompleteLattice.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (CompleteLattice.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (CompleteLattice.inf.{u1} α c)) -> (CompleteLattice.{u1} α)))))))
-but is expected to have type
-  forall {α : Type.{u1}} (c : CompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α c))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α c)))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α c)))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c)))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.sSup.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.sInf.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))) -> (CompleteLattice.{u1} α)))))))
-Case conversion may be inaccurate. Consider using '#align complete_lattice.copy CompleteLattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a complete lattice
 with possibly different definitional equalities. -/
 def CompleteLattice.copy (c : CompleteLattice α) (le : α → α → Prop)
@@ -114,12 +90,6 @@ def CompleteLattice.copy (c : CompleteLattice α) (le : α → α → Prop)
   all_goals abstract subst_vars; cases c; assumption
 #align complete_lattice.copy CompleteLattice.copy
 
-/- warning: frame.copy -> Frame.copy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (c : Order.Frame.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (Order.Frame.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (Order.Frame.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (Order.Frame.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Order.Frame.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Order.Frame.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (Order.Frame.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (Order.Frame.inf.{u1} α c)) -> (Order.Frame.{u1} α)))))))
-but is expected to have type
-  forall {α : Type.{u1}} (c : Order.Frame.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.sSup.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.sInf.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))) -> (Order.Frame.{u1} α)))))))
-Case conversion may be inaccurate. Consider using '#align frame.copy Frame.copyₓ'. -/
 /-- A function to create a provable equal copy of a frame with possibly different definitional
 equalities. -/
 def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = @Frame.Le α c) (top : α)
@@ -142,12 +112,6 @@ def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = @Frame.Le
   all_goals abstract subst_vars; cases c; assumption
 #align frame.copy Frame.copy
 
-/- warning: coframe.copy -> Coframe.copy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (c : Order.Coframe.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (Order.Coframe.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (Order.Coframe.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (Order.Coframe.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Order.Coframe.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Order.Coframe.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (Order.Coframe.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (Order.Coframe.inf.{u1} α c)) -> (Order.Coframe.{u1} α)))))))
-but is expected to have type
-  forall {α : Type.{u1}} (c : Order.Coframe.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.sSup.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.sInf.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))) -> (Order.Coframe.{u1} α)))))))
-Case conversion may be inaccurate. Consider using '#align coframe.copy Coframe.copyₓ'. -/
 /-- A function to create a provable equal copy of a coframe with possibly different definitional
 equalities. -/
 def Coframe.copy (c : Coframe α) (le : α → α → Prop) (eq_le : le = @Coframe.Le α c) (top : α)
@@ -170,12 +134,6 @@ def Coframe.copy (c : Coframe α) (le : α → α → Prop) (eq_le : le = @Cofra
   all_goals abstract subst_vars; cases c; assumption
 #align coframe.copy Coframe.copy
 
-/- warning: complete_distrib_lattice.copy -> CompleteDistribLattice.copy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (c : CompleteDistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (CompleteDistribLattice.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (CompleteDistribLattice.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (CompleteDistribLattice.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (CompleteDistribLattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (CompleteDistribLattice.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (CompleteDistribLattice.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (CompleteDistribLattice.inf.{u1} α c)) -> (CompleteDistribLattice.{u1} α)))))))
-but is expected to have type
-  forall {α : Type.{u1}} (c : CompleteDistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.sSup.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.sInf.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))) -> (CompleteDistribLattice.{u1} α)))))))
-Case conversion may be inaccurate. Consider using '#align complete_distrib_lattice.copy CompleteDistribLattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a complete distributive lattice
 with possibly different definitional equalities. -/
 def CompleteDistribLattice.copy (c : CompleteDistribLattice α) (le : α → α → Prop)
@@ -193,12 +151,6 @@ def CompleteDistribLattice.copy (c : CompleteDistribLattice α) (le : α → α
       inf eq_inf Sup eq_Sup Inf eq_Inf with }
 #align complete_distrib_lattice.copy CompleteDistribLattice.copy
 
-/- warning: conditionally_complete_lattice.copy -> ConditionallyCompleteLattice.copy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (c : ConditionallyCompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (ConditionallyCompleteLattice.Le.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (ConditionallyCompleteLattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (ConditionallyCompleteLattice.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (ConditionallyCompleteLattice.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (ConditionallyCompleteLattice.inf.{u1} α c)) -> (ConditionallyCompleteLattice.{u1} α)))))
-but is expected to have type
-  forall {α : Type.{u1}} (c : ConditionallyCompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c)))))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c)))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.sSup.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α c)))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.sInf.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α c)))) -> (ConditionallyCompleteLattice.{u1} α)))))
-Case conversion may be inaccurate. Consider using '#align conditionally_complete_lattice.copy ConditionallyCompleteLattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a conditionally complete lattice
 with possibly different definitional equalities. -/
 def ConditionallyCompleteLattice.copy (c : ConditionallyCompleteLattice α) (le : α → α → Prop)

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

@@ -88,7 +88,7 @@ def DistribLattice.copy (c : DistribLattice α) (le : α → α → Prop)
 lean 3 declaration is
   forall {α : Type.{u1}} (c : CompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (CompleteLattice.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (CompleteLattice.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (CompleteLattice.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (CompleteLattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (CompleteLattice.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (CompleteLattice.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (CompleteLattice.inf.{u1} α c)) -> (CompleteLattice.{u1} α)))))))
 but is expected to have type
-  forall {α : Type.{u1}} (c : CompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α c))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α c)))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α c)))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c)))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))) -> (CompleteLattice.{u1} α)))))))
+  forall {α : Type.{u1}} (c : CompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α c))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α c)))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α c)))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c)))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.sSup.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.sInf.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))) -> (CompleteLattice.{u1} α)))))))
 Case conversion may be inaccurate. Consider using '#align complete_lattice.copy CompleteLattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a complete lattice
 with possibly different definitional equalities. -/
@@ -109,8 +109,8 @@ def CompleteLattice.copy (c : CompleteLattice α) (le : α → α → Prop)
       bot
       sup
       inf
-      supₛ
-      infₛ.. }
+      sSup
+      sInf.. }
   all_goals abstract subst_vars; cases c; assumption
 #align complete_lattice.copy CompleteLattice.copy
 
@@ -118,7 +118,7 @@ def CompleteLattice.copy (c : CompleteLattice α) (le : α → α → Prop)
 lean 3 declaration is
   forall {α : Type.{u1}} (c : Order.Frame.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (Order.Frame.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (Order.Frame.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (Order.Frame.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Order.Frame.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Order.Frame.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (Order.Frame.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (Order.Frame.inf.{u1} α c)) -> (Order.Frame.{u1} α)))))))
 but is expected to have type
-  forall {α : Type.{u1}} (c : Order.Frame.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))) -> (Order.Frame.{u1} α)))))))
+  forall {α : Type.{u1}} (c : Order.Frame.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.sSup.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.sInf.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))) -> (Order.Frame.{u1} α)))))))
 Case conversion may be inaccurate. Consider using '#align frame.copy Frame.copyₓ'. -/
 /-- A function to create a provable equal copy of a frame with possibly different definitional
 equalities. -/
@@ -137,8 +137,8 @@ def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = @Frame.Le
       bot
       sup
       inf
-      supₛ
-      infₛ.. }
+      sSup
+      sInf.. }
   all_goals abstract subst_vars; cases c; assumption
 #align frame.copy Frame.copy
 
@@ -146,7 +146,7 @@ def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = @Frame.Le
 lean 3 declaration is
   forall {α : Type.{u1}} (c : Order.Coframe.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (Order.Coframe.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (Order.Coframe.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (Order.Coframe.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Order.Coframe.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Order.Coframe.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (Order.Coframe.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (Order.Coframe.inf.{u1} α c)) -> (Order.Coframe.{u1} α)))))))
 but is expected to have type
-  forall {α : Type.{u1}} (c : Order.Coframe.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))) -> (Order.Coframe.{u1} α)))))))
+  forall {α : Type.{u1}} (c : Order.Coframe.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.sSup.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.sInf.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))) -> (Order.Coframe.{u1} α)))))))
 Case conversion may be inaccurate. Consider using '#align coframe.copy Coframe.copyₓ'. -/
 /-- A function to create a provable equal copy of a coframe with possibly different definitional
 equalities. -/
@@ -165,8 +165,8 @@ def Coframe.copy (c : Coframe α) (le : α → α → Prop) (eq_le : le = @Cofra
       bot
       sup
       inf
-      supₛ
-      infₛ.. }
+      sSup
+      sInf.. }
   all_goals abstract subst_vars; cases c; assumption
 #align coframe.copy Coframe.copy
 
@@ -174,7 +174,7 @@ def Coframe.copy (c : Coframe α) (le : α → α → Prop) (eq_le : le = @Cofra
 lean 3 declaration is
   forall {α : Type.{u1}} (c : CompleteDistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (CompleteDistribLattice.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (CompleteDistribLattice.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (CompleteDistribLattice.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (CompleteDistribLattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (CompleteDistribLattice.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (CompleteDistribLattice.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (CompleteDistribLattice.inf.{u1} α c)) -> (CompleteDistribLattice.{u1} α)))))))
 but is expected to have type
-  forall {α : Type.{u1}} (c : CompleteDistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))) -> (CompleteDistribLattice.{u1} α)))))))
+  forall {α : Type.{u1}} (c : CompleteDistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.sSup.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.sInf.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))) -> (CompleteDistribLattice.{u1} α)))))))
 Case conversion may be inaccurate. Consider using '#align complete_distrib_lattice.copy CompleteDistribLattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a complete distributive lattice
 with possibly different definitional equalities. -/
@@ -197,7 +197,7 @@ def CompleteDistribLattice.copy (c : CompleteDistribLattice α) (le : α → α
 lean 3 declaration is
   forall {α : Type.{u1}} (c : ConditionallyCompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (ConditionallyCompleteLattice.Le.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (ConditionallyCompleteLattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (ConditionallyCompleteLattice.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (ConditionallyCompleteLattice.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (ConditionallyCompleteLattice.inf.{u1} α c)) -> (ConditionallyCompleteLattice.{u1} α)))))
 but is expected to have type
-  forall {α : Type.{u1}} (c : ConditionallyCompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c)))))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c)))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α c)))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α c)))) -> (ConditionallyCompleteLattice.{u1} α)))))
+  forall {α : Type.{u1}} (c : ConditionallyCompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c)))))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c)))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.sSup.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α c)))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.sInf.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α c)))) -> (ConditionallyCompleteLattice.{u1} α)))))
 Case conversion may be inaccurate. Consider using '#align conditionally_complete_lattice.copy ConditionallyCompleteLattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a conditionally complete lattice
 with possibly different definitional equalities. -/
@@ -212,8 +212,8 @@ def ConditionallyCompleteLattice.copy (c : ConditionallyCompleteLattice α) (le
     { le
       sup
       inf
-      supₛ
-      infₛ.. }
+      sSup
+      sInf.. }
   all_goals abstract subst_vars; cases c; assumption
 #align conditionally_complete_lattice.copy ConditionallyCompleteLattice.copy
 

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

@@ -50,7 +50,7 @@ def BoundedOrder.copy {h : LE α} {h' : LE α} (c : @BoundedOrder α h') (top :
 lean 3 declaration is
   forall {α : Type.{u1}} (c : Lattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (Lattice.Le.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Lattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Lattice.inf.{u1} α c)) -> (Lattice.{u1} α)))
 but is expected to have type
-  forall {α : Type.{u1}} (c : Lattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α c))))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (HasSup.sup.{u1} α (inferInstance.{succ u1} (HasSup.{u1} α) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α c))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (HasInf.inf.{u1} α (inferInstance.{succ u1} (HasInf.{u1} α) (Lattice.toHasInf.{u1} α c)))) -> (Lattice.{u1} α)))
+  forall {α : Type.{u1}} (c : Lattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α c))))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α c))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α c)))) -> (Lattice.{u1} α)))
 Case conversion may be inaccurate. Consider using '#align lattice.copy Lattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a lattice
 with possibly different definitional equalities. -/
@@ -69,7 +69,7 @@ def Lattice.copy (c : Lattice α) (le : α → α → Prop) (eq_le : le = @Latti
 lean 3 declaration is
   forall {α : Type.{u1}} (c : DistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (DistribLattice.Le.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (DistribLattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (DistribLattice.inf.{u1} α c)) -> (DistribLattice.{u1} α)))
 but is expected to have type
-  forall {α : Type.{u1}} (c : DistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α c)))))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (HasSup.sup.{u1} α (inferInstance.{succ u1} (HasSup.{u1} α) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (DistribLattice.toLattice.{u1} α c)))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (HasInf.inf.{u1} α (inferInstance.{succ u1} (HasInf.{u1} α) (Lattice.toHasInf.{u1} α (DistribLattice.toLattice.{u1} α c))))) -> (DistribLattice.{u1} α)))
+  forall {α : Type.{u1}} (c : DistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α c)))))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (DistribLattice.toLattice.{u1} α c)))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (DistribLattice.toLattice.{u1} α c))))) -> (DistribLattice.{u1} α)))
 Case conversion may be inaccurate. Consider using '#align distrib_lattice.copy DistribLattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a distributive lattice
 with possibly different definitional equalities. -/
@@ -88,7 +88,7 @@ def DistribLattice.copy (c : DistribLattice α) (le : α → α → Prop)
 lean 3 declaration is
   forall {α : Type.{u1}} (c : CompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (CompleteLattice.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (CompleteLattice.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (CompleteLattice.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (CompleteLattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (CompleteLattice.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (CompleteLattice.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (CompleteLattice.inf.{u1} α c)) -> (CompleteLattice.{u1} α)))))))
 but is expected to have type
-  forall {α : Type.{u1}} (c : CompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α c))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α c)))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α c)))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (HasSup.sup.{u1} α (inferInstance.{succ u1} (HasSup.{u1} α) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (HasInf.inf.{u1} α (inferInstance.{succ u1} (HasInf.{u1} α) (Lattice.toHasInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c)))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))) -> (CompleteLattice.{u1} α)))))))
+  forall {α : Type.{u1}} (c : CompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α c))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α c)))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α c)))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c)))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α c))))) -> (CompleteLattice.{u1} α)))))))
 Case conversion may be inaccurate. Consider using '#align complete_lattice.copy CompleteLattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a complete lattice
 with possibly different definitional equalities. -/
@@ -118,7 +118,7 @@ def CompleteLattice.copy (c : CompleteLattice α) (le : α → α → Prop)
 lean 3 declaration is
   forall {α : Type.{u1}} (c : Order.Frame.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (Order.Frame.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (Order.Frame.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (Order.Frame.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Order.Frame.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Order.Frame.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (Order.Frame.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (Order.Frame.inf.{u1} α c)) -> (Order.Frame.{u1} α)))))))
 but is expected to have type
-  forall {α : Type.{u1}} (c : Order.Frame.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (HasSup.sup.{u1} α (inferInstance.{succ u1} (HasSup.{u1} α) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (HasInf.inf.{u1} α (inferInstance.{succ u1} (HasInf.{u1} α) (Lattice.toHasInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))) -> (Order.Frame.{u1} α)))))))
+  forall {α : Type.{u1}} (c : Order.Frame.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Frame.toCompleteLattice.{u1} α c)))))) -> (Order.Frame.{u1} α)))))))
 Case conversion may be inaccurate. Consider using '#align frame.copy Frame.copyₓ'. -/
 /-- A function to create a provable equal copy of a frame with possibly different definitional
 equalities. -/
@@ -146,7 +146,7 @@ def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = @Frame.Le
 lean 3 declaration is
   forall {α : Type.{u1}} (c : Order.Coframe.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (Order.Coframe.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (Order.Coframe.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (Order.Coframe.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Order.Coframe.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Order.Coframe.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (Order.Coframe.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (Order.Coframe.inf.{u1} α c)) -> (Order.Coframe.{u1} α)))))))
 but is expected to have type
-  forall {α : Type.{u1}} (c : Order.Coframe.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (HasSup.sup.{u1} α (inferInstance.{succ u1} (HasSup.{u1} α) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (HasInf.inf.{u1} α (inferInstance.{succ u1} (HasInf.{u1} α) (Lattice.toHasInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))) -> (Order.Coframe.{u1} α)))))))
+  forall {α : Type.{u1}} (c : Order.Coframe.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α c)))))) -> (Order.Coframe.{u1} α)))))))
 Case conversion may be inaccurate. Consider using '#align coframe.copy Coframe.copyₓ'. -/
 /-- A function to create a provable equal copy of a coframe with possibly different definitional
 equalities. -/
@@ -174,7 +174,7 @@ def Coframe.copy (c : Coframe α) (le : α → α → Prop) (eq_le : le = @Cofra
 lean 3 declaration is
   forall {α : Type.{u1}} (c : CompleteDistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (CompleteDistribLattice.Le.{u1} α c)) -> (forall (top : α), (Eq.{succ u1} α top (CompleteDistribLattice.top.{u1} α c)) -> (forall (bot : α), (Eq.{succ u1} α bot (CompleteDistribLattice.bot.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (CompleteDistribLattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (CompleteDistribLattice.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (CompleteDistribLattice.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (CompleteDistribLattice.inf.{u1} α c)) -> (CompleteDistribLattice.{u1} α)))))))
 but is expected to have type
-  forall {α : Type.{u1}} (c : CompleteDistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (HasSup.sup.{u1} α (inferInstance.{succ u1} (HasSup.{u1} α) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (HasInf.inf.{u1} α (inferInstance.{succ u1} (HasInf.{u1} α) (Lattice.toHasInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))) -> (CompleteDistribLattice.{u1} α)))))))
+  forall {α : Type.{u1}} (c : CompleteDistribLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))))) -> (forall (top : α), (Eq.{succ u1} α top (Top.top.{u1} α (inferInstance.{succ u1} (Top.{u1} α) (CompleteLattice.toTop.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))) -> (forall (bot : α), (Eq.{succ u1} α bot (Bot.bot.{u1} α (inferInstance.{succ u1} (Bot.{u1} α) (CompleteLattice.toBot.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c)))))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α (Order.Coframe.toCompleteLattice.{u1} α (CompleteDistribLattice.toCoframe.{u1} α c))))))) -> (CompleteDistribLattice.{u1} α)))))))
 Case conversion may be inaccurate. Consider using '#align complete_distrib_lattice.copy CompleteDistribLattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a complete distributive lattice
 with possibly different definitional equalities. -/
@@ -197,7 +197,7 @@ def CompleteDistribLattice.copy (c : CompleteDistribLattice α) (le : α → α
 lean 3 declaration is
   forall {α : Type.{u1}} (c : ConditionallyCompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (ConditionallyCompleteLattice.Le.{u1} α c)) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (ConditionallyCompleteLattice.sup.{u1} α c)) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (ConditionallyCompleteLattice.inf.{u1} α c)) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (ConditionallyCompleteLattice.sup.{u1} α c)) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (ConditionallyCompleteLattice.inf.{u1} α c)) -> (ConditionallyCompleteLattice.{u1} α)))))
 but is expected to have type
-  forall {α : Type.{u1}} (c : ConditionallyCompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c)))))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (HasSup.sup.{u1} α (inferInstance.{succ u1} (HasSup.{u1} α) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c)))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (HasInf.inf.{u1} α (inferInstance.{succ u1} (HasInf.{u1} α) (Lattice.toHasInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α c)))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α c)))) -> (ConditionallyCompleteLattice.{u1} α)))))
+  forall {α : Type.{u1}} (c : ConditionallyCompleteLattice.{u1} α) (le : α -> α -> Prop), (Eq.{succ u1} (α -> α -> Prop) le (LE.le.{u1} α (inferInstance.{succ u1} (LE.{u1} α) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c)))))))) -> (forall (sup : α -> α -> α), (Eq.{succ u1} (α -> α -> α) sup (Sup.sup.{u1} α (inferInstance.{succ u1} (Sup.{u1} α) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c)))))) -> (forall (inf : α -> α -> α), (Eq.{succ u1} (α -> α -> α) inf (Inf.inf.{u1} α (inferInstance.{succ u1} (Inf.{u1} α) (Lattice.toInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α c))))) -> (forall (Sup : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Sup (SupSet.supₛ.{u1} α (inferInstance.{succ u1} (SupSet.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} α c)))) -> (forall (Inf : (Set.{u1} α) -> α), (Eq.{succ u1} ((Set.{u1} α) -> α) Inf (InfSet.infₛ.{u1} α (inferInstance.{succ u1} (InfSet.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} α c)))) -> (ConditionallyCompleteLattice.{u1} α)))))
 Case conversion may be inaccurate. Consider using '#align conditionally_complete_lattice.copy ConditionallyCompleteLattice.copyₓ'. -/
 /-- A function to create a provable equal copy of a conditionally complete lattice
 with possibly different definitional equalities. -/

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

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -22,7 +22,7 @@ universe u
 
 variable {α : Type u}
 
---Porting note: mathlib3 proof uses `refine { top := top, bot := bot, .. }` but this does not work
+-- Porting note: mathlib3 proof uses `refine { top := top, bot := bot, .. }` but this does not work
 -- anymore
 /-- A function to create a provable equal copy of a bounded order
 with possibly different definitional equalities. -/
@@ -34,7 +34,7 @@ def BoundedOrder.copy {h : LE α} {h' : LE α} (c : @BoundedOrder α h')
     (@OrderBot.mk α h { bot := bot } (fun _ ↦ by simp [eq_bot, le_eq]))
 #align bounded_order.copy BoundedOrder.copy
 
---Porting note: original proof uses
+-- Porting note: original proof uses
 -- `all_goals { abstract { subst_vars, casesI c, simp_rw le_eq, assumption } }`
 /-- A function to create a provable equal copy of a lattice
 with possibly different definitional equalities. -/
@@ -55,7 +55,7 @@ def Lattice.copy (c : Lattice α)
   · intro _ _ _ hac hbc; simp_rw [eq_le] at hac hbc ⊢; simp [eq_inf, hac, hbc]
 #align lattice.copy Lattice.copy
 
---Porting note: original proof uses
+-- Porting note: original proof uses
 -- `all_goals { abstract { subst_vars, casesI c, simp_rw le_eq, assumption } }`
 /-- A function to create a provable equal copy of a distributive lattice
 with possibly different definitional equalities. -/
@@ -77,7 +77,7 @@ def DistribLattice.copy (c : DistribLattice α)
   · intros; simp [eq_le, eq_inf, eq_sup, le_sup_inf]
 #align distrib_lattice.copy DistribLattice.copy
 
---Porting note: original proof uses
+-- Porting note: original proof uses
 -- `all_goals { abstract { subst_vars, casesI c, simp_rw le_eq, assumption } }`
 /-- A function to create a provable equal copy of a complete lattice
 with possibly different definitional equalities. -/
@@ -100,7 +100,7 @@ def CompleteLattice.copy (c : CompleteLattice α)
   · intros; simp [eq_le, eq_bot]
 #align complete_lattice.copy CompleteLattice.copy
 
---Porting note: original proof uses
+-- Porting note: original proof uses
 -- `all_goals { abstract { subst_vars, casesI c, simp_rw le_eq, assumption } }`
 /-- A function to create a provable equal copy of a frame with possibly different definitional
 equalities. -/
@@ -117,7 +117,7 @@ def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = (by infer_
       simp [eq_le, eq_sup, eq_inf, eq_sSup, @Order.Frame.inf_sSup_le_iSup_inf α _ a s] }
 #align frame.copy Frame.copy
 
---Porting note: original proof uses
+-- Porting note: original proof uses
 -- `all_goals { abstract { subst_vars, casesI c, simp_rw le_eq, assumption } }`
 /-- A function to create a provable equal copy of a coframe with possibly different definitional
 equalities. -/
@@ -151,7 +151,7 @@ def CompleteDistribLattice.copy (c : CompleteDistribLattice α)
       inf eq_inf sSup eq_sSup sInf eq_sInf with }
 #align complete_distrib_lattice.copy CompleteDistribLattice.copy
 
---Porting note: original proof uses
+-- Porting note: original proof uses
 -- `all_goals { abstract { subst_vars, casesI c, simp_rw le_eq, assumption } }`
 /-- A function to create a provable equal copy of a conditionally complete lattice
 with possibly different definitional equalities. -/

• depends on: #5966

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

@@ -2,14 +2,11 @@
 Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module order.copy
-! leanprover-community/mathlib commit 207cfac9fcd06138865b5d04f7091e46d9320432
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.ConditionallyCompleteLattice.Basic
 
+#align_import order.copy from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
+
 /-!
 # Tooling to make copies of lattice structures
 

As discussed on Zulip

Renames

• supₛ → sSup
• infₛ → sInf
• supᵢ → iSup
• infᵢ → iInf
• bsupₛ → bsSup
• binfₛ → bsInf
• bsupᵢ → biSup
• binfᵢ → biInf
• csupₛ → csSup
• cinfₛ → csInf
• csupᵢ → ciSup
• cinfᵢ → ciInf
• unionₛ → sUnion
• interₛ → sInter
• unionᵢ → iUnion
• interᵢ → iInter
• bunionₛ → bsUnion
• binterₛ → bsInter
• bunionᵢ → biUnion
• binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -90,15 +90,15 @@ def CompleteLattice.copy (c : CompleteLattice α)
     (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
     (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
     (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf)
-    (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
-    (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) :
+    (sSup : Set α → α) (eq_sSup : sSup = (by infer_instance : SupSet α).sSup)
+    (sInf : Set α → α) (eq_sInf : sInf = (by infer_instance : InfSet α).sInf) :
     CompleteLattice α := by
   refine' { Lattice.copy (@CompleteLattice.toLattice α c) le eq_le sup eq_sup inf eq_inf with
-    le := le, top := top, bot := bot, sup := sup, inf := inf, supₛ := supₛ, infₛ := infₛ.. }
-  · intro _ _ h; simp [eq_le, eq_supₛ, le_supₛ _ _ h]
-  · intro _ _ h; simpa [eq_le, eq_supₛ] using h
-  · intro _ _ h; simp [eq_le, eq_infₛ, infₛ_le _ _ h]
-  · intro _ _ h; simpa [eq_le, eq_infₛ] using h
+    le := le, top := top, bot := bot, sup := sup, inf := inf, sSup := sSup, sInf := sInf.. }
+  · intro _ _ h; simp [eq_le, eq_sSup, le_sSup _ _ h]
+  · intro _ _ h; simpa [eq_le, eq_sSup] using h
+  · intro _ _ h; simp [eq_le, eq_sInf, sInf_le _ _ h]
+  · intro _ _ h; simpa [eq_le, eq_sInf] using h
   · intros; simp [eq_le, eq_top]
   · intros; simp [eq_le, eq_bot]
 #align complete_lattice.copy CompleteLattice.copy
@@ -112,12 +112,12 @@ def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = (by infer_
     (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
     (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
     (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf)
-    (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
-    (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) : Frame α :=
+    (sSup : Set α → α) (eq_sSup : sSup = (by infer_instance : SupSet α).sSup)
+    (sInf : Set α → α) (eq_sInf : sInf = (by infer_instance : InfSet α).sInf) : Frame α :=
   { CompleteLattice.copy (@Frame.toCompleteLattice α c) le eq_le top eq_top bot eq_bot
-      sup eq_sup inf eq_inf supₛ eq_supₛ infₛ eq_infₛ with
-    inf_supₛ_le_supᵢ_inf := fun a s => by
-      simp [eq_le, eq_sup, eq_inf, eq_supₛ, @Order.Frame.inf_supₛ_le_supᵢ_inf α _ a s] }
+      sup eq_sup inf eq_inf sSup eq_sSup sInf eq_sInf with
+    inf_sSup_le_iSup_inf := fun a s => by
+      simp [eq_le, eq_sup, eq_inf, eq_sSup, @Order.Frame.inf_sSup_le_iSup_inf α _ a s] }
 #align frame.copy Frame.copy
 
 --Porting note: original proof uses
@@ -129,12 +129,12 @@ def Coframe.copy (c : Coframe α) (le : α → α → Prop) (eq_le : le = (by in
     (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
     (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
     (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf)
-    (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
-    (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) : Coframe α :=
+    (sSup : Set α → α) (eq_sSup : sSup = (by infer_instance : SupSet α).sSup)
+    (sInf : Set α → α) (eq_sInf : sInf = (by infer_instance : InfSet α).sInf) : Coframe α :=
   { CompleteLattice.copy (@Coframe.toCompleteLattice α c) le eq_le top eq_top bot eq_bot sup
-        eq_sup inf eq_inf supₛ eq_supₛ infₛ eq_infₛ with
-    infᵢ_sup_le_sup_infₛ := fun a s => by
-      simp [eq_le, eq_sup, eq_inf, eq_infₛ, @Order.Coframe.infᵢ_sup_le_sup_infₛ α _ a s] }
+        eq_sup inf eq_inf sSup eq_sSup sInf eq_sInf with
+    iInf_sup_le_sup_sInf := fun a s => by
+      simp [eq_le, eq_sup, eq_inf, eq_sInf, @Order.Coframe.iInf_sup_le_sup_sInf α _ a s] }
 #align coframe.copy Coframe.copy
 
 /-- A function to create a provable equal copy of a complete distributive lattice
@@ -145,13 +145,13 @@ def CompleteDistribLattice.copy (c : CompleteDistribLattice α)
     (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
     (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
     (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf)
-    (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
-    (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) :
+    (sSup : Set α → α) (eq_sSup : sSup = (by infer_instance : SupSet α).sSup)
+    (sInf : Set α → α) (eq_sInf : sInf = (by infer_instance : InfSet α).sInf) :
     CompleteDistribLattice α :=
   { Frame.copy (@CompleteDistribLattice.toFrame α c) le eq_le top eq_top bot eq_bot sup eq_sup inf
-      eq_inf supₛ eq_supₛ infₛ eq_infₛ,
+      eq_inf sSup eq_sSup sInf eq_sInf,
     Coframe.copy (@CompleteDistribLattice.toCoframe α c) le eq_le top eq_top bot eq_bot sup eq_sup
-      inf eq_inf supₛ eq_supₛ infₛ eq_infₛ with }
+      inf eq_inf sSup eq_sSup sInf eq_sInf with }
 #align complete_distrib_lattice.copy CompleteDistribLattice.copy
 
 --Porting note: original proof uses
@@ -162,10 +162,10 @@ def ConditionallyCompleteLattice.copy (c : ConditionallyCompleteLattice α)
     (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
     (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
     (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf)
-    (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
-    (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) :
+    (sSup : Set α → α) (eq_sSup : sSup = (by infer_instance : SupSet α).sSup)
+    (sInf : Set α → α) (eq_sInf : sInf = (by infer_instance : InfSet α).sInf) :
     ConditionallyCompleteLattice α := by
-  refine' { le := le, sup := sup, inf := inf, supₛ := supₛ, infₛ := infₛ.. }
+  refine' { le := le, sup := sup, inf := inf, sSup := sSup, sInf := sInf.. }
   · intro a b; exact le a b ∧ ¬ le b a
   · intros; simp [eq_le]
   · intro _ _ _ hab hbc; rw [eq_le] at hab hbc ⊢; exact le_trans hab hbc
@@ -177,8 +177,8 @@ def ConditionallyCompleteLattice.copy (c : ConditionallyCompleteLattice α)
   · intros; simp [eq_le, eq_inf]
   · intros; simp [eq_le, eq_inf]
   · intro _ _ _ hac hbc; simp_rw [eq_le] at hac hbc ⊢; simp [eq_inf, hac, hbc]
-  · intro _ _ hb h; subst_vars; exact le_csupₛ _ _ hb h
-  · intro _ _ hb h; subst_vars; exact csupₛ_le _ _ hb h
-  · intro _ _ hb h; subst_vars; exact cinfₛ_le _ _ hb h
-  · intro _ _ hb h; subst_vars; exact le_cinfₛ _ _ hb h
+  · intro _ _ hb h; subst_vars; exact le_csSup _ _ hb h
+  · intro _ _ hb h; subst_vars; exact csSup_le _ _ hb h
+  · intro _ _ hb h; subst_vars; exact csInf_le _ _ hb h
+  · intro _ _ hb h; subst_vars; exact le_csInf _ _ hb h
 #align conditionally_complete_lattice.copy ConditionallyCompleteLattice.copy

This PR fixes two things:

• Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
• All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

@@ -78,7 +78,6 @@ def DistribLattice.copy (c : DistribLattice α)
   · intros; simp [eq_le, eq_inf]
   · intro _ _ _ hac hbc; simp_rw [eq_le] at hac hbc ⊢; simp [eq_inf, hac, hbc]
   · intros; simp [eq_le, eq_inf, eq_sup, le_sup_inf]
-
 #align distrib_lattice.copy DistribLattice.copy
 
 --Porting note: original proof uses
@@ -182,5 +181,4 @@ def ConditionallyCompleteLattice.copy (c : ConditionallyCompleteLattice α)
   · intro _ _ hb h; subst_vars; exact csupₛ_le _ _ hb h
   · intro _ _ hb h; subst_vars; exact cinfₛ_le _ _ hb h
   · intro _ _ hb h; subst_vars; exact le_cinfₛ _ _ hb h
-
 #align conditionally_complete_lattice.copy ConditionallyCompleteLattice.copy

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

@@ -43,8 +43,8 @@ def BoundedOrder.copy {h : LE α} {h' : LE α} (c : @BoundedOrder α h')
 with possibly different definitional equalities. -/
 def Lattice.copy (c : Lattice α)
     (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
-    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
-    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf) : Lattice α := by
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf) : Lattice α := by
   refine' { le := le, sup := sup, inf := inf, lt := fun a b ↦ le a b ∧ ¬ le b a.. }
   · intros; simp [eq_le]
   · intro _ _ _ hab hbc; rw [eq_le] at hab hbc ⊢; exact le_trans hab hbc
@@ -64,8 +64,8 @@ def Lattice.copy (c : Lattice α)
 with possibly different definitional equalities. -/
 def DistribLattice.copy (c : DistribLattice α)
     (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
-    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
-    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf) : DistribLattice α := by
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf) : DistribLattice α := by
   refine' { le := le, sup := sup, inf := inf, lt := fun a b ↦ le a b ∧ ¬ le b a.. }
   · intros; simp [eq_le]
   · intro _ _ _ hab hbc; rw [eq_le] at hab hbc ⊢; exact le_trans hab hbc
@@ -89,8 +89,8 @@ def CompleteLattice.copy (c : CompleteLattice α)
     (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
     (top : α) (eq_top : top = (by infer_instance : Top α).top)
     (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
-    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
-    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf)
     (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
     (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) :
     CompleteLattice α := by
@@ -111,8 +111,8 @@ equalities. -/
 def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
     (top : α) (eq_top : top = (by infer_instance : Top α).top)
     (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
-    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
-    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf)
     (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
     (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) : Frame α :=
   { CompleteLattice.copy (@Frame.toCompleteLattice α c) le eq_le top eq_top bot eq_bot
@@ -128,8 +128,8 @@ equalities. -/
 def Coframe.copy (c : Coframe α) (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
     (top : α) (eq_top : top = (by infer_instance : Top α).top)
     (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
-    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
-    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf)
     (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
     (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) : Coframe α :=
   { CompleteLattice.copy (@Coframe.toCompleteLattice α c) le eq_le top eq_top bot eq_bot sup
@@ -144,8 +144,8 @@ def CompleteDistribLattice.copy (c : CompleteDistribLattice α)
     (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
     (top : α) (eq_top : top = (by infer_instance : Top α).top)
     (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
-    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
-    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf)
     (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
     (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) :
     CompleteDistribLattice α :=
@@ -161,8 +161,8 @@ def CompleteDistribLattice.copy (c : CompleteDistribLattice α)
 with possibly different definitional equalities. -/
 def ConditionallyCompleteLattice.copy (c : ConditionallyCompleteLattice α)
     (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
-    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
-    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : Sup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : Inf α).inf)
     (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
     (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) :
     ConditionallyCompleteLattice α := by

@@ -29,9 +29,9 @@ variable {α : Type u}
 -- anymore
 /-- A function to create a provable equal copy of a bounded order
 with possibly different definitional equalities. -/
-def BoundedOrder.copy {h : LE α} {h' : LE α} (c : @BoundedOrder α h') (top : α)
-    (eq_top : top = (by infer_instance : Top α).top) (bot : α)
-    (eq_bot : bot = (by infer_instance : Bot α).bot)
+def BoundedOrder.copy {h : LE α} {h' : LE α} (c : @BoundedOrder α h')
+    (top : α) (eq_top : top = (by infer_instance : Top α).top)
+    (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
     (le_eq : ∀ x y : α, (@LE.le α h) x y ↔ x ≤ y) : @BoundedOrder α h :=
   @BoundedOrder.mk α h (@OrderTop.mk α h { top := top } (fun _ ↦ by simp [eq_top, le_eq]))
     (@OrderBot.mk α h { bot := bot } (fun _ ↦ by simp [eq_bot, le_eq]))
@@ -41,29 +41,30 @@ def BoundedOrder.copy {h : LE α} {h' : LE α} (c : @BoundedOrder α h') (top :
 -- `all_goals { abstract { subst_vars, casesI c, simp_rw le_eq, assumption } }`
 /-- A function to create a provable equal copy of a lattice
 with possibly different definitional equalities. -/
-def Lattice.copy (c : Lattice α) (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
-    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup) (inf : α → α → α)
-    (eq_inf : inf = (by infer_instance : HasInf α).inf) : Lattice α := by
-    refine' { le := le, sup := sup, inf := inf, lt := fun a b ↦ le a b ∧ ¬ le b a.. }
-    · intros; simp [eq_le]
-    · intro _ _ _ hab hbc; rw [eq_le] at hab hbc ⊢; exact le_trans hab hbc
-    · intros; simp [eq_le]
-    · intro _ _ hab hba; simp_rw [eq_le] at hab hba; exact le_antisymm hab hba
-    · intros; simp [eq_le, eq_sup]
-    · intros; simp [eq_le, eq_sup]
-    · intro _ _ _ hac hbc; simp_rw [eq_le] at hac hbc ⊢; simp [eq_sup, hac, hbc]
-    · intros; simp [eq_le, eq_inf]
-    · intros; simp [eq_le, eq_inf]
-    · intro _ _ _ hac hbc; simp_rw [eq_le] at hac hbc ⊢; simp [eq_inf, hac, hbc]
+def Lattice.copy (c : Lattice α)
+    (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf) : Lattice α := by
+  refine' { le := le, sup := sup, inf := inf, lt := fun a b ↦ le a b ∧ ¬ le b a.. }
+  · intros; simp [eq_le]
+  · intro _ _ _ hab hbc; rw [eq_le] at hab hbc ⊢; exact le_trans hab hbc
+  · intros; simp [eq_le]
+  · intro _ _ hab hba; simp_rw [eq_le] at hab hba; exact le_antisymm hab hba
+  · intros; simp [eq_le, eq_sup]
+  · intros; simp [eq_le, eq_sup]
+  · intro _ _ _ hac hbc; simp_rw [eq_le] at hac hbc ⊢; simp [eq_sup, hac, hbc]
+  · intros; simp [eq_le, eq_inf]
+  · intros; simp [eq_le, eq_inf]
+  · intro _ _ _ hac hbc; simp_rw [eq_le] at hac hbc ⊢; simp [eq_inf, hac, hbc]
 #align lattice.copy Lattice.copy
 
 --Porting note: original proof uses
 -- `all_goals { abstract { subst_vars, casesI c, simp_rw le_eq, assumption } }`
 /-- A function to create a provable equal copy of a distributive lattice
 with possibly different definitional equalities. -/
-def DistribLattice.copy (c : DistribLattice α) (le : α → α → Prop)
-    (eq_le : le = (by infer_instance : LE α).le) (sup : α → α → α)
-    (eq_sup : sup = (by infer_instance : HasSup α).sup)
+def DistribLattice.copy (c : DistribLattice α)
+    (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
     (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf) : DistribLattice α := by
   refine' { le := le, sup := sup, inf := inf, lt := fun a b ↦ le a b ∧ ¬ le b a.. }
   · intros; simp [eq_le]
@@ -84,22 +85,23 @@ def DistribLattice.copy (c : DistribLattice α) (le : α → α → Prop)
 -- `all_goals { abstract { subst_vars, casesI c, simp_rw le_eq, assumption } }`
 /-- A function to create a provable equal copy of a complete lattice
 with possibly different definitional equalities. -/
-def CompleteLattice.copy (c : CompleteLattice α) (le : α → α → Prop)
-    (eq_le : le = (by infer_instance : LE α).le) (top : α)
-    (eq_top : top = (by infer_instance : Top α).top) (bot : α)
-    (eq_bot : bot = (by infer_instance : Bot α).bot) (sup : α → α → α)
-    (eq_sup : sup = (by infer_instance : HasSup α).sup) (inf : α → α → α)
-    (eq_inf : inf = (by infer_instance : HasInf α).inf) (Sup : Set α → α)
-    (eq_Sup : Sup = (by infer_instance : SupSet α).supₛ) (Inf : Set α → α)
-    (eq_Inf : Inf = (by infer_instance : InfSet α).infₛ) : CompleteLattice α := by
-    refine' { Lattice.copy (@CompleteLattice.toLattice α c) le eq_le sup eq_sup inf eq_inf with
-      le := le, top := top, bot := bot, sup := sup, inf := inf, supₛ := Sup, infₛ := Inf.. }
-    · intro _ _ h; simp [eq_le, eq_Sup, le_supₛ _ _ h]
-    · intro _ _ h; simpa [eq_le, eq_Sup] using h
-    · intro _ _ h; simp [eq_le, eq_Inf, infₛ_le _ _ h]
-    · intro _ _ h; simpa [eq_le, eq_Inf] using h
-    · intros; simp [eq_le, eq_top]
-    · intros; simp [eq_le, eq_bot]
+def CompleteLattice.copy (c : CompleteLattice α)
+    (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
+    (top : α) (eq_top : top = (by infer_instance : Top α).top)
+    (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf)
+    (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
+    (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) :
+    CompleteLattice α := by
+  refine' { Lattice.copy (@CompleteLattice.toLattice α c) le eq_le sup eq_sup inf eq_inf with
+    le := le, top := top, bot := bot, sup := sup, inf := inf, supₛ := supₛ, infₛ := infₛ.. }
+  · intro _ _ h; simp [eq_le, eq_supₛ, le_supₛ _ _ h]
+  · intro _ _ h; simpa [eq_le, eq_supₛ] using h
+  · intro _ _ h; simp [eq_le, eq_infₛ, infₛ_le _ _ h]
+  · intro _ _ h; simpa [eq_le, eq_infₛ] using h
+  · intros; simp [eq_le, eq_top]
+  · intros; simp [eq_le, eq_bot]
 #align complete_lattice.copy CompleteLattice.copy
 
 --Porting note: original proof uses
@@ -107,16 +109,16 @@ def CompleteLattice.copy (c : CompleteLattice α) (le : α → α → Prop)
 /-- A function to create a provable equal copy of a frame with possibly different definitional
 equalities. -/
 def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
-    (top : α) (eq_top : top = (by infer_instance : Top α).top) (bot : α)
-    (eq_bot : bot = (by infer_instance : Bot α).bot) (sup : α → α → α)
-    (eq_sup : sup = (by infer_instance : HasSup α).sup) (inf : α → α → α)
-    (eq_inf : inf = (by infer_instance : HasInf α).inf) (Sup : Set α → α)
-    (eq_Sup : Sup = (by infer_instance : SupSet α).supₛ) (Inf : Set α → α)
-    (eq_Inf : Inf = (by infer_instance : InfSet α).infₛ) : Frame α :=
+    (top : α) (eq_top : top = (by infer_instance : Top α).top)
+    (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf)
+    (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
+    (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) : Frame α :=
   { CompleteLattice.copy (@Frame.toCompleteLattice α c) le eq_le top eq_top bot eq_bot
-      sup eq_sup inf eq_inf Sup eq_Sup Inf eq_Inf with
+      sup eq_sup inf eq_inf supₛ eq_supₛ infₛ eq_infₛ with
     inf_supₛ_le_supᵢ_inf := fun a s => by
-      simp [eq_le, eq_sup, eq_inf, eq_Sup, @Order.Frame.inf_supₛ_le_supᵢ_inf α _ a s] }
+      simp [eq_le, eq_sup, eq_inf, eq_supₛ, @Order.Frame.inf_supₛ_le_supᵢ_inf α _ a s] }
 #align frame.copy Frame.copy
 
 --Porting note: original proof uses
@@ -124,45 +126,47 @@ def Frame.copy (c : Frame α) (le : α → α → Prop) (eq_le : le = (by infer_
 /-- A function to create a provable equal copy of a coframe with possibly different definitional
 equalities. -/
 def Coframe.copy (c : Coframe α) (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
-    (top : α) (eq_top : top = (by infer_instance : Top α).top) (bot : α)
-    (eq_bot : bot = (by infer_instance : Bot α).bot) (sup : α → α → α)
-    (eq_sup : sup = (by infer_instance : HasSup α).sup) (inf : α → α → α)
-    (eq_inf : inf = (by infer_instance : HasInf α).inf) (Sup : Set α → α)
-    (eq_Sup : Sup = (by infer_instance : SupSet α).supₛ) (Inf : Set α → α)
-    (eq_Inf : Inf = (by infer_instance : InfSet α).infₛ) : Coframe α :=
+    (top : α) (eq_top : top = (by infer_instance : Top α).top)
+    (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf)
+    (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
+    (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) : Coframe α :=
   { CompleteLattice.copy (@Coframe.toCompleteLattice α c) le eq_le top eq_top bot eq_bot sup
-        eq_sup inf eq_inf Sup eq_Sup Inf eq_Inf with
+        eq_sup inf eq_inf supₛ eq_supₛ infₛ eq_infₛ with
     infᵢ_sup_le_sup_infₛ := fun a s => by
-      simp [eq_le, eq_sup, eq_inf, eq_Inf, @Order.Coframe.infᵢ_sup_le_sup_infₛ α _ a s] }
+      simp [eq_le, eq_sup, eq_inf, eq_infₛ, @Order.Coframe.infᵢ_sup_le_sup_infₛ α _ a s] }
 #align coframe.copy Coframe.copy
 
 /-- A function to create a provable equal copy of a complete distributive lattice
 with possibly different definitional equalities. -/
-def CompleteDistribLattice.copy (c : CompleteDistribLattice α) (le : α → α → Prop)
-    (eq_le : le = (by infer_instance : LE α).le) (top : α)
-    (eq_top : top = (by infer_instance : Top α).top) (bot : α)
-    (eq_bot : bot = (by infer_instance : Bot α).bot) (sup : α → α → α)
-    (eq_sup : sup = (by infer_instance : HasSup α).sup) (inf : α → α → α)
-    (eq_inf : inf = (by infer_instance : HasInf α).inf) (Sup : Set α → α)
-    (eq_Sup : Sup = (by infer_instance : SupSet α).supₛ) (Inf : Set α → α)
-    (eq_Inf : Inf = (by infer_instance : InfSet α).infₛ) : CompleteDistribLattice α :=
+def CompleteDistribLattice.copy (c : CompleteDistribLattice α)
+    (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
+    (top : α) (eq_top : top = (by infer_instance : Top α).top)
+    (bot : α) (eq_bot : bot = (by infer_instance : Bot α).bot)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf)
+    (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
+    (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) :
+    CompleteDistribLattice α :=
   { Frame.copy (@CompleteDistribLattice.toFrame α c) le eq_le top eq_top bot eq_bot sup eq_sup inf
-      eq_inf Sup eq_Sup Inf eq_Inf,
+      eq_inf supₛ eq_supₛ infₛ eq_infₛ,
     Coframe.copy (@CompleteDistribLattice.toCoframe α c) le eq_le top eq_top bot eq_bot sup eq_sup
-      inf eq_inf Sup eq_Sup Inf eq_Inf with }
+      inf eq_inf supₛ eq_supₛ infₛ eq_infₛ with }
 #align complete_distrib_lattice.copy CompleteDistribLattice.copy
 
 --Porting note: original proof uses
 -- `all_goals { abstract { subst_vars, casesI c, simp_rw le_eq, assumption } }`
 /-- A function to create a provable equal copy of a conditionally complete lattice
 with possibly different definitional equalities. -/
-def ConditionallyCompleteLattice.copy (c : ConditionallyCompleteLattice α) (le : α → α → Prop)
-    (eq_le : le = (by infer_instance : LE α).le) (sup : α → α → α)
-    (eq_sup : sup = (by infer_instance : HasSup α).sup) (inf : α → α → α)
-    (eq_inf : inf = (by infer_instance : HasInf α).inf) (Sup : Set α → α)
-    (eq_Sup : Sup = (by infer_instance : SupSet α).supₛ) (Inf : Set α → α)
-    (eq_Inf : Inf = (by infer_instance : InfSet α).infₛ) : ConditionallyCompleteLattice α := by
-  refine' { le := le, sup := sup, inf := inf, supₛ := Sup, infₛ := Inf.. }
+def ConditionallyCompleteLattice.copy (c : ConditionallyCompleteLattice α)
+    (le : α → α → Prop) (eq_le : le = (by infer_instance : LE α).le)
+    (sup : α → α → α) (eq_sup : sup = (by infer_instance : HasSup α).sup)
+    (inf : α → α → α) (eq_inf : inf = (by infer_instance : HasInf α).inf)
+    (supₛ : Set α → α) (eq_supₛ : supₛ = (by infer_instance : SupSet α).supₛ)
+    (infₛ : Set α → α) (eq_infₛ : infₛ = (by infer_instance : InfSet α).infₛ) :
+    ConditionallyCompleteLattice α := by
+  refine' { le := le, sup := sup, inf := inf, supₛ := supₛ, infₛ := infₛ.. }
   · intro a b; exact le a b ∧ ¬ le b a
   · intros; simp [eq_le]
   · intro _ _ _ hab hbc; rw [eq_le] at hab hbc ⊢; exact le_trans hab hbc