control.lawful_fix ⟷ Mathlib.Control.LawfulFix

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

@@ -85,7 +85,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
   · simp only [Part.fix_def f h₀]
     constructor <;> intro hh; exact ⟨_, hh⟩
     have h₁ := Nat.find_spec h₀
-    rw [dom_iff_mem] at h₁ 
+    rw [dom_iff_mem] at h₁
     cases' h₁ with y h₁
     replace h₁ := approx_mono' f _ _ h₁
     suffices : y = b; subst this; exact h₁
@@ -96,7 +96,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
     replace hh := approx_mono f case _ _ hh
     apply Part.mem_unique h₁ hh
   · simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]
-    simp only [dom_iff_mem, not_exists] at h₀ 
+    simp only [dom_iff_mem, not_exists] at h₀
     intro; apply h₀
 #align part.fix.mem_iff Part.Fix.mem_iff
 -/
@@ -116,9 +116,9 @@ theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
     have hb' := approx_le_fix f i _ _ hb
     obtain rfl := Part.mem_unique h' hb'
     exact hb
-  · simp only [not_exists] at hh ; exists 0
+  · simp only [not_exists] at hh; exists 0
     intro b' h'
-    simp only [mem_iff f] at h' 
+    simp only [mem_iff f] at h'
     cases' h' with i h'
     cases hh _ _ h'
 #align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approx

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

@@ -308,7 +308,7 @@ theorem uncurry_curry_continuous :
 
 end Curry
 
-#print Pi.Pi.lawfulFix' /-
+#print Pi.lawfulFix' /-
 instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (∀ x y, γ x y)
     where fix_eq f hc := by
     dsimp [fix]
@@ -316,7 +316,7 @@ instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (
       lhs
       erw [LawfulFix.fix_eq (uncurry_curry_continuous hc)]
     rfl
-#align pi.pi.lawful_fix' Pi.Pi.lawfulFix'
+#align pi.pi.lawful_fix' Pi.lawfulFix'
 -/
 
 end Pi

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

@@ -142,7 +142,7 @@ theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x :=
 
 #print Part.Fix.approx_mem_approxChain /-
 theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f :=
-  Stream'.mem_of_nth_eq rfl
+  Stream'.mem_of_get_eq rfl
 #align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChain
 -/
 

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

@@ -3,10 +3,10 @@ Copyright (c) 2020 Simon Hudon. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon
 -/
-import Mathbin.Data.Stream.Init
-import Mathbin.Tactic.Apply
-import Mathbin.Control.Fix
-import Mathbin.Order.OmegaCompletePartialOrder
+import Data.Stream.Init
+import Tactic.Apply
+import Control.Fix
+import Order.OmegaCompletePartialOrder
 
 #align_import control.lawful_fix from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
 

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

@@ -172,7 +172,7 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
     apply le_ωSup_of_le i.succ
     dsimp [approx]; rfl
   · apply ωSup_le _ _ _
-    simp only [fix.approx_chain, OrderHom.coe_fun_mk]
+    simp only [fix.approx_chain, OrderHom.coe_mk]
     intro y x; apply approx_le_fix f
 #align part.fix_eq_ωSup Part.fix_eq_ωSup
 -/
@@ -182,7 +182,7 @@ theorem fix_le {X : ∀ a, Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X :=
   by
   rw [fix_eq_ωSup f]
   apply ωSup_le _ _ _
-  simp only [fix.approx_chain, OrderHom.coe_fun_mk]
+  simp only [fix.approx_chain, OrderHom.coe_mk]
   intro i
   induction i; dsimp [fix.approx]; apply bot_le
   trans f X; apply f.monotone i_ih

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

@@ -2,17 +2,14 @@
 Copyright (c) 2020 Simon Hudon. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon
-
-! This file was ported from Lean 3 source module control.lawful_fix
-! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Stream.Init
 import Mathbin.Tactic.Apply
 import Mathbin.Control.Fix
 import Mathbin.Order.OmegaCompletePartialOrder
 
+#align_import control.lawful_fix from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
+
 /-!
 # Lawful fixed point operators
 

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

@@ -276,13 +276,13 @@ variable [∀ x y, OmegaCompletePartialOrder <| γ x y]
 open OmegaCompletePartialOrder.Chain
 
 #print Pi.continuous_curry /-
-theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c => by ext (x y);
+theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c => by ext x y;
   dsimp [curry, ωSup]; rw [map_comp, map_comp]; rfl
 #align pi.continuous_curry Pi.continuous_curry
 -/
 
 #print Pi.continuous_uncurry /-
-theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c => by ext (x y);
+theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c => by ext x y;
   dsimp [uncurry, ωSup]; rw [map_comp, map_comp]; rfl
 #align pi.continuous_uncurry Pi.continuous_uncurry
 -/

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

@@ -64,19 +64,24 @@ namespace Fix
 
 variable (f : (∀ a, Part <| β a) →o ∀ a, Part <| β a)
 
+#print Part.Fix.approx_mono' /-
 theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) :=
   by
   induction i; dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
   intro; apply f.monotone; apply i_ih
 #align part.fix.approx_mono' Part.Fix.approx_mono'
+-/
 
+#print Part.Fix.approx_mono /-
 theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j :=
   by
   induction' j with j ih; · cases hij; exact le_rfl
   cases hij; · exact le_rfl
   exact le_trans (ih ‹_›) (approx_mono' f)
 #align part.fix.approx_mono Part.Fix.approx_mono
+-/
 
+#print Part.Fix.mem_iff /-
 theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx f i a :=
   by
   by_cases h₀ : ∃ i : ℕ, (approx f i a).Dom
@@ -97,11 +102,15 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
     simp only [dom_iff_mem, not_exists] at h₀ 
     intro; apply h₀
 #align part.fix.mem_iff Part.Fix.mem_iff
+-/
 
+#print Part.Fix.approx_le_fix /-
 theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh => by rw [mem_iff f];
   exact ⟨_, hh⟩
 #align part.fix.approx_le_fix Part.Fix.approx_le_fix
+-/
 
+#print Part.Fix.exists_fix_le_approx /-
 theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
   by
   by_cases hh : ∃ i b, b ∈ approx f i x
@@ -116,24 +125,29 @@ theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
     cases' h' with i h'
     cases hh _ _ h'
 #align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approx
+-/
 
-include f
-
+#print Part.Fix.approxChain /-
 /-- The series of approximations of `fix f` (see `approx`) as a `chain` -/
 def approxChain : Chain (∀ a, Part <| β a) :=
   ⟨approx f, approx_mono f⟩
 #align part.fix.approx_chain Part.Fix.approxChain
+-/
 
+#print Part.Fix.le_f_of_mem_approx /-
 theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x :=
   by
   simp only [(· ∈ ·), forall_exists_index]
   rintro i rfl
   apply approx_mono'
 #align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approx
+-/
 
+#print Part.Fix.approx_mem_approxChain /-
 theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f :=
   Stream'.mem_of_nth_eq rfl
 #align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChain
+-/
 
 end Fix
 
@@ -151,6 +165,7 @@ open Nat
 
 open Nat.Upto OmegaCompletePartialOrder
 
+#print Part.fix_eq_ωSup /-
 theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
   by
   apply le_antisymm
@@ -163,7 +178,9 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
     simp only [fix.approx_chain, OrderHom.coe_fun_mk]
     intro y x; apply approx_le_fix f
 #align part.fix_eq_ωSup Part.fix_eq_ωSup
+-/
 
+#print Part.fix_le /-
 theorem fix_le {X : ∀ a, Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X :=
   by
   rw [fix_eq_ωSup f]
@@ -174,11 +191,11 @@ theorem fix_le {X : ∀ a, Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X :=
   trans f X; apply f.monotone i_ih
   apply hX
 #align part.fix_le Part.fix_le
+-/
 
 variable {f} (hc : Continuous f)
 
-include hc
-
+#print Part.fix_eq /-
 theorem fix_eq : Part.fix f = f (Part.fix f) :=
   by
   rw [fix_eq_ωSup f, hc]
@@ -190,11 +207,13 @@ theorem fix_eq : Part.fix f = f (Part.fix f) :=
   · apply ωSup_le_ωSup_of_le _
     intro i; exists i.succ; rfl
 #align part.fix_eq Part.fix_eq
+-/
 
 end Part
 
 namespace Part
 
+#print Part.toUnitMono /-
 /-- `to_unit` as a monotone function -/
 @[simps]
 def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α
@@ -202,13 +221,16 @@ def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Par
   toFun x u := f (x u)
   monotone' x y (h : x ≤ y) u := f.Monotone <| h u
 #align part.to_unit_mono Part.toUnitMono
+-/
 
+#print Part.to_unit_cont /-
 theorem to_unit_cont (f : Part α →o Part α) (hc : Continuous f) : Continuous (toUnitMono f)
   | c => by
     ext ⟨⟩ : 1
     dsimp [OmegaCompletePartialOrder.ωSup]
     erw [hc, chain.map_comp]; rfl
 #align part.to_unit_cont Part.to_unit_cont
+-/
 
 instance : LawfulFix (Part α) :=
   ⟨fun f hc => show Part.fix (toUnitMono f) () = _ by rw [Part.fix_eq (to_unit_cont f hc)] <;> rfl⟩
@@ -253,13 +275,17 @@ variable [∀ x y, OmegaCompletePartialOrder <| γ x y]
 
 open OmegaCompletePartialOrder.Chain
 
+#print Pi.continuous_curry /-
 theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c => by ext (x y);
   dsimp [curry, ωSup]; rw [map_comp, map_comp]; rfl
 #align pi.continuous_curry Pi.continuous_curry
+-/
 
+#print Pi.continuous_uncurry /-
 theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c => by ext (x y);
   dsimp [uncurry, ωSup]; rw [map_comp, map_comp]; rfl
 #align pi.continuous_uncurry Pi.continuous_uncurry
+-/
 
 end Monotone
 
@@ -276,10 +302,12 @@ variable {f : (∀ (x) (y : β x), γ x y) →o ∀ (x) (y : β x), γ x y}
 
 variable (hc : Continuous f)
 
+#print Pi.uncurry_curry_continuous /-
 theorem uncurry_curry_continuous :
     Continuous <| (monotoneUncurry α β γ).comp <| f.comp <| monotoneCurry α β γ :=
   continuous_comp _ _ (continuous_comp _ _ (continuous_curry _ _ _) hc) (continuous_uncurry _ _ _)
 #align pi.uncurry_curry_continuous Pi.uncurry_curry_continuous
+-/
 
 end Curry
 

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

@@ -67,7 +67,7 @@ variable (f : (∀ a, Part <| β a) →o ∀ a, Part <| β a)
 theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) :=
   by
   induction i; dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
-  intro ; apply f.monotone; apply i_ih
+  intro; apply f.monotone; apply i_ih
 #align part.fix.approx_mono' Part.Fix.approx_mono'
 
 theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j :=
@@ -83,19 +83,19 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
   · simp only [Part.fix_def f h₀]
     constructor <;> intro hh; exact ⟨_, hh⟩
     have h₁ := Nat.find_spec h₀
-    rw [dom_iff_mem] at h₁
+    rw [dom_iff_mem] at h₁ 
     cases' h₁ with y h₁
     replace h₁ := approx_mono' f _ _ h₁
     suffices : y = b; subst this; exact h₁
     cases' hh with i hh
     revert h₁; generalize succ (Nat.find h₀) = j; intro
     wlog case : i ≤ j
-    · cases' le_total i j with H H <;> [skip;symm] <;> apply_assumption <;> assumption
+    · cases' le_total i j with H H <;> [skip; symm] <;> apply_assumption <;> assumption
     replace hh := approx_mono f case _ _ hh
     apply Part.mem_unique h₁ hh
   · simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]
-    simp only [dom_iff_mem, not_exists] at h₀
-    intro ; apply h₀
+    simp only [dom_iff_mem, not_exists] at h₀ 
+    intro; apply h₀
 #align part.fix.mem_iff Part.Fix.mem_iff
 
 theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh => by rw [mem_iff f];
@@ -110,9 +110,9 @@ theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
     have hb' := approx_le_fix f i _ _ hb
     obtain rfl := Part.mem_unique h' hb'
     exact hb
-  · simp only [not_exists] at hh; exists 0
+  · simp only [not_exists] at hh ; exists 0
     intro b' h'
-    simp only [mem_iff f] at h'
+    simp only [mem_iff f] at h' 
     cases' h' with i h'
     cases hh _ _ h'
 #align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approx
@@ -231,7 +231,7 @@ variable (α β γ)
 #print Pi.monotoneCurry /-
 /-- `sigma.curry` as a monotone function. -/
 @[simps]
-def monotoneCurry [∀ x y, Preorder <| γ x y] : (∀ x : Σa, β a, γ x.1 x.2) →o ∀ (a) (b : β a), γ a b
+def monotoneCurry [∀ x y, Preorder <| γ x y] : (∀ x : Σ a, β a, γ x.1 x.2) →o ∀ (a) (b : β a), γ a b
     where
   toFun := curry
   monotone' x y h a b := h ⟨a, b⟩
@@ -242,7 +242,7 @@ def monotoneCurry [∀ x y, Preorder <| γ x y] : (∀ x : Σa, β a, γ x.1 x.2
 /-- `sigma.uncurry` as a monotone function. -/
 @[simps]
 def monotoneUncurry [∀ x y, Preorder <| γ x y] :
-    (∀ (a) (b : β a), γ a b) →o ∀ x : Σa, β a, γ x.1 x.2
+    (∀ (a) (b : β a), γ a b) →o ∀ x : Σ a, β a, γ x.1 x.2
     where
   toFun := uncurry
   monotone' x y h a := h a.1 a.2

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

@@ -31,7 +31,7 @@ omega complete partial orders (ωCPO). Proofs of the lawfulness of all `has_fix`
 
 universe u v
 
-open Classical
+open scoped Classical
 
 variable {α : Type _} {β : α → Type _}
 
@@ -283,6 +283,7 @@ theorem uncurry_curry_continuous :
 
 end Curry
 
+#print Pi.Pi.lawfulFix' /-
 instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (∀ x y, γ x y)
     where fix_eq f hc := by
     dsimp [fix]
@@ -291,6 +292,7 @@ instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (
       erw [LawfulFix.fix_eq (uncurry_curry_continuous hc)]
     rfl
 #align pi.pi.lawful_fix' Pi.Pi.lawfulFix'
+-/
 
 end Pi
 

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

@@ -64,24 +64,12 @@ namespace Fix
 
 variable (f : (∀ a, Part <| β a) →o ∀ a, Part <| β a)
 
-/- warning: part.fix.approx_mono' -> Part.Fix.approx_mono' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) (Nat.succ i))
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {i : Nat}, LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) (Nat.succ i))
-Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono' Part.Fix.approx_mono'ₓ'. -/
 theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) :=
   by
   induction i; dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
   intro ; apply f.monotone; apply i_ih
 #align part.fix.approx_mono' Part.Fix.approx_mono'
 
-/- warning: part.fix.approx_mono -> Part.Fix.approx_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat Nat.hasLe i j) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) j))
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat instLENat i j) -> (LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) j))
-Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono Part.Fix.approx_monoₓ'. -/
 theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j :=
   by
   induction' j with j ih; · cases hij; exact le_rfl
@@ -89,12 +77,6 @@ theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j
   exact le_trans (ih ‹_›) (approx_mono' f)
 #align part.fix.approx_mono Part.Fix.approx_mono
 
-/- warning: part.fix.mem_iff -> Part.Fix.mem_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (a : α) (b : β a), Iff (Membership.Mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.hasMem.{u2} (β a)) b (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) a)) (Exists.{1} Nat (fun (i : Nat) => Membership.Mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.hasMem.{u2} (β a)) b (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i a)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (a : α) (b : β a), Iff (Membership.mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.instMembershipPart.{u2} (β a)) b (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) a)) (Exists.{1} Nat (fun (i : Nat) => Membership.mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.instMembershipPart.{u2} (β a)) b (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) i a)))
-Case conversion may be inaccurate. Consider using '#align part.fix.mem_iff Part.Fix.mem_iffₓ'. -/
 theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx f i a :=
   by
   by_cases h₀ : ∃ i : ℕ, (approx f i a).Dom
@@ -116,22 +98,10 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
     intro ; apply h₀
 #align part.fix.mem_iff Part.Fix.mem_iff
 
-/- warning: part.fix.approx_le_fix -> Part.Fix.approx_le_fix is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (i : Nat), LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (i : Nat), LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))
-Case conversion may be inaccurate. Consider using '#align part.fix.approx_le_fix Part.Fix.approx_le_fixₓ'. -/
 theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh => by rw [mem_iff f];
   exact ⟨_, hh⟩
 #align part.fix.approx_le_fix Part.Fix.approx_le_fix
 
-/- warning: part.fix.exists_fix_le_approx -> Part.Fix.exists_fix_le_approx is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toHasLe.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.partialOrder.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) x) (Part.Fix.approx.{u1, u2} α β (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toLE.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.instPartialOrderPart.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) x) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) i x))
-Case conversion may be inaccurate. Consider using '#align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approxₓ'. -/
 theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
   by
   by_cases hh : ∃ i b, b ∈ approx f i x
@@ -149,23 +119,11 @@ theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
 
 include f
 
-/- warning: part.fix.approx_chain -> Part.Fix.approxChain is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}}, (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) -> (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : α -> Type.{u2}}, (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) -> (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))))
-Case conversion may be inaccurate. Consider using '#align part.fix.approx_chain Part.Fix.approxChainₓ'. -/
 /-- The series of approximations of `fix f` (see `approx`) as a `chain` -/
 def approxChain : Chain (∀ a, Part <| β a) :=
   ⟨approx f, approx_mono f⟩
 #align part.fix.approx_chain Part.Fix.approxChain
 
-/- warning: part.fix.le_f_of_mem_approx -> Part.Fix.le_f_of_mem_approx is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.mem.{max u1 u2, max u2 u1} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.instMembershipChain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f x))
-Case conversion may be inaccurate. Consider using '#align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approxₓ'. -/
 theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x :=
   by
   simp only [(· ∈ ·), forall_exists_index]
@@ -173,12 +131,6 @@ theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x :=
   apply approx_mono'
 #align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approx
 
-/- warning: part.fix.approx_mem_approx_chain -> Part.Fix.approx_mem_approxChain is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {i : Nat}, Membership.mem.{max u2 u1, max u1 u2} (forall (a : α), Part.{u1} (β a)) (OmegaCompletePartialOrder.Chain.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (OmegaCompletePartialOrder.Chain.instMembershipChain.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approxChain.{u2, u1} α (fun (a : α) => β a) f)
-Case conversion may be inaccurate. Consider using '#align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChainₓ'. -/
 theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f :=
   Stream'.mem_of_nth_eq rfl
 #align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChain
@@ -199,12 +151,6 @@ open Nat
 
 open Nat.Upto OmegaCompletePartialOrder
 
-/- warning: part.fix_eq_ωSup -> Part.fix_eq_ωSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))), Eq.{max (succ u1) (succ u2)} (forall (x : α), Part.{u2} (β x)) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) (OmegaCompletePartialOrder.ωSup.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (x : α) => Part.{u2} (β x)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) (Part.Fix.approxChain.{u1, u2} α (fun (x : α) => β x) f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))), Eq.{max (succ u2) (succ u1)} (forall (x : α), Part.{u1} (β x)) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f)) (OmegaCompletePartialOrder.ωSup.{max u1 u2} (forall (x : α), Part.{u1} (β x)) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (x : α) => Part.{u1} (β x)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) (Part.Fix.approxChain.{u2, u1} α (fun (x : α) => β x) f))
-Case conversion may be inaccurate. Consider using '#align part.fix_eq_ωSup Part.fix_eq_ωSupₓ'. -/
 theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
   by
   apply le_antisymm
@@ -218,12 +164,6 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
     intro y x; apply approx_le_fix f
 #align part.fix_eq_ωSup Part.fix_eq_ωSup
 
-/- warning: part.fix_le -> Part.fix_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) X)
-but is expected to have type
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f)) X)
-Case conversion may be inaccurate. Consider using '#align part.fix_le Part.fix_leₓ'. -/
 theorem fix_le {X : ∀ a, Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X :=
   by
   rw [fix_eq_ωSup f]
@@ -239,12 +179,6 @@ variable {f} (hc : Continuous f)
 
 include hc
 
-/- warning: part.fix_eq -> Part.fix_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} {f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))}, (OmegaCompletePartialOrder.Continuous.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) f) -> (Eq.{max (succ u1) (succ u2)} (forall (x : α), Part.{u2} (β x)) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}} {f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))}, (OmegaCompletePartialOrder.Continuous.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) f) -> (Eq.{max (succ u2) (succ u1)} (forall (x : α), Part.{u1} (β x)) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f)) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))))
-Case conversion may be inaccurate. Consider using '#align part.fix_eq Part.fix_eqₓ'. -/
 theorem fix_eq : Part.fix f = f (Part.fix f) :=
   by
   rw [fix_eq_ωSup f, hc]
@@ -261,12 +195,6 @@ end Part
 
 namespace Part
 
-/- warning: part.to_unit_mono -> Part.toUnitMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, (OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))) -> (OrderHom.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}}, (OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))) -> (OrderHom.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align part.to_unit_mono Part.toUnitMonoₓ'. -/
 /-- `to_unit` as a monotone function -/
 @[simps]
 def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α
@@ -275,12 +203,6 @@ def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Par
   monotone' x y (h : x ≤ y) u := f.Monotone <| h u
 #align part.to_unit_mono Part.toUnitMono
 
-/- warning: part.to_unit_cont -> Part.to_unit_cont is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (f : OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))), (OmegaCompletePartialOrder.Continuous.{u1, u1} (Part.{u1} α) (Part.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) f) -> (OmegaCompletePartialOrder.Continuous.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.omegaCompletePartialOrder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Pi.omegaCompletePartialOrder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Part.toUnitMono.{u1} α f))
-but is expected to have type
-  forall {α : Type.{u1}} (f : OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))), (OmegaCompletePartialOrder.Continuous.{u1, u1} (Part.{u1} α) (Part.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) f) -> (OmegaCompletePartialOrder.Continuous.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.instOmegaCompletePartialOrderForAll.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Pi.instOmegaCompletePartialOrderForAll.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Part.toUnitMono.{u1} α f))
-Case conversion may be inaccurate. Consider using '#align part.to_unit_cont Part.to_unit_contₓ'. -/
 theorem to_unit_cont (f : Part α →o Part α) (hc : Continuous f) : Continuous (toUnitMono f)
   | c => by
     ext ⟨⟩ : 1
@@ -331,22 +253,10 @@ variable [∀ x y, OmegaCompletePartialOrder <| γ x y]
 
 open OmegaCompletePartialOrder.Chain
 
-/- warning: pi.continuous_curry -> Pi.continuous_curry is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u3}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u1 u2) u3, max u1 u2 u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.monotoneCurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))))
-but is expected to have type
-  forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.monotoneCurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
-Case conversion may be inaccurate. Consider using '#align pi.continuous_curry Pi.continuous_curryₓ'. -/
 theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c => by ext (x y);
   dsimp [curry, ωSup]; rw [map_comp, map_comp]; rfl
 #align pi.continuous_curry Pi.continuous_curry
 
-/- warning: pi.continuous_uncurry -> Pi.continuous_uncurry is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u3}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)], OmegaCompletePartialOrder.Continuous.{max u1 u2 u3, max (max u1 u2) u3} (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.monotoneUncurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))))
-but is expected to have type
-  forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.monotoneUncurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
-Case conversion may be inaccurate. Consider using '#align pi.continuous_uncurry Pi.continuous_uncurryₓ'. -/
 theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c => by ext (x y);
   dsimp [uncurry, ωSup]; rw [map_comp, map_comp]; rfl
 #align pi.continuous_uncurry Pi.continuous_uncurry
@@ -366,9 +276,6 @@ variable {f : (∀ (x) (y : β x), γ x y) →o ∀ (x) (y : β x), γ x y}
 
 variable (hc : Continuous f)
 
-/- warning: pi.uncurry_curry_continuous -> Pi.uncurry_curry_continuous is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align pi.uncurry_curry_continuous Pi.uncurry_curry_continuousₓ'. -/
 theorem uncurry_curry_continuous :
     Continuous <| (monotoneUncurry α β γ).comp <| f.comp <| monotoneCurry α β γ :=
   continuous_comp _ _ (continuous_comp _ _ (continuous_curry _ _ _) hc) (continuous_uncurry _ _ _)
@@ -376,12 +283,6 @@ theorem uncurry_curry_continuous :
 
 end Curry
 
-/- warning: pi.pi.lawful_fix' -> Pi.Pi.lawfulFix' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] [_inst_2 : LawfulFix.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α β), γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α β) (fun (x : Sigma.{u1, u2} α β) => γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (fun (a : Sigma.{u1, u2} α β) => _inst_1 (Sigma.fst.{u1, u2} α β a) (Sigma.snd.{u1, u2} α β a)))], LawfulFix.{max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] [_inst_2 : LawfulFix.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α β), γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (Pi.instOmegaCompletePartialOrderForAll.{max u1 u2, u3} (Sigma.{u1, u2} α β) (fun (x : Sigma.{u1, u2} α β) => γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (fun (a : Sigma.{u1, u2} α β) => _inst_1 (Sigma.fst.{u1, u2} α β a) (Sigma.snd.{u1, u2} α β a)))], LawfulFix.{max (max u1 u2) u3} (forall (x : α) (y : β x), γ x y) (Pi.instOmegaCompletePartialOrderForAll.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1)))
-Case conversion may be inaccurate. Consider using '#align pi.pi.lawful_fix' Pi.Pi.lawfulFix'ₓ'. -/
 instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (∀ x y, γ x y)
     where fix_eq f hc := by
     dsimp [fix]

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

@@ -84,9 +84,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono Part.Fix.approx_monoₓ'. -/
 theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j :=
   by
-  induction' j with j ih;
-  · cases hij
-    exact le_rfl
+  induction' j with j ih; · cases hij; exact le_rfl
   cases hij; · exact le_rfl
   exact le_trans (ih ‹_›) (approx_mono' f)
 #align part.fix.approx_mono Part.Fix.approx_mono
@@ -101,27 +99,21 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
   by
   by_cases h₀ : ∃ i : ℕ, (approx f i a).Dom
   · simp only [Part.fix_def f h₀]
-    constructor <;> intro hh
-    exact ⟨_, hh⟩
+    constructor <;> intro hh; exact ⟨_, hh⟩
     have h₁ := Nat.find_spec h₀
     rw [dom_iff_mem] at h₁
     cases' h₁ with y h₁
     replace h₁ := approx_mono' f _ _ h₁
-    suffices : y = b
-    subst this
-    exact h₁
+    suffices : y = b; subst this; exact h₁
     cases' hh with i hh
-    revert h₁
-    generalize succ (Nat.find h₀) = j
-    intro
+    revert h₁; generalize succ (Nat.find h₀) = j; intro
     wlog case : i ≤ j
     · cases' le_total i j with H H <;> [skip;symm] <;> apply_assumption <;> assumption
     replace hh := approx_mono f case _ _ hh
     apply Part.mem_unique h₁ hh
   · simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]
     simp only [dom_iff_mem, not_exists] at h₀
-    intro
-    apply h₀
+    intro ; apply h₀
 #align part.fix.mem_iff Part.Fix.mem_iff
 
 /- warning: part.fix.approx_le_fix -> Part.Fix.approx_le_fix is a dubious translation:
@@ -130,9 +122,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (i : Nat), LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))
 Case conversion may be inaccurate. Consider using '#align part.fix.approx_le_fix Part.Fix.approx_le_fixₓ'. -/
-theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh =>
-  by
-  rw [mem_iff f]
+theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh => by rw [mem_iff f];
   exact ⟨_, hh⟩
 #align part.fix.approx_le_fix Part.Fix.approx_le_fix
 
@@ -145,14 +135,12 @@ Case conversion may be inaccurate. Consider using '#align part.fix.exists_fix_le
 theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
   by
   by_cases hh : ∃ i b, b ∈ approx f i x
-  · rcases hh with ⟨i, b, hb⟩
-    exists i
+  · rcases hh with ⟨i, b, hb⟩; exists i
     intro b' h'
     have hb' := approx_le_fix f i _ _ hb
     obtain rfl := Part.mem_unique h' hb'
     exact hb
-  · simp only [not_exists] at hh
-    exists 0
+  · simp only [not_exists] at hh; exists 0
     intro b' h'
     simp only [mem_iff f] at h'
     cases' h' with i h'
@@ -220,19 +208,14 @@ Case conversion may be inaccurate. Consider using '#align part.fix_eq_ωSup Part
 theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
   by
   apply le_antisymm
-  · intro x
-    cases' exists_fix_le_approx f x with i hx
+  · intro x; cases' exists_fix_le_approx f x with i hx
     trans approx f i.succ x
-    · trans
-      apply hx
-      apply approx_mono' f
+    · trans; apply hx; apply approx_mono' f
     apply le_ωSup_of_le i.succ
-    dsimp [approx]
-    rfl
+    dsimp [approx]; rfl
   · apply ωSup_le _ _ _
     simp only [fix.approx_chain, OrderHom.coe_fun_mk]
-    intro y x
-    apply approx_le_fix f
+    intro y x; apply approx_le_fix f
 #align part.fix_eq_ωSup Part.fix_eq_ωSup
 
 /- warning: part.fix_le -> Part.fix_le is a dubious translation:
@@ -267,15 +250,11 @@ theorem fix_eq : Part.fix f = f (Part.fix f) :=
   rw [fix_eq_ωSup f, hc]
   apply le_antisymm
   · apply ωSup_le_ωSup_of_le _
-    intro i
-    exists i
-    intro x
+    intro i; exists i; intro x
     -- intros x y hx,
     apply le_f_of_mem_approx _ ⟨i, rfl⟩
   · apply ωSup_le_ωSup_of_le _
-    intro i
-    exists i.succ
-    rfl
+    intro i; exists i.succ; rfl
 #align part.fix_eq Part.fix_eq
 
 end Part
@@ -358,12 +337,8 @@ lean 3 declaration is
 but is expected to have type
   forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.monotoneCurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
 Case conversion may be inaccurate. Consider using '#align pi.continuous_curry Pi.continuous_curryₓ'. -/
-theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c =>
-  by
-  ext (x y)
-  dsimp [curry, ωSup]
-  rw [map_comp, map_comp]
-  rfl
+theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c => by ext (x y);
+  dsimp [curry, ωSup]; rw [map_comp, map_comp]; rfl
 #align pi.continuous_curry Pi.continuous_curry
 
 /- warning: pi.continuous_uncurry -> Pi.continuous_uncurry is a dubious translation:
@@ -372,12 +347,8 @@ lean 3 declaration is
 but is expected to have type
   forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.monotoneUncurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
 Case conversion may be inaccurate. Consider using '#align pi.continuous_uncurry Pi.continuous_uncurryₓ'. -/
-theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c =>
-  by
-  ext (x y)
-  dsimp [uncurry, ωSup]
-  rw [map_comp, map_comp]
-  rfl
+theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c => by ext (x y);
+  dsimp [uncurry, ωSup]; rw [map_comp, map_comp]; rfl
 #align pi.continuous_uncurry Pi.continuous_uncurry
 
 end Monotone

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

@@ -396,10 +396,7 @@ variable {f : (∀ (x) (y : β x), γ x y) →o ∀ (x) (y : β x), γ x y}
 variable (hc : Continuous f)
 
 /- warning: pi.uncurry_curry_continuous -> Pi.uncurry_curry_continuous is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] {f : OrderHom.{max u1 u2 u3, max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1)))))}, (OmegaCompletePartialOrder.Continuous.{max u1 u2 u3, max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) f) -> (OmegaCompletePartialOrder.Continuous.{max (max u1 u2) u3, max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (OrderHom.comp.{max (max u1 u2) u3, max u1 u2 u3, max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (PartialOrder.toPreorder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (b : β i) => γ i b) (fun (i_1 : β i) => (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))) i i_1))) (Pi.preorder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (i : Sigma.{u1, u2} α (fun (a : α) => β a)) => (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))) (Sigma.fst.{u1, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) i))) (Pi.monotoneUncurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y)))) (OrderHom.comp.{max (max u1 u2) u3, max u1 u2 u3, max u1 u2 u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (PartialOrder.toPreorder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) f (Pi.monotoneCurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y)))))))
-but is expected to have type
-  forall {α : Type.{u3}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u1}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)] {f : OrderHom.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1)))))}, (OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) f) -> (OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (OrderHom.comp.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (PartialOrder.toPreorder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (b : β i) => γ i b) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (i : Sigma.{u3, u2} α (fun (a : α) => β a)) => PartialOrder.toPreorder.{u1} (γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i)) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i)) (_inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i))))) (Pi.monotoneUncurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y)))) (OrderHom.comp.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (PartialOrder.toPreorder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) f (Pi.monotoneCurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y)))))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align pi.uncurry_curry_continuous Pi.uncurry_curry_continuousₓ'. -/
 theorem uncurry_curry_continuous :
     Continuous <| (monotoneUncurry α β γ).comp <| f.comp <| monotoneCurry α β γ :=

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

@@ -115,7 +115,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
     generalize succ (Nat.find h₀) = j
     intro
     wlog case : i ≤ j
-    · cases' le_total i j with H H <;> [skip, symm] <;> apply_assumption <;> assumption
+    · cases' le_total i j with H H <;> [skip;symm] <;> apply_assumption <;> assumption
     replace hh := approx_mono f case _ _ hh
     apply Part.mem_unique h₁ hh
   · simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]

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

@@ -66,7 +66,7 @@ variable (f : (∀ a, Part <| β a) →o ∀ a, Part <| β a)
 
 /- warning: part.fix.approx_mono' -> Part.Fix.approx_mono' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) (Nat.succ i))
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) (Nat.succ i))
 but is expected to have type
   forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {i : Nat}, LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) (Nat.succ i))
 Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono' Part.Fix.approx_mono'ₓ'. -/
@@ -78,7 +78,7 @@ theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) :=
 
 /- warning: part.fix.approx_mono -> Part.Fix.approx_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat Nat.hasLe i j) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) j))
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat Nat.hasLe i j) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) j))
 but is expected to have type
   forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat instLENat i j) -> (LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) j))
 Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono Part.Fix.approx_monoₓ'. -/
@@ -126,7 +126,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
 
 /- warning: part.fix.approx_le_fix -> Part.Fix.approx_le_fix is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (i : Nat), LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (i : Nat), LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))
 but is expected to have type
   forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (i : Nat), LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))
 Case conversion may be inaccurate. Consider using '#align part.fix.approx_le_fix Part.Fix.approx_le_fixₓ'. -/
@@ -138,7 +138,7 @@ theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh =>
 
 /- warning: part.fix.exists_fix_le_approx -> Part.Fix.exists_fix_le_approx is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toLE.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.partialOrder.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) x) (Part.Fix.approx.{u1, u2} α β (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i x))
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toHasLe.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.partialOrder.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) x) (Part.Fix.approx.{u1, u2} α β (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i x))
 but is expected to have type
   forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toLE.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.instPartialOrderPart.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) x) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) i x))
 Case conversion may be inaccurate. Consider using '#align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approxₓ'. -/
@@ -174,7 +174,7 @@ def approxChain : Chain (∀ a, Part <| β a) :=
 
 /- warning: part.fix.le_f_of_mem_approx -> Part.Fix.le_f_of_mem_approx is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f x))
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f x))
 but is expected to have type
   forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.mem.{max u1 u2, max u2 u1} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.instMembershipChain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f x))
 Case conversion may be inaccurate. Consider using '#align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approxₓ'. -/
@@ -237,7 +237,7 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
 
 /- warning: part.fix_le -> Part.fix_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) X)
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) X)
 but is expected to have type
   forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f)) X)
 Case conversion may be inaccurate. Consider using '#align part.fix_le Part.fix_leₓ'. -/
@@ -408,7 +408,12 @@ theorem uncurry_curry_continuous :
 
 end Curry
 
-#print Pi.Pi.lawfulFix' /-
+/- warning: pi.pi.lawful_fix' -> Pi.Pi.lawfulFix' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] [_inst_2 : LawfulFix.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α β), γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α β) (fun (x : Sigma.{u1, u2} α β) => γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (fun (a : Sigma.{u1, u2} α β) => _inst_1 (Sigma.fst.{u1, u2} α β a) (Sigma.snd.{u1, u2} α β a)))], LawfulFix.{max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] [_inst_2 : LawfulFix.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α β), γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (Pi.instOmegaCompletePartialOrderForAll.{max u1 u2, u3} (Sigma.{u1, u2} α β) (fun (x : Sigma.{u1, u2} α β) => γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (fun (a : Sigma.{u1, u2} α β) => _inst_1 (Sigma.fst.{u1, u2} α β a) (Sigma.snd.{u1, u2} α β a)))], LawfulFix.{max (max u1 u2) u3} (forall (x : α) (y : β x), γ x y) (Pi.instOmegaCompletePartialOrderForAll.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1)))
+Case conversion may be inaccurate. Consider using '#align pi.pi.lawful_fix' Pi.Pi.lawfulFix'ₓ'. -/
 instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (∀ x y, γ x y)
     where fix_eq f hc := by
     dsimp [fix]
@@ -417,7 +422,6 @@ instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (
       erw [LawfulFix.fix_eq (uncurry_curry_continuous hc)]
     rfl
 #align pi.pi.lawful_fix' Pi.Pi.lawfulFix'
--/
 
 end Pi
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/21e3562c5e12d846c7def5eff8cdbc520d7d4936

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon
 
 ! This file was ported from Lean 3 source module control.lawful_fix
-! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
+! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.Order.OmegaCompletePartialOrder
 /-!
 # Lawful fixed point operators
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This module defines the laws required of a `has_fix` instance, using the theory of
 omega complete partial orders (ωCPO). Proofs of the lawfulness of all `has_fix` instances in
 `control.fix` are provided.

mathlib commit https://github.com/leanprover-community/mathlib/commit/195fcd60ff2bfe392543bceb0ec2adcdb472db4c

@@ -34,6 +34,7 @@ variable {α : Type _} {β : α → Type _}
 
 open OmegaCompletePartialOrder
 
+#print LawfulFix /-
 /-- Intuitively, a fixed point operator `fix` is lawful if it satisfies `fix f = f (fix f)` for all
 `f`, but this is inconsistent / uninteresting in most cases due to the existence of "exotic"
 functions `f`, such as the function that is defined iff its argument is not, familiar from the
@@ -43,11 +44,14 @@ sense of `ω`-complete partial orders, which excludes the example because it is
 class LawfulFix (α : Type _) [OmegaCompletePartialOrder α] extends Fix α where
   fix_eq : ∀ {f : α →o α}, Continuous f → Fix.fix f = f (Fix.fix f)
 #align lawful_fix LawfulFix
+-/
 
+#print LawfulFix.fix_eq' /-
 theorem LawfulFix.fix_eq' {α} [OmegaCompletePartialOrder α] [LawfulFix α] {f : α → α}
     (hf : Continuous' f) : Fix.fix f = f (Fix.fix f) :=
   LawfulFix.fix_eq (hf.to_bundled _)
 #align lawful_fix.fix_eq' LawfulFix.fix_eq'
+-/
 
 namespace Part
 
@@ -57,12 +61,24 @@ namespace Fix
 
 variable (f : (∀ a, Part <| β a) →o ∀ a, Part <| β a)
 
+/- warning: part.fix.approx_mono' -> Part.Fix.approx_mono' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) (Nat.succ i))
+but is expected to have type
+  forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {i : Nat}, LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) (Nat.succ i))
+Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono' Part.Fix.approx_mono'ₓ'. -/
 theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) :=
   by
   induction i; dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
   intro ; apply f.monotone; apply i_ih
-#align part.fix.approx_mono' Part.fix.approx_mono'
-
+#align part.fix.approx_mono' Part.Fix.approx_mono'
+
+/- warning: part.fix.approx_mono -> Part.Fix.approx_mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat Nat.hasLe i j) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) j))
+but is expected to have type
+  forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat instLENat i j) -> (LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) j))
+Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono Part.Fix.approx_monoₓ'. -/
 theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j :=
   by
   induction' j with j ih;
@@ -70,8 +86,14 @@ theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j
     exact le_rfl
   cases hij; · exact le_rfl
   exact le_trans (ih ‹_›) (approx_mono' f)
-#align part.fix.approx_mono Part.fix.approx_mono
-
+#align part.fix.approx_mono Part.Fix.approx_mono
+
+/- warning: part.fix.mem_iff -> Part.Fix.mem_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (a : α) (b : β a), Iff (Membership.Mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.hasMem.{u2} (β a)) b (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) a)) (Exists.{1} Nat (fun (i : Nat) => Membership.Mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.hasMem.{u2} (β a)) b (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i a)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (a : α) (b : β a), Iff (Membership.mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.instMembershipPart.{u2} (β a)) b (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) a)) (Exists.{1} Nat (fun (i : Nat) => Membership.mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.instMembershipPart.{u2} (β a)) b (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) i a)))
+Case conversion may be inaccurate. Consider using '#align part.fix.mem_iff Part.Fix.mem_iffₓ'. -/
 theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx f i a :=
   by
   by_cases h₀ : ∃ i : ℕ, (approx f i a).Dom
@@ -97,14 +119,26 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
     simp only [dom_iff_mem, not_exists] at h₀
     intro
     apply h₀
-#align part.fix.mem_iff Part.fix.mem_iff
-
+#align part.fix.mem_iff Part.Fix.mem_iff
+
+/- warning: part.fix.approx_le_fix -> Part.Fix.approx_le_fix is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (i : Nat), LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))
+but is expected to have type
+  forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (i : Nat), LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))
+Case conversion may be inaccurate. Consider using '#align part.fix.approx_le_fix Part.Fix.approx_le_fixₓ'. -/
 theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh =>
   by
   rw [mem_iff f]
   exact ⟨_, hh⟩
-#align part.fix.approx_le_fix Part.fix.approx_le_fix
-
+#align part.fix.approx_le_fix Part.Fix.approx_le_fix
+
+/- warning: part.fix.exists_fix_le_approx -> Part.Fix.exists_fix_le_approx is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toLE.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.partialOrder.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) x) (Part.Fix.approx.{u1, u2} α β (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toLE.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.instPartialOrderPart.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) x) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) i x))
+Case conversion may be inaccurate. Consider using '#align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approxₓ'. -/
 theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
   by
   by_cases hh : ∃ i b, b ∈ approx f i x
@@ -120,25 +154,43 @@ theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
     simp only [mem_iff f] at h'
     cases' h' with i h'
     cases hh _ _ h'
-#align part.fix.exists_fix_le_approx Part.fix.exists_fix_le_approx
+#align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approx
 
 include f
 
+/- warning: part.fix.approx_chain -> Part.Fix.approxChain is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}}, (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) -> (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : α -> Type.{u2}}, (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) -> (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))))
+Case conversion may be inaccurate. Consider using '#align part.fix.approx_chain Part.Fix.approxChainₓ'. -/
 /-- The series of approximations of `fix f` (see `approx`) as a `chain` -/
 def approxChain : Chain (∀ a, Part <| β a) :=
   ⟨approx f, approx_mono f⟩
-#align part.fix.approx_chain Part.fix.approxChain
-
+#align part.fix.approx_chain Part.Fix.approxChain
+
+/- warning: part.fix.le_f_of_mem_approx -> Part.Fix.le_f_of_mem_approx is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.mem.{max u1 u2, max u2 u1} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.instMembershipChain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f x))
+Case conversion may be inaccurate. Consider using '#align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approxₓ'. -/
 theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x :=
   by
   simp only [(· ∈ ·), forall_exists_index]
   rintro i rfl
   apply approx_mono'
-#align part.fix.le_f_of_mem_approx Part.fix.le_f_of_mem_approx
-
+#align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approx
+
+/- warning: part.fix.approx_mem_approx_chain -> Part.Fix.approx_mem_approxChain is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)
+but is expected to have type
+  forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {i : Nat}, Membership.mem.{max u2 u1, max u1 u2} (forall (a : α), Part.{u1} (β a)) (OmegaCompletePartialOrder.Chain.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (OmegaCompletePartialOrder.Chain.instMembershipChain.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approxChain.{u2, u1} α (fun (a : α) => β a) f)
+Case conversion may be inaccurate. Consider using '#align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChainₓ'. -/
 theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f :=
   Stream'.mem_of_nth_eq rfl
-#align part.fix.approx_mem_approx_chain Part.fix.approx_mem_approxChain
+#align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChain
 
 end Fix
 
@@ -156,6 +208,12 @@ open Nat
 
 open Nat.Upto OmegaCompletePartialOrder
 
+/- warning: part.fix_eq_ωSup -> Part.fix_eq_ωSup is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))), Eq.{max (succ u1) (succ u2)} (forall (x : α), Part.{u2} (β x)) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) (OmegaCompletePartialOrder.ωSup.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (x : α) => Part.{u2} (β x)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) (Part.Fix.approxChain.{u1, u2} α (fun (x : α) => β x) f))
+but is expected to have type
+  forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))), Eq.{max (succ u2) (succ u1)} (forall (x : α), Part.{u1} (β x)) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f)) (OmegaCompletePartialOrder.ωSup.{max u1 u2} (forall (x : α), Part.{u1} (β x)) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (x : α) => Part.{u1} (β x)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) (Part.Fix.approxChain.{u2, u1} α (fun (x : α) => β x) f))
+Case conversion may be inaccurate. Consider using '#align part.fix_eq_ωSup Part.fix_eq_ωSupₓ'. -/
 theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
   by
   apply le_antisymm
@@ -174,6 +232,12 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
     apply approx_le_fix f
 #align part.fix_eq_ωSup Part.fix_eq_ωSup
 
+/- warning: part.fix_le -> Part.fix_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) X)
+but is expected to have type
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f)) X)
+Case conversion may be inaccurate. Consider using '#align part.fix_le Part.fix_leₓ'. -/
 theorem fix_le {X : ∀ a, Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X :=
   by
   rw [fix_eq_ωSup f]
@@ -189,6 +253,12 @@ variable {f} (hc : Continuous f)
 
 include hc
 
+/- warning: part.fix_eq -> Part.fix_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} {f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))}, (OmegaCompletePartialOrder.Continuous.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) f) -> (Eq.{max (succ u1) (succ u2)} (forall (x : α), Part.{u2} (β x)) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))))
+but is expected to have type
+  forall {α : Type.{u2}} {β : α -> Type.{u1}} {f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))}, (OmegaCompletePartialOrder.Continuous.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) f) -> (Eq.{max (succ u2) (succ u1)} (forall (x : α), Part.{u1} (β x)) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f)) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))))
+Case conversion may be inaccurate. Consider using '#align part.fix_eq Part.fix_eqₓ'. -/
 theorem fix_eq : Part.fix f = f (Part.fix f) :=
   by
   rw [fix_eq_ωSup f, hc]
@@ -209,6 +279,12 @@ end Part
 
 namespace Part
 
+/- warning: part.to_unit_mono -> Part.toUnitMono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}}, (OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))) -> (OrderHom.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))))
+but is expected to have type
+  forall {α : Type.{u1}}, (OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))) -> (OrderHom.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))))
+Case conversion may be inaccurate. Consider using '#align part.to_unit_mono Part.toUnitMonoₓ'. -/
 /-- `to_unit` as a monotone function -/
 @[simps]
 def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α
@@ -217,6 +293,12 @@ def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Par
   monotone' x y (h : x ≤ y) u := f.Monotone <| h u
 #align part.to_unit_mono Part.toUnitMono
 
+/- warning: part.to_unit_cont -> Part.to_unit_cont is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} (f : OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))), (OmegaCompletePartialOrder.Continuous.{u1, u1} (Part.{u1} α) (Part.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) f) -> (OmegaCompletePartialOrder.Continuous.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.omegaCompletePartialOrder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Pi.omegaCompletePartialOrder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Part.toUnitMono.{u1} α f))
+but is expected to have type
+  forall {α : Type.{u1}} (f : OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))), (OmegaCompletePartialOrder.Continuous.{u1, u1} (Part.{u1} α) (Part.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) f) -> (OmegaCompletePartialOrder.Continuous.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.instOmegaCompletePartialOrderForAll.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Pi.instOmegaCompletePartialOrderForAll.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Part.toUnitMono.{u1} α f))
+Case conversion may be inaccurate. Consider using '#align part.to_unit_cont Part.to_unit_contₓ'. -/
 theorem to_unit_cont (f : Part α →o Part α) (hc : Continuous f) : Continuous (toUnitMono f)
   | c => by
     ext ⟨⟩ : 1
@@ -242,6 +324,7 @@ section Monotone
 
 variable (α β γ)
 
+#print Pi.monotoneCurry /-
 /-- `sigma.curry` as a monotone function. -/
 @[simps]
 def monotoneCurry [∀ x y, Preorder <| γ x y] : (∀ x : Σa, β a, γ x.1 x.2) →o ∀ (a) (b : β a), γ a b
@@ -249,7 +332,9 @@ def monotoneCurry [∀ x y, Preorder <| γ x y] : (∀ x : Σa, β a, γ x.1 x.2
   toFun := curry
   monotone' x y h a b := h ⟨a, b⟩
 #align pi.monotone_curry Pi.monotoneCurry
+-/
 
+#print Pi.monotoneUncurry /-
 /-- `sigma.uncurry` as a monotone function. -/
 @[simps]
 def monotoneUncurry [∀ x y, Preorder <| γ x y] :
@@ -258,11 +343,18 @@ def monotoneUncurry [∀ x y, Preorder <| γ x y] :
   toFun := uncurry
   monotone' x y h a := h a.1 a.2
 #align pi.monotone_uncurry Pi.monotoneUncurry
+-/
 
 variable [∀ x y, OmegaCompletePartialOrder <| γ x y]
 
 open OmegaCompletePartialOrder.Chain
 
+/- warning: pi.continuous_curry -> Pi.continuous_curry is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u3}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u1 u2) u3, max u1 u2 u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.monotoneCurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))))
+but is expected to have type
+  forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.monotoneCurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
+Case conversion may be inaccurate. Consider using '#align pi.continuous_curry Pi.continuous_curryₓ'. -/
 theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c =>
   by
   ext (x y)
@@ -271,6 +363,12 @@ theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c =>
   rfl
 #align pi.continuous_curry Pi.continuous_curry
 
+/- warning: pi.continuous_uncurry -> Pi.continuous_uncurry is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u3}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)], OmegaCompletePartialOrder.Continuous.{max u1 u2 u3, max (max u1 u2) u3} (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.monotoneUncurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))))
+but is expected to have type
+  forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.monotoneUncurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
+Case conversion may be inaccurate. Consider using '#align pi.continuous_uncurry Pi.continuous_uncurryₓ'. -/
 theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c =>
   by
   ext (x y)
@@ -294,6 +392,12 @@ variable {f : (∀ (x) (y : β x), γ x y) →o ∀ (x) (y : β x), γ x y}
 
 variable (hc : Continuous f)
 
+/- warning: pi.uncurry_curry_continuous -> Pi.uncurry_curry_continuous is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] {f : OrderHom.{max u1 u2 u3, max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1)))))}, (OmegaCompletePartialOrder.Continuous.{max u1 u2 u3, max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) f) -> (OmegaCompletePartialOrder.Continuous.{max (max u1 u2) u3, max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (OrderHom.comp.{max (max u1 u2) u3, max u1 u2 u3, max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (PartialOrder.toPreorder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (b : β i) => γ i b) (fun (i_1 : β i) => (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))) i i_1))) (Pi.preorder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (i : Sigma.{u1, u2} α (fun (a : α) => β a)) => (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))) (Sigma.fst.{u1, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) i))) (Pi.monotoneUncurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y)))) (OrderHom.comp.{max (max u1 u2) u3, max u1 u2 u3, max u1 u2 u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (PartialOrder.toPreorder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) f (Pi.monotoneCurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y)))))))
+but is expected to have type
+  forall {α : Type.{u3}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u1}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)] {f : OrderHom.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1)))))}, (OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) f) -> (OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (OrderHom.comp.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (PartialOrder.toPreorder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (b : β i) => γ i b) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (i : Sigma.{u3, u2} α (fun (a : α) => β a)) => PartialOrder.toPreorder.{u1} (γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i)) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i)) (_inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i))))) (Pi.monotoneUncurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y)))) (OrderHom.comp.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (PartialOrder.toPreorder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) f (Pi.monotoneCurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y)))))))
+Case conversion may be inaccurate. Consider using '#align pi.uncurry_curry_continuous Pi.uncurry_curry_continuousₓ'. -/
 theorem uncurry_curry_continuous :
     Continuous <| (monotoneUncurry α β γ).comp <| f.comp <| monotoneCurry α β γ :=
   continuous_comp _ _ (continuous_comp _ _ (continuous_curry _ _ _) hc) (continuous_uncurry _ _ _)
@@ -301,6 +405,7 @@ theorem uncurry_curry_continuous :
 
 end Curry
 
+#print Pi.Pi.lawfulFix' /-
 instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (∀ x y, γ x y)
     where fix_eq f hc := by
     dsimp [fix]
@@ -309,6 +414,7 @@ instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (
       erw [LawfulFix.fix_eq (uncurry_curry_continuous hc)]
     rfl
 #align pi.pi.lawful_fix' Pi.Pi.lawfulFix'
+-/
 
 end Pi
 

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

A PR accompanying #12339.

Zulip discussion

@@ -148,8 +148,8 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) := by
     cases' exists_fix_le_approx f x with i hx
     trans approx f i.succ x
     · trans
-      apply hx
-      apply approx_mono' f
+      · apply hx
+      · apply approx_mono' f
     apply le_ωSup_of_le i.succ
     dsimp [approx]
     rfl
@@ -166,7 +166,10 @@ theorem fix_le {X : (a : _) → Part <| β a} (hX : f X ≤ X) : Part.fix f ≤
   intro i
   induction i with
   | zero => dsimp [Fix.approx]; apply bot_le
-  | succ _ i_ih => trans f X; apply f.monotone i_ih; apply hX
+  | succ _ i_ih =>
+    trans f X
+    · apply f.monotone i_ih
+    · apply hX
 #align part.fix_le Part.fix_le
 
 variable {f} (hc : Continuous f)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -132,7 +132,6 @@ end Fix
 open Fix
 
 variable {α : Type*}
-
 variable (f : ((a : _) → Part <| β a) →o (a : _) → Part <| β a)
 
 open OmegaCompletePartialOrder
@@ -272,7 +271,6 @@ variable [∀ x y, OmegaCompletePartialOrder <| γ x y]
 section Curry
 
 variable {f : ((x : _) → (y : β x) → γ x y) →o (x : _) → (y : β x) → γ x y}
-
 variable (hc : Continuous f)
 
 theorem uncurry_curry_continuous :

We remove all but one open Classicals, instead preferring to use open scoped Classical. The only real side-effect this led to is moving a couple declarations to use Exists.choose instead of Classical.choose.

The first few commits are explicitly labelled regex replaces for ease of review.

@@ -24,7 +24,7 @@ omega complete partial orders (ωCPO). Proofs of the lawfulness of all `Fix` ins
 
 universe u v
 
-open Classical
+open scoped Classical
 
 variable {α : Type*} {β : α → Type*}
 

@@ -282,13 +282,13 @@ theorem uncurry_curry_continuous :
 
 end Curry
 
-instance Pi.lawfulFix' [LawfulFix <| (x : Sigma β) → γ x.1 x.2] :
+instance lawfulFix' [LawfulFix <| (x : Sigma β) → γ x.1 x.2] :
     LawfulFix ((x y : _) → γ x y) where
   fix_eq {_f} hc := by
     dsimp [fix]
     conv =>
       lhs
       erw [LawfulFix.fix_eq (uncurry_curry_continuous hc)]
-#align pi.pi.lawful_fix' Pi.Pi.lawfulFix'
+#align pi.pi.lawful_fix' Pi.lawfulFix'
 
 end Pi

I literally went through and regex'd some uses of cases', replacing them with rcases; this is meant to be a low effort PR as I hope that tools can do this in the future.

rcases is an easier replacement than cases, though with better tools we could in future do a second pass converting simple rcases added here (and existing ones) to cases.

@@ -83,7 +83,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
     cases' hh with i hh
     revert h₁; generalize succ (Nat.find h₀) = j; intro h₁
     wlog case : i ≤ j
-    · cases' le_total i j with H H <;> [skip; symm] <;> apply_assumption <;> assumption
+    · rcases le_total i j with H | H <;> [skip; symm] <;> apply_assumption <;> assumption
     replace hh := approx_mono f case _ _ hh
     apply Part.mem_unique h₁ hh
   · simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]

Many of nth (e.g. list.nth, stream.seq.nth) are renamed to get? in Mathlib 4, but Stream'.nth had been remained as it.

@@ -124,7 +124,7 @@ theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x := by
 #align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approx
 
 theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f :=
-  Stream'.mem_of_nth_eq rfl
+  Stream'.mem_of_get_eq rfl
 #align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChain
 
 end Fix

Many proofs use the "stream of consciousness" style from Lean 3, rather than have ... := or suffices ... from/by.

This PR updates a fraction of these to the preferred Lean 4 style.

I think a good goal would be to delete the "deferred" versions of have, suffices, and let at the bottom of Mathlib.Tactic.Have

(Anyone who would like to contribute more cleanup is welcome to push directly to this branch.)

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

@@ -77,8 +77,8 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
     rw [dom_iff_mem] at h₁
     cases' h₁ with y h₁
     replace h₁ := approx_mono' f _ _ h₁
-    suffices : y = b
-    · subst this
+    suffices y = b by
+      subst this
       exact h₁
     cases' hh with i hh
     revert h₁; generalize succ (Nat.find h₀) = j; intro h₁

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

This has nice performance benefits.

@@ -26,7 +26,7 @@ universe u v
 
 open Classical
 
-variable {α : Type _} {β : α → Type _}
+variable {α : Type*} {β : α → Type*}
 
 open OmegaCompletePartialOrder
 
@@ -37,7 +37,7 @@ functions `f`, such as the function that is defined iff its argument is not, fam
 halting problem. Instead, this requirement is limited to only functions that are `Continuous` in the
 sense of `ω`-complete partial orders, which excludes the example because it is not monotone
 (making the input argument less defined can make `f` more defined). -/
-class LawfulFix (α : Type _) [OmegaCompletePartialOrder α] extends Fix α where
+class LawfulFix (α : Type*) [OmegaCompletePartialOrder α] extends Fix α where
   fix_eq : ∀ {f : α →o α}, Continuous f → Fix.fix f = f (Fix.fix f)
 #align lawful_fix LawfulFix
 
@@ -131,7 +131,7 @@ end Fix
 
 open Fix
 
-variable {α : Type _}
+variable {α : Type*}
 
 variable (f : ((a : _) → Part <| β a) →o (a : _) → Part <| β a)
 
@@ -219,7 +219,7 @@ instance lawfulFix {β} : LawfulFix (α → Part β) :=
   ⟨fun {_f} ↦ Part.fix_eq⟩
 #align pi.lawful_fix Pi.lawfulFix
 
-variable {γ : ∀ a : α, β a → Type _}
+variable {γ : ∀ a : α, β a → Type*}
 
 section Monotone
 

Co-authored-by: Jujian Zhang <jujian.zhang1998@outlook.com> Co-authored-by: Oliver Nash <github@olivernash.org>

@@ -155,7 +155,7 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) := by
     dsimp [approx]
     rfl
   · apply ωSup_le _ _ _
-    simp only [Fix.approxChain, OrderHom.coe_fun_mk]
+    simp only [Fix.approxChain, OrderHom.coe_mk]
     intro y x
     apply approx_le_fix f
 #align part.fix_eq_ωSup Part.fix_eq_ωSup
@@ -163,7 +163,7 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) := by
 theorem fix_le {X : (a : _) → Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X := by
   rw [fix_eq_ωSup f]
   apply ωSup_le _ _ _
-  simp only [Fix.approxChain, OrderHom.coe_fun_mk]
+  simp only [Fix.approxChain, OrderHom.coe_mk]
   intro i
   induction i with
   | zero => dsimp [Fix.approx]; apply bot_le

• depends on: #5966

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

@@ -2,17 +2,14 @@
 Copyright (c) 2020 Simon Hudon. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon
-
-! This file was ported from Lean 3 source module control.lawful_fix
-! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Stream.Init
 import Mathlib.Tactic.ApplyFun
 import Mathlib.Control.Fix
 import Mathlib.Order.OmegaCompletePartialOrder
 
+#align_import control.lawful_fix from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
+
 /-!
 # Lawful fixed point operators
 

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

@@ -60,7 +60,7 @@ variable (f : ((a : _) → Part <| β a) →o (a : _) → Part <| β a)
 theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) := by
   induction i with
   | zero => dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
-  | succ _ i_ih => intro ; apply f.monotone; apply i_ih
+  | succ _ i_ih => intro; apply f.monotone; apply i_ih
 #align part.fix.approx_mono' Part.Fix.approx_mono'
 
 theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j := by
@@ -170,7 +170,7 @@ theorem fix_le {X : (a : _) → Part <| β a} (hX : f X ≤ X) : Part.fix f ≤
   intro i
   induction i with
   | zero => dsimp [Fix.approx]; apply bot_le
-  | succ _ i_ih => trans f X; apply f.monotone i_ih ; apply hX
+  | succ _ i_ih => trans f X; apply f.monotone i_ih; apply hX
 #align part.fix_le Part.fix_le
 
 variable {f} (hc : Continuous f)

Co-authored-by: Xavier Roblot <46200072+xroblot@users.noreply.github.com> Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr> Co-authored-by: Riccardo Brasca <riccardo.brasca@gmail.com> Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Pol'tta / Miyahara Kō <pol_tta@outlook.jp> Co-authored-by: Jason Yuen <jason_yuen2007@hotmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Jireh Loreaux <loreaujy@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Heather Macbeth <25316162+hrmacbeth@users.noreply.github.com> Co-authored-by: Jujian Zhang <jujian.zhang1998@outlook.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

@@ -249,7 +249,7 @@ variable [(x y : _) → OmegaCompletePartialOrder <| γ x y]
 open OmegaCompletePartialOrder.Chain
 
 theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c ↦ by
-  ext (x y)
+  ext x y
   dsimp [curry, ωSup]
   rw [map_comp, map_comp]
   rfl

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Alex J Best <alex.j.best@gmail.com>

@@ -256,7 +256,7 @@ theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c ↦ by
 #align pi.continuous_curry Pi.continuous_curry
 
 theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c ↦ by
-  ext (x y)
+  ext ⟨x, y⟩
   dsimp [uncurry, ωSup]
   rw [map_comp, map_comp]
   rfl

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

@@ -37,7 +37,7 @@ open OmegaCompletePartialOrder
 /-- Intuitively, a fixed point operator `fix` is lawful if it satisfies `fix f = f (fix f)` for all
 `f`, but this is inconsistent / uninteresting in most cases due to the existence of "exotic"
 functions `f`, such as the function that is defined iff its argument is not, familiar from the
-halting problem. Instead, this requirement is limited to only functions that are `continuous` in the
+halting problem. Instead, this requirement is limited to only functions that are `Continuous` in the
 sense of `ω`-complete partial orders, which excludes the example because it is not monotone
 (making the input argument less defined can make `f` more defined). -/
 class LawfulFix (α : Type _) [OmegaCompletePartialOrder α] extends Fix α where

The main breaking change is that tac <;> [t1, t2] is now written tac <;> [t1; t2], to avoid clashing with tactics like cases and use that take comma-separated lists.

@@ -86,7 +86,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
     cases' hh with i hh
     revert h₁; generalize succ (Nat.find h₀) = j; intro h₁
     wlog case : i ≤ j
-    · cases' le_total i j with H H <;> [skip, symm] <;> apply_assumption <;> assumption
+    · cases' le_total i j with H H <;> [skip; symm] <;> apply_assumption <;> assumption
     replace hh := approx_mono f case _ _ hh
     apply Part.mem_unique h₁ hh
   · simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]

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

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

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

@@ -12,7 +12,6 @@ import Mathlib.Data.Stream.Init
 import Mathlib.Tactic.ApplyFun
 import Mathlib.Control.Fix
 import Mathlib.Order.OmegaCompletePartialOrder
-import Mathlib.Tactic.WLOG
 
 /-!
 # Lawful fixed point operators

Lean 4 code generator has had no native supports for Acc.rec. This PR makes Acc.rec computable. This change makes many defs computable. Especially, computable PFun.fix and Part.hasFix enables us to reason about partial functions. This PR also renames some instances and gives PFun.lift @[coe] attr.

@@ -208,9 +208,7 @@ theorem to_unit_cont (f : Part α →o Part α) (hc : Continuous f) : Continuous
     erw [hc, Chain.map_comp]; rfl
 #align part.to_unit_cont Part.to_unit_cont
 
--- Porting note: `noncomputable` is required because the code generator does not support recursor
---               `Acc.rec` yet.
-noncomputable instance lawfulFix : LawfulFix (Part α) :=
+instance lawfulFix : LawfulFix (Part α) :=
   ⟨fun {f : Part α →o Part α} hc ↦ show Part.fix (toUnitMono f) () = _ by
     rw [Part.fix_eq (to_unit_cont f hc)]; rfl⟩
 #align part.lawful_fix Part.lawfulFix
@@ -221,9 +219,7 @@ open Sigma
 
 namespace Pi
 
--- Porting note: `noncomputable` is required because the code generator does not support recursor
---               `Acc.rec` yet.
-noncomputable instance lawfulFix {β} : LawfulFix (α → Part β) :=
+instance lawfulFix {β} : LawfulFix (α → Part β) :=
   ⟨fun {_f} ↦ Part.fix_eq⟩
 #align pi.lawful_fix Pi.lawfulFix
 

The only change here comes from a change in wlog in mathlib3.The change is already present in mathlib4.

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon
 
 ! This file was ported from Lean 3 source module control.lawful_fix
-! leanprover-community/mathlib commit 1126441d6bccf98c81214a0780c73d499f6721fe
+! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

@@ -65,7 +65,7 @@ theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) := by
 #align part.fix.approx_mono' Part.Fix.approx_mono'
 
 theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j := by
-  induction' j with j ih;
+  induction' j with j ih
   · cases hij
     exact le_rfl
   cases hij; · exact le_rfl
@@ -76,14 +76,14 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
   by_cases h₀ : ∃ i : ℕ, (approx f i a).Dom
   · simp only [Part.fix_def f h₀]
     constructor <;> intro hh
-    exact ⟨_, hh⟩
+    · exact ⟨_, hh⟩
     have h₁ := Nat.find_spec h₀
     rw [dom_iff_mem] at h₁
     cases' h₁ with y h₁
     replace h₁ := approx_mono' f _ _ h₁
     suffices : y = b
-    subst this
-    exact h₁
+    · subst this
+      exact h₁
     cases' hh with i hh
     revert h₁; generalize succ (Nat.find h₀) = j; intro h₁
     wlog case : i ≤ j
@@ -196,8 +196,7 @@ namespace Part
 
 /-- `toUnit` as a monotone function -/
 @[simps]
-def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α
-    where
+def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α where
   toFun x u := f (x u)
   monotone' x y (h : x ≤ y) u := f.monotone <| h u
 #align part.to_unit_mono Part.toUnitMono

Co-authored-by: Moritz Firsching <firsching@google.com> Co-authored-by: Komyyy <pol_tta@outlook.jp>