Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

3ff3f2d6

(last sync)

feat(set_theory/cardinal/finite): prove lemmas to handle part_enat.card (#19198)

Prove some lemmas that allow to handle part_enat.card of finite cardinals, analogous to those about nat.card

Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr>

Diff

@@ -380,6 +380,9 @@ begin
   apply_mod_cast nat.lt_of_succ_le, apply_mod_cast h
 end
 
+lemma coe_succ_le_iff {n : ℕ} {e : part_enat} : ↑n.succ ≤ e ↔ ↑n < e:=
+by rw [nat.succ_eq_add_one n, nat.cast_add, nat.cast_one, add_one_le_iff_lt (coe_ne_top n)]
+
 lemma lt_add_one_iff_lt {x y : part_enat} (hx : x ≠ ⊤) : x < y + 1 ↔ x ≤ y :=
 begin
   split, exact le_of_lt_add_one,
@@ -388,6 +391,9 @@ begin
   apply_mod_cast nat.lt_succ_of_le, apply_mod_cast h
 end
 
+lemma lt_coe_succ_iff_le {x : part_enat} {n : ℕ} (hx : x ≠ ⊤) : x < n.succ ↔ x ≤ n :=
+by rw [nat.succ_eq_add_one n, nat.cast_add, nat.cast_one, lt_add_one_iff_lt hx]
+
 lemma add_eq_top_iff {a b : part_enat} : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ :=
 by apply part_enat.cases_on a; apply part_enat.cases_on b;
   simp; simp only [(nat.cast_add _ _).symm, part_enat.coe_ne_top]; simp

114ff8a4

feat(data/nat/multiplicity): rename nat.multiplicity_choose_prime_pow, add lemmas (#18183)

Rename nat.multiplicity_choose_prime_pow to nat.multiplicity_choose_prime_pow_add_multiplicity.
Add part_enat.eq_coe_sub_of_add_eq_coe and a version of nat.multiplicity_choose_prime_pow with just the multiplicity of p in choose (p ^ n) k in the LHS.
Golf 2 proofs.

Diff

@@ -94,6 +94,8 @@ lemma some_eq_coe (n : ℕ) : some n = n := rfl
 
 @[simp] lemma dom_coe (x : ℕ) : (x : part_enat).dom := trivial
 
+instance : can_lift part_enat ℕ coe dom := ⟨λ n hn, ⟨n.get hn, part.some_get _⟩⟩
+
 instance : has_le part_enat := ⟨λ x y, ∃ h : y.dom → x.dom, ∀ hy : y.dom, x.get (h hy) ≤ y.get hy⟩
 instance : has_top part_enat := ⟨none⟩
 instance : has_bot part_enat := ⟨0⟩
@@ -326,6 +328,15 @@ instance : canonically_ordered_add_monoid part_enat :=
   ..part_enat.order_bot,
   ..part_enat.ordered_add_comm_monoid }
 
+lemma eq_coe_sub_of_add_eq_coe {x y : part_enat} {n : ℕ} (h : x + y = n) :
+  x = ↑(n - y.get (dom_of_le_coe ((le_add_left le_rfl).trans_eq h))) :=
+begin
+  lift x to ℕ using dom_of_le_coe ((le_add_right le_rfl).trans_eq h),
+  lift y to ℕ using dom_of_le_coe ((le_add_left le_rfl).trans_eq h),
+  rw [← nat.cast_add, coe_inj] at h,
+  rw [get_coe, coe_inj, eq_tsub_of_add_eq h]
+end
+
 protected lemma add_lt_add_right {x y z : part_enat} (h : x < y) (hz : z ≠ ⊤) : x + z < y + z :=
 begin
   rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩,

f7fc89d5

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

3ff3f2d6

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 -/
-import Algebra.Hom.Equiv.Basic
+import Algebra.Group.Equiv.Basic
 import Data.Part
-import Data.Enat.Lattice
+import Data.ENat.Lattice
 import Tactic.NormNum
 
 #align_import data.nat.part_enat from "leanprover-community/mathlib"@"3ff3f2d6a3118b8711063de7111a0d77a53219a8"

3ff3f2d6

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -254,7 +254,7 @@ theorem dom_of_le_some {x : PartENat} {y : ℕ} (h : x ≤ some y) : x.Dom :=
 -/
 
 #print PartENat.dom_of_le_natCast /-
-theorem dom_of_le_natCast {x : PartENat} {y : ℕ} (h : x ≤ y) : x.Dom := by rw [← some_eq_coe] at h ;
+theorem dom_of_le_natCast {x : PartENat} {y : ℕ} (h : x ≤ y) : x.Dom := by rw [← some_eq_coe] at h;
   exact dom_of_le_some h
 #align part_enat.dom_of_le_coe PartENat.dom_of_le_natCast
 -/
@@ -299,10 +299,10 @@ theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.ge
     by_cases hx : x.dom
     · use hx; intro hy
       specialize H hy; specialize h fun _ => hy
-      rw [Classical.not_forall] at h ; cases' h with hx' h
-      rw [not_le] at h ; exact h
+      rw [Classical.not_forall] at h; cases' h with hx' h
+      rw [not_le] at h; exact h
     · specialize h fun hx' => (hx hx').elim
-      rw [Classical.not_forall] at h ; cases' h with hx' h
+      rw [Classical.not_forall] at h; cases' h with hx' h
       exact (hx hx').elim
   · rintro ⟨hx, H⟩;
     exact ⟨⟨fun _ => hx, fun hy => (H hy).le⟩, fun hxy h => not_lt_of_le (h _) (H _)⟩
@@ -534,7 +534,7 @@ theorem eq_natCast_sub_of_add_eq_natCast {x y : PartENat} {n : ℕ} (h : x + y =
   by
   lift x to ℕ using dom_of_le_coe ((le_add_right le_rfl).trans_eq h)
   lift y to ℕ using dom_of_le_coe ((le_add_left le_rfl).trans_eq h)
-  rw [← Nat.cast_add, coe_inj] at h 
+  rw [← Nat.cast_add, coe_inj] at h
   rw [get_coe, coe_inj, eq_tsub_of_add_eq h]
 #align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_natCast_sub_of_add_eq_natCast
 -/
@@ -546,7 +546,7 @@ protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ 
   rcases ne_top_iff.mp hz with ⟨k, rfl⟩
   induction' y using PartENat.casesOn with n
   · rw [top_add]; apply_mod_cast coe_lt_top
-  norm_cast at h ; apply_mod_cast add_lt_add_right h
+  norm_cast at h; apply_mod_cast add_lt_add_right h
 #align part_enat.add_lt_add_right PartENat.add_lt_add_right
 -/
 
@@ -893,7 +893,7 @@ theorem lt_find_iff (n : ℕ) : (n : PartENat) < find P ↔ ∀ m ≤ n, ¬P m :
   refine' ⟨_, lt_find P n⟩
   intro h m hm
   by_cases H : (find P).Dom
-  · apply Nat.find_min H; rw [coe_lt_iff] at h ; specialize h H; exact lt_of_le_of_lt hm h
+  · apply Nat.find_min H; rw [coe_lt_iff] at h; specialize h H; exact lt_of_le_of_lt hm h
   · exact not_exists.mp H m
 #align part_enat.lt_find_iff PartENat.lt_find_iff
 -/

3ff3f2d6

bump to nightly-2024-02-01-06

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

5433bded

Diff

@@ -445,7 +445,8 @@ theorem ne_top_iff {x : PartENat} : x ≠ ⊤ ↔ ∃ n : ℕ, x = n := by
 -/
 
 #print PartENat.ne_top_iff_dom /-
-theorem ne_top_iff_dom {x : PartENat} : x ≠ ⊤ ↔ x.Dom := by classical
+theorem ne_top_iff_dom {x : PartENat} : x ≠ ⊤ ↔ x.Dom := by
+  classical exact not_iff_comm.1 part.eq_none_iff'.symm
 #align part_enat.ne_top_iff_dom PartENat.ne_top_iff_dom
 -/
 
@@ -836,7 +837,11 @@ noncomputable def withTopAddEquiv : PartENat ≃+ ℕ∞ :=
 end WithTopEquiv
 
 #print PartENat.lt_wf /-
-theorem lt_wf : @WellFounded PartENat (· < ·) := by classical
+theorem lt_wf : @WellFounded PartENat (· < ·) := by
+  classical
+  change WellFounded fun a b : PartENat => a < b
+  simp_rw [← to_with_top_lt]
+  exact InvImage.wf _ (WithTop.instWellFoundedLT Nat.lt_wfRel)
 #align part_enat.lt_wf PartENat.lt_wf
 -/

3ff3f2d6

bump to nightly-2024-01-31-06

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

61100fe9

Diff

@@ -445,8 +445,7 @@ theorem ne_top_iff {x : PartENat} : x ≠ ⊤ ↔ ∃ n : ℕ, x = n := by
 -/
 
 #print PartENat.ne_top_iff_dom /-
-theorem ne_top_iff_dom {x : PartENat} : x ≠ ⊤ ↔ x.Dom := by
-  classical exact not_iff_comm.1 part.eq_none_iff'.symm
+theorem ne_top_iff_dom {x : PartENat} : x ≠ ⊤ ↔ x.Dom := by classical
 #align part_enat.ne_top_iff_dom PartENat.ne_top_iff_dom
 -/
 
@@ -837,11 +836,7 @@ noncomputable def withTopAddEquiv : PartENat ≃+ ℕ∞ :=
 end WithTopEquiv
 
 #print PartENat.lt_wf /-
-theorem lt_wf : @WellFounded PartENat (· < ·) := by
-  classical
-  change WellFounded fun a b : PartENat => a < b
-  simp_rw [← to_with_top_lt]
-  exact InvImage.wf _ (WithTop.instWellFoundedLT Nat.lt_wfRel)
+theorem lt_wf : @WellFounded PartENat (· < ·) := by classical
 #align part_enat.lt_wf PartENat.lt_wf
 -/

3ff3f2d6

bump to nightly-2023-11-11-06

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

55354f59

Diff

@@ -272,19 +272,15 @@ instance decidableLe (x y : PartENat) [Decidable x.Dom] [Decidable y.Dom] : Deci
 #align part_enat.decidable_le PartENat.decidableLe
 -/
 
-#print PartENat.natCast_AddMonoidHom /-
 /-- The coercion `ℕ → part_enat` preserves `0` and addition. -/
-def natCast_AddMonoidHom : ℕ →+ PartENat :=
+def coeHom : ℕ →+ PartENat :=
   ⟨coe, Nat.cast_zero, Nat.cast_add⟩
-#align part_enat.coe_hom PartENat.natCast_AddMonoidHom
--/
+#align part_enat.coe_hom PartENat.coeHom
 
-#print PartENat.coe_coeHom /-
 @[simp]
-theorem coe_coeHom : ⇑natCast_AddMonoidHom = coe :=
+theorem coe_coeHom : ⇑coeHom = coe :=
   rfl
 #align part_enat.coe_coe_hom PartENat.coe_coeHom
--/
 
 instance : PartialOrder PartENat where
   le := (· ≤ ·)
@@ -369,11 +365,9 @@ theorem coe_lt_iff (n : ℕ) (x : PartENat) : (n : PartENat) < x ↔ ∀ h : x.D
 #align part_enat.coe_lt_iff PartENat.coe_lt_iff
 -/
 
-#print PartENat.NeZero.one /-
 instance NeZero.one : NeZero (1 : PartENat) :=
   ⟨natCast_inj.Not.mpr (by decide)⟩
 #align part_enat.ne_zero.one PartENat.NeZero.one
--/
 
 #print PartENat.semilatticeSup /-
 instance semilatticeSup : SemilatticeSup PartENat :=

3ff3f2d6

bump to nightly-2023-11-05-06

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

acc3325f

Diff

@@ -847,7 +847,7 @@ theorem lt_wf : @WellFounded PartENat (· < ·) := by
   classical
   change WellFounded fun a b : PartENat => a < b
   simp_rw [← to_with_top_lt]
-  exact InvImage.wf _ (WithTop.wellFounded_lt Nat.lt_wfRel)
+  exact InvImage.wf _ (WithTop.instWellFoundedLT Nat.lt_wfRel)
 #align part_enat.lt_wf PartENat.lt_wf
 -/

3ff3f2d6

bump to nightly-2023-10-21-06

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

a2dc86f8

Diff

@@ -303,10 +303,10 @@ theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.ge
     by_cases hx : x.dom
     · use hx; intro hy
       specialize H hy; specialize h fun _ => hy
-      rw [not_forall] at h ; cases' h with hx' h
+      rw [Classical.not_forall] at h ; cases' h with hx' h
       rw [not_le] at h ; exact h
     · specialize h fun hx' => (hx hx').elim
-      rw [not_forall] at h ; cases' h with hx' h
+      rw [Classical.not_forall] at h ; cases' h with hx' h
       exact (hx hx').elim
   · rintro ⟨hx, H⟩;
     exact ⟨⟨fun _ => hx, fun hy => (H hy).le⟩, fun hxy h => not_lt_of_le (h _) (H _)⟩

3ff3f2d6

bump to nightly-2023-10-07-06

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

d191b687

Diff

@@ -521,7 +521,7 @@ instance : OrderedAddCommMonoid PartENat :=
         ⟨fun h => And.intro (dom_natCast _) (h₁ h.2), fun h => by
           simpa only [coe_add_get] using add_le_add_left (h₂ _) c⟩ }
 
-instance : CanonicallyOrderedAddMonoid PartENat :=
+instance : CanonicallyOrderedAddCommMonoid PartENat :=
   { PartENat.semilatticeSup, PartENat.orderBot,
     PartENat.orderedAddCommMonoid with
     le_self_add := fun a b =>

3ff3f2d6

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 -/
-import Mathbin.Algebra.Hom.Equiv.Basic
-import Mathbin.Data.Part
-import Mathbin.Data.Enat.Lattice
-import Mathbin.Tactic.NormNum
+import Algebra.Hom.Equiv.Basic
+import Data.Part
+import Data.Enat.Lattice
+import Tactic.NormNum
 
 #align_import data.nat.part_enat from "leanprover-community/mathlib"@"3ff3f2d6a3118b8711063de7111a0d77a53219a8"

3ff3f2d6

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
-
-! This file was ported from Lean 3 source module data.nat.part_enat
-! leanprover-community/mathlib commit 3ff3f2d6a3118b8711063de7111a0d77a53219a8
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Hom.Equiv.Basic
 import Mathbin.Data.Part
 import Mathbin.Data.Enat.Lattice
 import Mathbin.Tactic.NormNum
 
+#align_import data.nat.part_enat from "leanprover-community/mathlib"@"3ff3f2d6a3118b8711063de7111a0d77a53219a8"
+
 /-!
 # Natural numbers with infinity

3ff3f2d6

bump to nightly-2023-06-27-03

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

b5e0c440

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 
 ! This file was ported from Lean 3 source module data.nat.part_enat
-! leanprover-community/mathlib commit 114ff8a4a7935cb7531062200bff375e7b1d6d85
+! leanprover-community/mathlib commit 3ff3f2d6a3118b8711063de7111a0d77a53219a8
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -611,6 +611,14 @@ theorem add_one_le_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x + 1 ≤ y ↔ x
 #align part_enat.add_one_le_iff_lt PartENat.add_one_le_iff_lt
 -/
 
+/- warning: part_enat.coe_succ_le_iff clashes with part_enat.coe_succ_le_succ_iff -> PartENat.coe_succ_le_iff
+Case conversion may be inaccurate. Consider using '#align part_enat.coe_succ_le_iff PartENat.coe_succ_le_iffₓ'. -/
+#print PartENat.coe_succ_le_iff /-
+theorem coe_succ_le_iff {n : ℕ} {e : PartENat} : ↑n.succ ≤ e ↔ ↑n < e := by
+  rw [Nat.succ_eq_add_one n, Nat.cast_add, Nat.cast_one, add_one_le_iff_lt (coe_ne_top n)]
+#align part_enat.coe_succ_le_iff PartENat.coe_succ_le_iff
+-/
+
 #print PartENat.lt_add_one_iff_lt /-
 theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x ≤ y :=
   by
@@ -621,6 +629,12 @@ theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x 
 #align part_enat.lt_add_one_iff_lt PartENat.lt_add_one_iff_lt
 -/
 
+#print PartENat.lt_coe_succ_iff_le /-
+theorem lt_coe_succ_iff_le {x : PartENat} {n : ℕ} (hx : x ≠ ⊤) : x < n.succ ↔ x ≤ n := by
+  rw [Nat.succ_eq_add_one n, Nat.cast_add, Nat.cast_one, lt_add_one_iff_lt hx]
+#align part_enat.lt_coe_succ_iff_le PartENat.lt_coe_succ_iff_le
+-/
+
 #print PartENat.add_eq_top_iff /-
 theorem add_eq_top_iff {a b : PartENat} : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ := by
   apply PartENat.casesOn a <;> apply PartENat.casesOn b <;> simp <;>

114ff8a4

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -116,19 +116,25 @@ instance : AddCommMonoidWithOne PartENat :=
     natCast_zero := rfl
     natCast_succ := fun _ => Part.ext' (true_and_iff _).symm fun _ _ => rfl }
 
+#print PartENat.some_eq_natCast /-
 theorem some_eq_natCast (n : ℕ) : some n = n :=
   rfl
 #align part_enat.some_eq_coe PartENat.some_eq_natCast
+-/
 
+#print PartENat.natCast_inj /-
 @[simp, norm_cast]
 theorem natCast_inj {x y : ℕ} : (x : PartENat) = y ↔ x = y :=
   Part.some_inj
 #align part_enat.coe_inj PartENat.natCast_inj
+-/
 
+#print PartENat.dom_natCast /-
 @[simp]
 theorem dom_natCast (x : ℕ) : (x : PartENat).Dom :=
   trivial
 #align part_enat.dom_coe PartENat.dom_natCast
+-/
 
 instance : CanLift PartENat ℕ coe Dom :=
   ⟨fun n hn => ⟨n.get hn, Part.some_get _⟩⟩
@@ -160,10 +166,12 @@ protected theorem casesOn' {P : PartENat → Prop} :
 #align part_enat.cases_on' PartENat.casesOn'
 -/
 
+#print PartENat.casesOn /-
 @[elab_as_elim]
 protected theorem casesOn {P : PartENat → Prop} : ∀ a : PartENat, P ⊤ → (∀ n : ℕ, P n) → P a := by
   simp only [← some_eq_coe]; exact PartENat.casesOn'
 #align part_enat.cases_on PartENat.casesOn
+-/
 
 #print PartENat.top_add /-
 @[simp]
@@ -178,23 +186,31 @@ theorem add_top (x : PartENat) : x + ⊤ = ⊤ := by rw [add_comm, top_add]
 #align part_enat.add_top PartENat.add_top
 -/
 
+#print PartENat.natCast_get /-
 @[simp]
 theorem natCast_get {x : PartENat} (h : x.Dom) : (x.get h : PartENat) = x := by rw [← some_eq_coe];
   exact Part.ext' (iff_of_true trivial h) fun _ _ => rfl
 #align part_enat.coe_get PartENat.natCast_get
+-/
 
+#print PartENat.get_natCast' /-
 @[simp, norm_cast]
 theorem get_natCast' (x : ℕ) (h : (x : PartENat).Dom) : get (x : PartENat) h = x := by
   rw [← coe_inj, coe_get]
 #align part_enat.get_coe' PartENat.get_natCast'
+-/
 
+#print PartENat.get_natCast /-
 theorem get_natCast {x : ℕ} : get (x : PartENat) (dom_natCast x) = x :=
   get_natCast' _ _
 #align part_enat.get_coe PartENat.get_natCast
+-/
 
+#print PartENat.coe_add_get /-
 theorem coe_add_get {x : ℕ} {y : PartENat} (h : ((x : PartENat) + y).Dom) :
     get ((x : PartENat) + y) h = x + get y h.2 := by simp only [← some_eq_coe] at h ⊢; rfl
 #align part_enat.coe_add_get PartENat.coe_add_get
+-/
 
 #print PartENat.get_add /-
 @[simp]
@@ -223,9 +239,11 @@ theorem get_eq_iff_eq_some {a : PartENat} {ha : a.Dom} {b : ℕ} : a.get ha = b
 #align part_enat.get_eq_iff_eq_some PartENat.get_eq_iff_eq_some
 -/
 
+#print PartENat.get_eq_iff_eq_coe /-
 theorem get_eq_iff_eq_coe {a : PartENat} {ha : a.Dom} {b : ℕ} : a.get ha = b ↔ a = b := by
   rw [get_eq_iff_eq_some, some_eq_coe]
 #align part_enat.get_eq_iff_eq_coe PartENat.get_eq_iff_eq_coe
+-/
 
 #print PartENat.dom_of_le_of_dom /-
 theorem dom_of_le_of_dom {x y : PartENat} : x ≤ y → y.Dom → x.Dom := fun ⟨h, _⟩ => h
@@ -238,9 +256,11 @@ theorem dom_of_le_some {x : PartENat} {y : ℕ} (h : x ≤ some y) : x.Dom :=
 #align part_enat.dom_of_le_some PartENat.dom_of_le_some
 -/
 
+#print PartENat.dom_of_le_natCast /-
 theorem dom_of_le_natCast {x : PartENat} {y : ℕ} (h : x ≤ y) : x.Dom := by rw [← some_eq_coe] at h ;
   exact dom_of_le_some h
 #align part_enat.dom_of_le_coe PartENat.dom_of_le_natCast
+-/
 
 #print PartENat.decidableLe /-
 instance decidableLe (x y : PartENat) [Decidable x.Dom] [Decidable y.Dom] : Decidable (x ≤ y) :=
@@ -255,15 +275,19 @@ instance decidableLe (x y : PartENat) [Decidable x.Dom] [Decidable y.Dom] : Deci
 #align part_enat.decidable_le PartENat.decidableLe
 -/
 
+#print PartENat.natCast_AddMonoidHom /-
 /-- The coercion `ℕ → part_enat` preserves `0` and addition. -/
 def natCast_AddMonoidHom : ℕ →+ PartENat :=
   ⟨coe, Nat.cast_zero, Nat.cast_add⟩
 #align part_enat.coe_hom PartENat.natCast_AddMonoidHom
+-/
 
+#print PartENat.coe_coeHom /-
 @[simp]
 theorem coe_coeHom : ⇑natCast_AddMonoidHom = coe :=
   rfl
 #align part_enat.coe_coe_hom PartENat.coe_coeHom
+-/
 
 instance : PartialOrder PartENat where
   le := (· ≤ ·)
@@ -292,15 +316,19 @@ theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.ge
 #align part_enat.lt_def PartENat.lt_def
 -/
 
+#print PartENat.coe_le_coe /-
 @[simp, norm_cast]
 theorem coe_le_coe {x y : ℕ} : (x : PartENat) ≤ y ↔ x ≤ y := by rw [← some_eq_coe, ← some_eq_coe];
   exact ⟨fun ⟨_, h⟩ => h trivial, fun h => ⟨fun _ => trivial, fun _ => h⟩⟩
 #align part_enat.coe_le_coe PartENat.coe_le_coe
+-/
 
+#print PartENat.coe_lt_coe /-
 @[simp, norm_cast]
 theorem coe_lt_coe {x y : ℕ} : (x : PartENat) < y ↔ x < y := by
   rw [lt_iff_le_not_le, lt_iff_le_not_le, coe_le_coe, coe_le_coe]
 #align part_enat.coe_lt_coe PartENat.coe_lt_coe
+-/
 
 #print PartENat.get_le_get /-
 @[simp]
@@ -311,30 +339,38 @@ theorem get_le_get {x y : PartENat} {hx : x.Dom} {hy : y.Dom} : x.get hx ≤ y.g
 #align part_enat.get_le_get PartENat.get_le_get
 -/
 
+#print PartENat.le_coe_iff /-
 theorem le_coe_iff (x : PartENat) (n : ℕ) : x ≤ n ↔ ∃ h : x.Dom, x.get h ≤ n :=
   by
   rw [← some_eq_coe]
   show (∃ h : True → x.dom, _) ↔ ∃ h : x.dom, x.get h ≤ n
   simp only [forall_prop_of_true, some_eq_coe, dom_coe, get_coe']
 #align part_enat.le_coe_iff PartENat.le_coe_iff
+-/
 
+#print PartENat.lt_coe_iff /-
 theorem lt_coe_iff (x : PartENat) (n : ℕ) : x < n ↔ ∃ h : x.Dom, x.get h < n := by
   simp only [lt_def, forall_prop_of_true, get_coe', dom_coe]
 #align part_enat.lt_coe_iff PartENat.lt_coe_iff
+-/
 
+#print PartENat.coe_le_iff /-
 theorem coe_le_iff (n : ℕ) (x : PartENat) : (n : PartENat) ≤ x ↔ ∀ h : x.Dom, n ≤ x.get h :=
   by
   rw [← some_eq_coe]
   simp only [le_def, exists_prop_of_true, dom_some, forall_true_iff]
   rfl
 #align part_enat.coe_le_iff PartENat.coe_le_iff
+-/
 
+#print PartENat.coe_lt_iff /-
 theorem coe_lt_iff (n : ℕ) (x : PartENat) : (n : PartENat) < x ↔ ∀ h : x.Dom, n < x.get h :=
   by
   rw [← some_eq_coe]
   simp only [lt_def, exists_prop_of_true, dom_some, forall_true_iff]
   rfl
 #align part_enat.coe_lt_iff PartENat.coe_lt_iff
+-/
 
 #print PartENat.NeZero.one /-
 instance NeZero.one : NeZero (1 : PartENat) :=
@@ -391,23 +427,31 @@ theorem top_eq_none : (⊤ : PartENat) = none :=
 #align part_enat.top_eq_none PartENat.top_eq_none
 -/
 
+#print PartENat.natCast_lt_top /-
 @[simp]
 theorem natCast_lt_top (x : ℕ) : (x : PartENat) < ⊤ :=
   Ne.lt_top fun h => absurd (congr_arg Dom h) <| by simpa only [dom_coe] using true_ne_false
 #align part_enat.coe_lt_top PartENat.natCast_lt_top
+-/
 
+#print PartENat.natCast_ne_top /-
 @[simp]
 theorem natCast_ne_top (x : ℕ) : (x : PartENat) ≠ ⊤ :=
   ne_of_lt (natCast_lt_top x)
 #align part_enat.coe_ne_top PartENat.natCast_ne_top
+-/
 
+#print PartENat.not_isMax_natCast /-
 theorem not_isMax_natCast (x : ℕ) : ¬IsMax (x : PartENat) :=
   not_isMax_of_lt (natCast_lt_top x)
 #align part_enat.not_is_max_coe PartENat.not_isMax_natCast
+-/
 
+#print PartENat.ne_top_iff /-
 theorem ne_top_iff {x : PartENat} : x ≠ ⊤ ↔ ∃ n : ℕ, x = n := by
   simpa only [← some_eq_coe] using Part.ne_none_iff
 #align part_enat.ne_top_iff PartENat.ne_top_iff
+-/
 
 #print PartENat.ne_top_iff_dom /-
 theorem ne_top_iff_dom {x : PartENat} : x ≠ ⊤ ↔ x.Dom := by
@@ -427,17 +471,21 @@ theorem ne_top_of_lt {x y : PartENat} (h : x < y) : x ≠ ⊤ :=
 #align part_enat.ne_top_of_lt PartENat.ne_top_of_lt
 -/
 
+#print PartENat.eq_top_iff_forall_lt /-
 theorem eq_top_iff_forall_lt (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : PartENat) < x :=
   by
   constructor
   · rintro rfl n; exact coe_lt_top _
   · contrapose!; rw [ne_top_iff]; rintro ⟨n, rfl⟩; exact ⟨n, irrefl _⟩
 #align part_enat.eq_top_iff_forall_lt PartENat.eq_top_iff_forall_lt
+-/
 
+#print PartENat.eq_top_iff_forall_le /-
 theorem eq_top_iff_forall_le (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : PartENat) ≤ x :=
   (eq_top_iff_forall_lt x).trans
     ⟨fun h n => (h n).le, fun h n => lt_of_lt_of_le (coe_lt_coe.mpr n.lt_succ_self) (h (n + 1))⟩
 #align part_enat.eq_top_iff_forall_le PartENat.eq_top_iff_forall_le
+-/
 
 #print PartENat.pos_iff_one_le /-
 theorem pos_iff_one_le {x : PartENat} : 0 < x ↔ 1 ≤ x :=
@@ -489,6 +537,7 @@ instance : CanonicallyOrderedAddMonoid PartENat :=
           ⟨(b - a : ℕ), by
             rw [← Nat.cast_add, coe_inj, add_comm, tsub_add_cancel_of_le (coe_le_coe.1 h)]⟩ }
 
+#print PartENat.eq_natCast_sub_of_add_eq_natCast /-
 theorem eq_natCast_sub_of_add_eq_natCast {x y : PartENat} {n : ℕ} (h : x + y = n) :
     x = ↑(n - y.get (dom_of_le_natCast ((le_add_left le_rfl).trans_eq h))) :=
   by
@@ -497,6 +546,7 @@ theorem eq_natCast_sub_of_add_eq_natCast {x y : PartENat} {n : ℕ} (h : x + y =
   rw [← Nat.cast_add, coe_inj] at h 
   rw [get_coe, coe_inj, eq_tsub_of_add_eq h]
 #align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_natCast_sub_of_add_eq_natCast
+-/
 
 #print PartENat.add_lt_add_right /-
 protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ ⊤) : x + z < y + z :=
@@ -637,26 +687,34 @@ theorem toWithTop_some (n : ℕ) : toWithTop (some n) = n :=
 #align part_enat.to_with_top_some PartENat.toWithTop_some
 -/
 
+#print PartENat.toWithTop_natCast /-
 theorem toWithTop_natCast (n : ℕ) {_ : Decidable (n : PartENat).Dom} : toWithTop n = n := by
   simp only [← some_eq_coe, ← to_with_top_some]
 #align part_enat.to_with_top_coe PartENat.toWithTop_natCast
+-/
 
+#print PartENat.toWithTop_natCast' /-
 @[simp]
 theorem toWithTop_natCast' (n : ℕ) {h : Decidable (n : PartENat).Dom} :
     toWithTop (n : PartENat) = n := by convert to_with_top_coe n
 #align part_enat.to_with_top_coe' PartENat.toWithTop_natCast'
+-/
 
+#print PartENat.toWithTop_le /-
 @[simp]
 theorem toWithTop_le {x y : PartENat} :
     ∀ [Decidable x.Dom] [Decidable y.Dom], to_with_top x ≤ to_with_top y ↔ x ≤ y :=
   PartENat.casesOn y (by simp) (PartENat.casesOn x (by simp) (by intros <;> simp))
 #align part_enat.to_with_top_le PartENat.toWithTop_le
+-/
 
+#print PartENat.toWithTop_lt /-
 @[simp]
 theorem toWithTop_lt {x y : PartENat} [Decidable x.Dom] [Decidable y.Dom] :
     toWithTop x < toWithTop y ↔ x < y :=
   lt_iff_lt_of_le_iff_le toWithTop_le
 #align part_enat.to_with_top_lt PartENat.toWithTop_lt
+-/
 
 end WithTop
 
@@ -664,10 +722,12 @@ section WithTopEquiv
 
 open scoped Classical
 
+#print PartENat.toWithTop_add /-
 @[simp]
 theorem toWithTop_add {x y : PartENat} : toWithTop (x + y) = toWithTop x + toWithTop y := by
   apply PartENat.casesOn y <;> apply PartENat.casesOn x <;> simp [← Nat.cast_add, ← ENat.coe_add]
 #align part_enat.to_with_top_add PartENat.toWithTop_add
+-/
 
 #print PartENat.withTopEquiv /-
 /-- `equiv` between `part_enat` and `ℕ∞` (for the order isomorphism see
@@ -705,20 +765,26 @@ theorem withTopEquiv_zero : withTopEquiv 0 = 0 := by
 #align part_enat.with_top_equiv_zero PartENat.withTopEquiv_zero
 -/
 
+#print PartENat.withTopEquiv_le /-
 @[simp]
 theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔ x ≤ y :=
   toWithTop_le
 #align part_enat.with_top_equiv_le PartENat.withTopEquiv_le
+-/
 
+#print PartENat.withTopEquiv_lt /-
 @[simp]
 theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x < y :=
   toWithTop_lt
 #align part_enat.with_top_equiv_lt PartENat.withTopEquiv_lt
+-/
 
+#print PartENat.withTopOrderIso /-
 /-- `to_with_top` induces an order isomorphism between `part_enat` and `ℕ∞`. -/
 noncomputable def withTopOrderIso : PartENat ≃o ℕ∞ :=
   { withTopEquiv with map_rel_iff' := fun _ _ => withTopEquiv_le }
 #align part_enat.with_top_order_iso PartENat.withTopOrderIso
+-/
 
 #print PartENat.withTopEquiv_symm_top /-
 @[simp]
@@ -755,11 +821,13 @@ theorem withTopEquiv_symm_lt {x y : ℕ∞} : withTopEquiv.symm x < withTopEquiv
 #align part_enat.with_top_equiv_symm_lt PartENat.withTopEquiv_symm_lt
 -/
 
+#print PartENat.withTopAddEquiv /-
 /-- `to_with_top` induces an additive monoid isomorphism between `part_enat` and `ℕ∞`. -/
 noncomputable def withTopAddEquiv : PartENat ≃+ ℕ∞ :=
   { withTopEquiv with
     map_add' := fun x y => by simp only [with_top_equiv] <;> convert to_with_top_add }
 #align part_enat.with_top_add_equiv PartENat.withTopAddEquiv
+-/
 
 end WithTopEquiv
 
@@ -804,6 +872,7 @@ theorem find_dom (h : ∃ n, P n) : (find P).Dom :=
 #align part_enat.find_dom PartENat.find_dom
 -/
 
+#print PartENat.lt_find /-
 theorem lt_find (n : ℕ) (h : ∀ m ≤ n, ¬P m) : (n : PartENat) < find P :=
   by
   rw [coe_lt_iff]; intro h'; rw [find_get]
@@ -811,7 +880,9 @@ theorem lt_find (n : ℕ) (h : ∀ m ≤ n, ¬P m) : (n : PartENat) < find P :=
   contrapose! this
   exact h _ this
 #align part_enat.lt_find PartENat.lt_find
+-/
 
+#print PartENat.lt_find_iff /-
 theorem lt_find_iff (n : ℕ) : (n : PartENat) < find P ↔ ∀ m ≤ n, ¬P m :=
   by
   refine' ⟨_, lt_find P n⟩
@@ -820,10 +891,13 @@ theorem lt_find_iff (n : ℕ) : (n : PartENat) < find P ↔ ∀ m ≤ n, ¬P m :
   · apply Nat.find_min H; rw [coe_lt_iff] at h ; specialize h H; exact lt_of_le_of_lt hm h
   · exact not_exists.mp H m
 #align part_enat.lt_find_iff PartENat.lt_find_iff
+-/
 
+#print PartENat.find_le /-
 theorem find_le (n : ℕ) (h : P n) : find P ≤ n := by rw [le_coe_iff];
   refine' ⟨⟨_, h⟩, @Nat.find_min' P _ _ _ h⟩
 #align part_enat.find_le PartENat.find_le
+-/
 
 #print PartENat.find_eq_top_iff /-
 theorem find_eq_top_iff : find P = ⊤ ↔ ∀ n, ¬P n :=

114ff8a4

bump to nightly-2023-06-04-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

3fb4268b

Diff

@@ -505,7 +505,7 @@ protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ 
   rcases ne_top_iff.mp hz with ⟨k, rfl⟩
   induction' y using PartENat.casesOn with n
   · rw [top_add]; apply_mod_cast coe_lt_top
-  norm_cast  at h ; apply_mod_cast add_lt_add_right h
+  norm_cast at h ; apply_mod_cast add_lt_add_right h
 #align part_enat.add_lt_add_right PartENat.add_lt_add_right
 -/
 
@@ -766,9 +766,9 @@ end WithTopEquiv
 #print PartENat.lt_wf /-
 theorem lt_wf : @WellFounded PartENat (· < ·) := by
   classical
-    change WellFounded fun a b : PartENat => a < b
-    simp_rw [← to_with_top_lt]
-    exact InvImage.wf _ (WithTop.wellFounded_lt Nat.lt_wfRel)
+  change WellFounded fun a b : PartENat => a < b
+  simp_rw [← to_with_top_lt]
+  exact InvImage.wf _ (WithTop.wellFounded_lt Nat.lt_wfRel)
 #align part_enat.lt_wf PartENat.lt_wf
 -/

114ff8a4

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -193,7 +193,7 @@ theorem get_natCast {x : ℕ} : get (x : PartENat) (dom_natCast x) = x :=
 #align part_enat.get_coe PartENat.get_natCast
 
 theorem coe_add_get {x : ℕ} {y : PartENat} (h : ((x : PartENat) + y).Dom) :
-    get ((x : PartENat) + y) h = x + get y h.2 := by simp only [← some_eq_coe] at h⊢; rfl
+    get ((x : PartENat) + y) h = x + get y h.2 := by simp only [← some_eq_coe] at h ⊢; rfl
 #align part_enat.coe_add_get PartENat.coe_add_get
 
 #print PartENat.get_add /-
@@ -238,7 +238,7 @@ theorem dom_of_le_some {x : PartENat} {y : ℕ} (h : x ≤ some y) : x.Dom :=
 #align part_enat.dom_of_le_some PartENat.dom_of_le_some
 -/
 
-theorem dom_of_le_natCast {x : PartENat} {y : ℕ} (h : x ≤ y) : x.Dom := by rw [← some_eq_coe] at h;
+theorem dom_of_le_natCast {x : PartENat} {y : ℕ} (h : x ≤ y) : x.Dom := by rw [← some_eq_coe] at h ;
   exact dom_of_le_some h
 #align part_enat.dom_of_le_coe PartENat.dom_of_le_natCast
 
@@ -282,10 +282,10 @@ theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.ge
     by_cases hx : x.dom
     · use hx; intro hy
       specialize H hy; specialize h fun _ => hy
-      rw [not_forall] at h; cases' h with hx' h
-      rw [not_le] at h; exact h
+      rw [not_forall] at h ; cases' h with hx' h
+      rw [not_le] at h ; exact h
     · specialize h fun hx' => (hx hx').elim
-      rw [not_forall] at h; cases' h with hx' h
+      rw [not_forall] at h ; cases' h with hx' h
       exact (hx hx').elim
   · rintro ⟨hx, H⟩;
     exact ⟨⟨fun _ => hx, fun hy => (H hy).le⟩, fun hxy h => not_lt_of_le (h _) (H _)⟩
@@ -494,7 +494,7 @@ theorem eq_natCast_sub_of_add_eq_natCast {x y : PartENat} {n : ℕ} (h : x + y =
   by
   lift x to ℕ using dom_of_le_coe ((le_add_right le_rfl).trans_eq h)
   lift y to ℕ using dom_of_le_coe ((le_add_left le_rfl).trans_eq h)
-  rw [← Nat.cast_add, coe_inj] at h
+  rw [← Nat.cast_add, coe_inj] at h 
   rw [get_coe, coe_inj, eq_tsub_of_add_eq h]
 #align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_natCast_sub_of_add_eq_natCast
 
@@ -505,7 +505,7 @@ protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ 
   rcases ne_top_iff.mp hz with ⟨k, rfl⟩
   induction' y using PartENat.casesOn with n
   · rw [top_add]; apply_mod_cast coe_lt_top
-  norm_cast  at h; apply_mod_cast add_lt_add_right h
+  norm_cast  at h ; apply_mod_cast add_lt_add_right h
 #align part_enat.add_lt_add_right PartENat.add_lt_add_right
 -/
 
@@ -817,7 +817,7 @@ theorem lt_find_iff (n : ℕ) : (n : PartENat) < find P ↔ ∀ m ≤ n, ¬P m :
   refine' ⟨_, lt_find P n⟩
   intro h m hm
   by_cases H : (find P).Dom
-  · apply Nat.find_min H; rw [coe_lt_iff] at h; specialize h H; exact lt_of_le_of_lt hm h
+  · apply Nat.find_min H; rw [coe_lt_iff] at h ; specialize h H; exact lt_of_le_of_lt hm h
   · exact not_exists.mp H m
 #align part_enat.lt_find_iff PartENat.lt_find_iff

114ff8a4

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -273,6 +273,7 @@ instance : PartialOrder PartENat where
   le_antisymm := fun x y ⟨hxy₁, hxy₂⟩ ⟨hyx₁, hyx₂⟩ =>
     Part.ext' ⟨hyx₁, hxy₁⟩ fun _ _ => le_antisymm (hxy₂ _) (hyx₂ _)
 
+#print PartENat.lt_def /-
 theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.get hx < y.get hy :=
   by
   rw [lt_iff_le_not_le, le_def, le_def, not_exists]
@@ -289,6 +290,7 @@ theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.ge
   · rintro ⟨hx, H⟩;
     exact ⟨⟨fun _ => hx, fun hy => (H hy).le⟩, fun hxy h => not_lt_of_le (h _) (H _)⟩
 #align part_enat.lt_def PartENat.lt_def
+-/
 
 @[simp, norm_cast]
 theorem coe_le_coe {x y : ℕ} : (x : PartENat) ≤ y ↔ x ≤ y := by rw [← some_eq_coe, ← some_eq_coe];
@@ -371,13 +373,17 @@ theorem eq_zero_iff {x : PartENat} : x = 0 ↔ x ≤ 0 :=
 #align part_enat.eq_zero_iff PartENat.eq_zero_iff
 -/
 
+#print PartENat.ne_zero_iff /-
 theorem ne_zero_iff {x : PartENat} : x ≠ 0 ↔ ⊥ < x :=
   bot_lt_iff_ne_bot.symm
 #align part_enat.ne_zero_iff PartENat.ne_zero_iff
+-/
 
+#print PartENat.dom_of_lt /-
 theorem dom_of_lt {x y : PartENat} : x < y → x.Dom :=
   PartENat.casesOn x not_top_lt fun _ _ => dom_natCast _
 #align part_enat.dom_of_lt PartENat.dom_of_lt
+-/
 
 #print PartENat.top_eq_none /-
 theorem top_eq_none : (⊤ : PartENat) = none :=
@@ -415,9 +421,11 @@ theorem not_dom_iff_eq_top {x : PartENat} : ¬x.Dom ↔ x = ⊤ :=
 #align part_enat.not_dom_iff_eq_top PartENat.not_dom_iff_eq_top
 -/
 
+#print PartENat.ne_top_of_lt /-
 theorem ne_top_of_lt {x y : PartENat} (h : x < y) : x ≠ ⊤ :=
   ne_of_lt <| lt_of_lt_of_le h le_top
 #align part_enat.ne_top_of_lt PartENat.ne_top_of_lt
+-/
 
 theorem eq_top_iff_forall_lt (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : PartENat) < x :=
   by
@@ -431,10 +439,12 @@ theorem eq_top_iff_forall_le (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : Part
     ⟨fun h n => (h n).le, fun h n => lt_of_lt_of_le (coe_lt_coe.mpr n.lt_succ_self) (h (n + 1))⟩
 #align part_enat.eq_top_iff_forall_le PartENat.eq_top_iff_forall_le
 
+#print PartENat.pos_iff_one_le /-
 theorem pos_iff_one_le {x : PartENat} : 0 < x ↔ 1 ≤ x :=
   PartENat.casesOn x (by simp only [iff_true_iff, le_top, coe_lt_top, ← @Nat.cast_zero PartENat])
     fun n => by rw [← Nat.cast_zero, ← Nat.cast_one, PartENat.coe_lt_coe, PartENat.coe_le_coe]; rfl
 #align part_enat.pos_iff_one_le PartENat.pos_iff_one_le
+-/
 
 instance : IsTotal PartENat (· ≤ ·)
     where Total x y :=
@@ -488,6 +498,7 @@ theorem eq_natCast_sub_of_add_eq_natCast {x y : PartENat} {n : ℕ} (h : x + y =
   rw [get_coe, coe_inj, eq_tsub_of_add_eq h]
 #align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_natCast_sub_of_add_eq_natCast
 
+#print PartENat.add_lt_add_right /-
 protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ ⊤) : x + z < y + z :=
   by
   rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
@@ -496,37 +507,51 @@ protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ 
   · rw [top_add]; apply_mod_cast coe_lt_top
   norm_cast  at h; apply_mod_cast add_lt_add_right h
 #align part_enat.add_lt_add_right PartENat.add_lt_add_right
+-/
 
+#print PartENat.add_lt_add_iff_right /-
 protected theorem add_lt_add_iff_right {x y z : PartENat} (hz : z ≠ ⊤) : x + z < y + z ↔ x < y :=
   ⟨lt_of_add_lt_add_right, fun h => PartENat.add_lt_add_right h hz⟩
 #align part_enat.add_lt_add_iff_right PartENat.add_lt_add_iff_right
+-/
 
+#print PartENat.add_lt_add_iff_left /-
 protected theorem add_lt_add_iff_left {x y z : PartENat} (hz : z ≠ ⊤) : z + x < z + y ↔ x < y := by
   rw [add_comm z, add_comm z, PartENat.add_lt_add_iff_right hz]
 #align part_enat.add_lt_add_iff_left PartENat.add_lt_add_iff_left
+-/
 
+#print PartENat.lt_add_iff_pos_right /-
 protected theorem lt_add_iff_pos_right {x y : PartENat} (hx : x ≠ ⊤) : x < x + y ↔ 0 < y := by
   conv_rhs => rw [← PartENat.add_lt_add_iff_left hx]; rw [add_zero]
 #align part_enat.lt_add_iff_pos_right PartENat.lt_add_iff_pos_right
+-/
 
+#print PartENat.lt_add_one /-
 theorem lt_add_one {x : PartENat} (hx : x ≠ ⊤) : x < x + 1 := by
   rw [PartENat.lt_add_iff_pos_right hx]; norm_cast; norm_num
 #align part_enat.lt_add_one PartENat.lt_add_one
+-/
 
+#print PartENat.le_of_lt_add_one /-
 theorem le_of_lt_add_one {x y : PartENat} (h : x < y + 1) : x ≤ y :=
   by
   induction' y using PartENat.casesOn with n; apply le_top
   rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
   apply_mod_cast Nat.le_of_lt_succ; apply_mod_cast h
 #align part_enat.le_of_lt_add_one PartENat.le_of_lt_add_one
+-/
 
+#print PartENat.add_one_le_of_lt /-
 theorem add_one_le_of_lt {x y : PartENat} (h : x < y) : x + 1 ≤ y :=
   by
   induction' y using PartENat.casesOn with n; apply le_top
   rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
   apply_mod_cast Nat.succ_le_of_lt; apply_mod_cast h
 #align part_enat.add_one_le_of_lt PartENat.add_one_le_of_lt
+-/
 
+#print PartENat.add_one_le_iff_lt /-
 theorem add_one_le_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x + 1 ≤ y ↔ x < y :=
   by
   constructor; swap; exact add_one_le_of_lt
@@ -534,7 +559,9 @@ theorem add_one_le_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x + 1 ≤ y ↔ x
   induction' y using PartENat.casesOn with n; apply coe_lt_top
   apply_mod_cast Nat.lt_of_succ_le; apply_mod_cast h
 #align part_enat.add_one_le_iff_lt PartENat.add_one_le_iff_lt
+-/
 
+#print PartENat.lt_add_one_iff_lt /-
 theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x ≤ y :=
   by
   constructor; exact le_of_lt_add_one
@@ -542,6 +569,7 @@ theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x 
   induction' y using PartENat.casesOn with n; · rw [top_add]; apply coe_lt_top
   apply_mod_cast Nat.lt_succ_of_le; apply_mod_cast h
 #align part_enat.lt_add_one_iff_lt PartENat.lt_add_one_iff_lt
+-/
 
 #print PartENat.add_eq_top_iff /-
 theorem add_eq_top_iff {a b : PartENat} : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ := by
@@ -634,7 +662,7 @@ end WithTop
 
 section WithTopEquiv
 
-open Classical
+open scoped Classical
 
 @[simp]
 theorem toWithTop_add {x y : PartENat} : toWithTop (x + y) = toWithTop x + toWithTop y := by
@@ -720,10 +748,12 @@ theorem withTopEquiv_symm_le {x y : ℕ∞} : withTopEquiv.symm x ≤ withTopEqu
 #align part_enat.with_top_equiv_symm_le PartENat.withTopEquiv_symm_le
 -/
 
+#print PartENat.withTopEquiv_symm_lt /-
 @[simp]
 theorem withTopEquiv_symm_lt {x y : ℕ∞} : withTopEquiv.symm x < withTopEquiv.symm y ↔ x < y := by
   rw [← with_top_equiv_lt] <;> simp
 #align part_enat.with_top_equiv_symm_lt PartENat.withTopEquiv_symm_lt
+-/
 
 /-- `to_with_top` induces an additive monoid isomorphism between `part_enat` and `ℕ∞`. -/
 noncomputable def withTopAddEquiv : PartENat ≃+ ℕ∞ :=
@@ -733,12 +763,14 @@ noncomputable def withTopAddEquiv : PartENat ≃+ ℕ∞ :=
 
 end WithTopEquiv
 
+#print PartENat.lt_wf /-
 theorem lt_wf : @WellFounded PartENat (· < ·) := by
   classical
     change WellFounded fun a b : PartENat => a < b
     simp_rw [← to_with_top_lt]
     exact InvImage.wf _ (WithTop.wellFounded_lt Nat.lt_wfRel)
 #align part_enat.lt_wf PartENat.lt_wf
+-/
 
 instance : WellFoundedLT PartENat :=
   ⟨lt_wf⟩

114ff8a4

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -116,33 +116,15 @@ instance : AddCommMonoidWithOne PartENat :=
     natCast_zero := rfl
     natCast_succ := fun _ => Part.ext' (true_and_iff _).symm fun _ _ => rfl }
 
-/- warning: part_enat.some_eq_coe -> PartENat.some_eq_natCast is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat), Eq.{1} PartENat (PartENat.some n) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n)
-but is expected to have type
-  forall (n : Nat), Eq.{1} PartENat (PartENat.some n) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n)
-Case conversion may be inaccurate. Consider using '#align part_enat.some_eq_coe PartENat.some_eq_natCastₓ'. -/
 theorem some_eq_natCast (n : ℕ) : some n = n :=
   rfl
 #align part_enat.some_eq_coe PartENat.some_eq_natCast
 
-/- warning: part_enat.coe_inj -> PartENat.natCast_inj is a dubious translation:
-lean 3 declaration is
-  forall {x : Nat} {y : Nat}, Iff (Eq.{1} PartENat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) y)) (Eq.{1} Nat x y)
-but is expected to have type
-  forall {x : Nat} {y : Nat}, Iff (Eq.{1} PartENat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) y)) (Eq.{1} Nat x y)
-Case conversion may be inaccurate. Consider using '#align part_enat.coe_inj PartENat.natCast_injₓ'. -/
 @[simp, norm_cast]
 theorem natCast_inj {x y : ℕ} : (x : PartENat) = y ↔ x = y :=
   Part.some_inj
 #align part_enat.coe_inj PartENat.natCast_inj
 
-/- warning: part_enat.dom_coe -> PartENat.dom_natCast is a dubious translation:
-lean 3 declaration is
-  forall (x : Nat), Part.Dom.{0} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x)
-but is expected to have type
-  forall (x : Nat), Part.Dom.{0} Nat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x)
-Case conversion may be inaccurate. Consider using '#align part_enat.dom_coe PartENat.dom_natCastₓ'. -/
 @[simp]
 theorem dom_natCast (x : ℕ) : (x : PartENat).Dom :=
   trivial
@@ -178,12 +160,6 @@ protected theorem casesOn' {P : PartENat → Prop} :
 #align part_enat.cases_on' PartENat.casesOn'
 -/
 
-/- warning: part_enat.cases_on -> PartENat.casesOn is a dubious translation:
-lean 3 declaration is
-  forall {P : PartENat -> Prop} (a : PartENat), (P (Top.top.{0} PartENat PartENat.hasTop)) -> (forall (n : Nat), P ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n)) -> (P a)
-but is expected to have type
-  forall {P : PartENat -> Prop} (a : PartENat), (P (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (forall (n : Nat), P (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n)) -> (P a)
-Case conversion may be inaccurate. Consider using '#align part_enat.cases_on PartENat.casesOnₓ'. -/
 @[elab_as_elim]
 protected theorem casesOn {P : PartENat → Prop} : ∀ a : PartENat, P ⊤ → (∀ n : ℕ, P n) → P a := by
   simp only [← some_eq_coe]; exact PartENat.casesOn'
@@ -202,44 +178,20 @@ theorem add_top (x : PartENat) : x + ⊤ = ⊤ := by rw [add_comm, top_add]
 #align part_enat.add_top PartENat.add_top
 -/
 
-/- warning: part_enat.coe_get -> PartENat.natCast_get is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} (h : Part.Dom.{0} Nat x), Eq.{1} PartENat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) (Part.get.{0} Nat x h)) x
-but is expected to have type
-  forall {x : PartENat} (h : Part.Dom.{0} Nat x), Eq.{1} PartENat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) (Part.get.{0} Nat x h)) x
-Case conversion may be inaccurate. Consider using '#align part_enat.coe_get PartENat.natCast_getₓ'. -/
 @[simp]
 theorem natCast_get {x : PartENat} (h : x.Dom) : (x.get h : PartENat) = x := by rw [← some_eq_coe];
   exact Part.ext' (iff_of_true trivial h) fun _ _ => rfl
 #align part_enat.coe_get PartENat.natCast_get
 
-/- warning: part_enat.get_coe' -> PartENat.get_natCast' is a dubious translation:
-lean 3 declaration is
-  forall (x : Nat) (h : Part.Dom.{0} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x)), Eq.{1} Nat (Part.get.{0} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) h) x
-but is expected to have type
-  forall (x : Nat) (h : Part.Dom.{0} Nat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x)), Eq.{1} Nat (Part.get.{0} Nat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) h) x
-Case conversion may be inaccurate. Consider using '#align part_enat.get_coe' PartENat.get_natCast'ₓ'. -/
 @[simp, norm_cast]
 theorem get_natCast' (x : ℕ) (h : (x : PartENat).Dom) : get (x : PartENat) h = x := by
   rw [← coe_inj, coe_get]
 #align part_enat.get_coe' PartENat.get_natCast'
 
-/- warning: part_enat.get_coe -> PartENat.get_natCast is a dubious translation:
-lean 3 declaration is
-  forall {x : Nat}, Eq.{1} Nat (Part.get.{0} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) (PartENat.dom_natCast x)) x
-but is expected to have type
-  forall {x : Nat}, Eq.{1} Nat (Part.get.{0} Nat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) (PartENat.dom_natCast x)) x
-Case conversion may be inaccurate. Consider using '#align part_enat.get_coe PartENat.get_natCastₓ'. -/
 theorem get_natCast {x : ℕ} : get (x : PartENat) (dom_natCast x) = x :=
   get_natCast' _ _
 #align part_enat.get_coe PartENat.get_natCast
 
-/- warning: part_enat.coe_add_get -> PartENat.coe_add_get is a dubious translation:
-lean 3 declaration is
-  forall {x : Nat} {y : PartENat} (h : Part.Dom.{0} Nat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) y)), Eq.{1} Nat (Part.get.{0} Nat (HAdd.hAdd.{0, 0, 0} (Part.{0} Nat) (Part.{0} Nat) (Part.{0} Nat) (instHAdd.{0} (Part.{0} Nat) PartENat.hasAdd) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) y) h) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) x (Part.get.{0} Nat y (And.right (Part.Dom.{0} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x)) (Part.Dom.{0} Nat y) h)))
-but is expected to have type
-  forall {x : Nat} {y : PartENat} (h : Part.Dom.{0} Nat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) y)), Eq.{1} Nat (Part.get.{0} Nat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) y) h) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) x (Part.get.{0} Nat y (And.right (Part.Dom.{0} Nat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x)) (Part.Dom.{0} Nat y) h)))
-Case conversion may be inaccurate. Consider using '#align part_enat.coe_add_get PartENat.coe_add_getₓ'. -/
 theorem coe_add_get {x : ℕ} {y : PartENat} (h : ((x : PartENat) + y).Dom) :
     get ((x : PartENat) + y) h = x + get y h.2 := by simp only [← some_eq_coe] at h⊢; rfl
 #align part_enat.coe_add_get PartENat.coe_add_get
@@ -271,12 +223,6 @@ theorem get_eq_iff_eq_some {a : PartENat} {ha : a.Dom} {b : ℕ} : a.get ha = b
 #align part_enat.get_eq_iff_eq_some PartENat.get_eq_iff_eq_some
 -/
 
-/- warning: part_enat.get_eq_iff_eq_coe -> PartENat.get_eq_iff_eq_coe is a dubious translation:
-lean 3 declaration is
-  forall {a : PartENat} {ha : Part.Dom.{0} Nat a} {b : Nat}, Iff (Eq.{1} Nat (Part.get.{0} Nat a ha) b) (Eq.{1} PartENat a ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) b))
-but is expected to have type
-  forall {a : PartENat} {ha : Part.Dom.{0} Nat a} {b : Nat}, Iff (Eq.{1} Nat (Part.get.{0} Nat a ha) b) (Eq.{1} PartENat a (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) b))
-Case conversion may be inaccurate. Consider using '#align part_enat.get_eq_iff_eq_coe PartENat.get_eq_iff_eq_coeₓ'. -/
 theorem get_eq_iff_eq_coe {a : PartENat} {ha : a.Dom} {b : ℕ} : a.get ha = b ↔ a = b := by
   rw [get_eq_iff_eq_some, some_eq_coe]
 #align part_enat.get_eq_iff_eq_coe PartENat.get_eq_iff_eq_coe
@@ -292,12 +238,6 @@ theorem dom_of_le_some {x : PartENat} {y : ℕ} (h : x ≤ some y) : x.Dom :=
 #align part_enat.dom_of_le_some PartENat.dom_of_le_some
 -/
 
-/- warning: part_enat.dom_of_le_coe -> PartENat.dom_of_le_natCast is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : Nat}, (LE.le.{0} PartENat PartENat.hasLe x ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) y)) -> (Part.Dom.{0} Nat x)
-but is expected to have type
-  forall {x : PartENat} {y : Nat}, (LE.le.{0} PartENat PartENat.instLEPartENat x (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) y)) -> (Part.Dom.{0} Nat x)
-Case conversion may be inaccurate. Consider using '#align part_enat.dom_of_le_coe PartENat.dom_of_le_natCastₓ'. -/
 theorem dom_of_le_natCast {x : PartENat} {y : ℕ} (h : x ≤ y) : x.Dom := by rw [← some_eq_coe] at h;
   exact dom_of_le_some h
 #align part_enat.dom_of_le_coe PartENat.dom_of_le_natCast
@@ -315,23 +255,11 @@ instance decidableLe (x y : PartENat) [Decidable x.Dom] [Decidable y.Dom] : Deci
 #align part_enat.decidable_le PartENat.decidableLe
 -/
 
-/- warning: part_enat.coe_hom -> PartENat.natCast_AddMonoidHom is a dubious translation:
-lean 3 declaration is
-  AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne)))
-but is expected to have type
-  AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))
-Case conversion may be inaccurate. Consider using '#align part_enat.coe_hom PartENat.natCast_AddMonoidHomₓ'. -/
 /-- The coercion `ℕ → part_enat` preserves `0` and addition. -/
 def natCast_AddMonoidHom : ℕ →+ PartENat :=
   ⟨coe, Nat.cast_zero, Nat.cast_add⟩
 #align part_enat.coe_hom PartENat.natCast_AddMonoidHom
 
-/- warning: part_enat.coe_coe_hom -> PartENat.coe_coeHom is a dubious translation:
-lean 3 declaration is
-  Eq.{1} (Nat -> PartENat) (coeFn.{1, 1} (AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne)))) (fun (_x : AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne)))) => Nat -> PartENat) (AddMonoidHom.hasCoeToFun.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne)))) PartENat.natCast_AddMonoidHom) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))))
-but is expected to have type
-  Eq.{1} (forall (ᾰ : Nat), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : Nat) => PartENat) ᾰ) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : Nat) => PartENat) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) Nat PartENat (AddZeroClass.toAdd.{0} Nat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (AddZeroClass.toAdd.{0} PartENat (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat))) (AddMonoidHom.addMonoidHomClass.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))))) PartENat.natCast_AddMonoidHom) PartENat.some
-Case conversion may be inaccurate. Consider using '#align part_enat.coe_coe_hom PartENat.coe_coeHomₓ'. -/
 @[simp]
 theorem coe_coeHom : ⇑natCast_AddMonoidHom = coe :=
   rfl
@@ -345,12 +273,6 @@ instance : PartialOrder PartENat where
   le_antisymm := fun x y ⟨hxy₁, hxy₂⟩ ⟨hyx₁, hyx₂⟩ =>
     Part.ext' ⟨hyx₁, hxy₁⟩ fun _ _ => le_antisymm (hxy₂ _) (hyx₂ _)
 
-/- warning: part_enat.lt_def -> PartENat.lt_def is a dubious translation:
-lean 3 declaration is
-  forall (x : PartENat) (y : PartENat), Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) (Exists.{0} (Part.Dom.{0} Nat x) (fun (hx : Part.Dom.{0} Nat x) => forall (hy : Part.Dom.{0} Nat y), LT.lt.{0} Nat Nat.hasLt (Part.get.{0} Nat x hx) (Part.get.{0} Nat y hy)))
-but is expected to have type
-  forall (x : PartENat) (y : PartENat), Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) (Exists.{0} (Part.Dom.{0} Nat x) (fun (hx : Part.Dom.{0} Nat x) => forall (hy : Part.Dom.{0} Nat y), LT.lt.{0} Nat instLTNat (Part.get.{0} Nat x hx) (Part.get.{0} Nat y hy)))
-Case conversion may be inaccurate. Consider using '#align part_enat.lt_def PartENat.lt_defₓ'. -/
 theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.get hx < y.get hy :=
   by
   rw [lt_iff_le_not_le, le_def, le_def, not_exists]
@@ -368,23 +290,11 @@ theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.ge
     exact ⟨⟨fun _ => hx, fun hy => (H hy).le⟩, fun hxy h => not_lt_of_le (h _) (H _)⟩
 #align part_enat.lt_def PartENat.lt_def
 
-/- warning: part_enat.coe_le_coe -> PartENat.coe_le_coe is a dubious translation:
-lean 3 declaration is
-  forall {x : Nat} {y : Nat}, Iff (LE.le.{0} PartENat PartENat.hasLe ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) y)) (LE.le.{0} Nat Nat.hasLe x y)
-but is expected to have type
-  forall {x : Nat} {y : Nat}, Iff (LE.le.{0} PartENat PartENat.instLEPartENat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) y)) (LE.le.{0} Nat instLENat x y)
-Case conversion may be inaccurate. Consider using '#align part_enat.coe_le_coe PartENat.coe_le_coeₓ'. -/
 @[simp, norm_cast]
 theorem coe_le_coe {x y : ℕ} : (x : PartENat) ≤ y ↔ x ≤ y := by rw [← some_eq_coe, ← some_eq_coe];
   exact ⟨fun ⟨_, h⟩ => h trivial, fun h => ⟨fun _ => trivial, fun _ => h⟩⟩
 #align part_enat.coe_le_coe PartENat.coe_le_coe
 
-/- warning: part_enat.coe_lt_coe -> PartENat.coe_lt_coe is a dubious translation:
-lean 3 declaration is
-  forall {x : Nat} {y : Nat}, Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) y)) (LT.lt.{0} Nat Nat.hasLt x y)
-but is expected to have type
-  forall {x : Nat} {y : Nat}, Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) y)) (LT.lt.{0} Nat instLTNat x y)
-Case conversion may be inaccurate. Consider using '#align part_enat.coe_lt_coe PartENat.coe_lt_coeₓ'. -/
 @[simp, norm_cast]
 theorem coe_lt_coe {x y : ℕ} : (x : PartENat) < y ↔ x < y := by
   rw [lt_iff_le_not_le, lt_iff_le_not_le, coe_le_coe, coe_le_coe]
@@ -399,12 +309,6 @@ theorem get_le_get {x y : PartENat} {hx : x.Dom} {hy : y.Dom} : x.get hx ≤ y.g
 #align part_enat.get_le_get PartENat.get_le_get
 -/
 
-/- warning: part_enat.le_coe_iff -> PartENat.le_coe_iff is a dubious translation:
-lean 3 declaration is
-  forall (x : PartENat) (n : Nat), Iff (LE.le.{0} PartENat PartENat.hasLe x ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n)) (Exists.{0} (Part.Dom.{0} Nat x) (fun (h : Part.Dom.{0} Nat x) => LE.le.{0} Nat Nat.hasLe (Part.get.{0} Nat x h) n))
-but is expected to have type
-  forall (x : PartENat) (n : Nat), Iff (LE.le.{0} PartENat PartENat.instLEPartENat x (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n)) (Exists.{0} (Part.Dom.{0} Nat x) (fun (h : Part.Dom.{0} Nat x) => LE.le.{0} Nat instLENat (Part.get.{0} Nat x h) n))
-Case conversion may be inaccurate. Consider using '#align part_enat.le_coe_iff PartENat.le_coe_iffₓ'. -/
 theorem le_coe_iff (x : PartENat) (n : ℕ) : x ≤ n ↔ ∃ h : x.Dom, x.get h ≤ n :=
   by
   rw [← some_eq_coe]
@@ -412,22 +316,10 @@ theorem le_coe_iff (x : PartENat) (n : ℕ) : x ≤ n ↔ ∃ h : x.Dom, x.get h
   simp only [forall_prop_of_true, some_eq_coe, dom_coe, get_coe']
 #align part_enat.le_coe_iff PartENat.le_coe_iff
 
-/- warning: part_enat.lt_coe_iff -> PartENat.lt_coe_iff is a dubious translation:
-lean 3 declaration is
-  forall (x : PartENat) (n : Nat), Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n)) (Exists.{0} (Part.Dom.{0} Nat x) (fun (h : Part.Dom.{0} Nat x) => LT.lt.{0} Nat Nat.hasLt (Part.get.{0} Nat x h) n))
-but is expected to have type
-  forall (x : PartENat) (n : Nat), Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n)) (Exists.{0} (Part.Dom.{0} Nat x) (fun (h : Part.Dom.{0} Nat x) => LT.lt.{0} Nat instLTNat (Part.get.{0} Nat x h) n))
-Case conversion may be inaccurate. Consider using '#align part_enat.lt_coe_iff PartENat.lt_coe_iffₓ'. -/
 theorem lt_coe_iff (x : PartENat) (n : ℕ) : x < n ↔ ∃ h : x.Dom, x.get h < n := by
   simp only [lt_def, forall_prop_of_true, get_coe', dom_coe]
 #align part_enat.lt_coe_iff PartENat.lt_coe_iff
 
-/- warning: part_enat.coe_le_iff -> PartENat.coe_le_iff is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat) (x : PartENat), Iff (LE.le.{0} PartENat PartENat.hasLe ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) x) (forall (h : Part.Dom.{0} Nat x), LE.le.{0} Nat Nat.hasLe n (Part.get.{0} Nat x h))
-but is expected to have type
-  forall (n : Nat) (x : PartENat), Iff (LE.le.{0} PartENat PartENat.instLEPartENat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) x) (forall (h : Part.Dom.{0} Nat x), LE.le.{0} Nat instLENat n (Part.get.{0} Nat x h))
-Case conversion may be inaccurate. Consider using '#align part_enat.coe_le_iff PartENat.coe_le_iffₓ'. -/
 theorem coe_le_iff (n : ℕ) (x : PartENat) : (n : PartENat) ≤ x ↔ ∀ h : x.Dom, n ≤ x.get h :=
   by
   rw [← some_eq_coe]
@@ -435,12 +327,6 @@ theorem coe_le_iff (n : ℕ) (x : PartENat) : (n : PartENat) ≤ x ↔ ∀ h : x
   rfl
 #align part_enat.coe_le_iff PartENat.coe_le_iff
 
-/- warning: part_enat.coe_lt_iff -> PartENat.coe_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat) (x : PartENat), Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) x) (forall (h : Part.Dom.{0} Nat x), LT.lt.{0} Nat Nat.hasLt n (Part.get.{0} Nat x h))
-but is expected to have type
-  forall (n : Nat) (x : PartENat), Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) x) (forall (h : Part.Dom.{0} Nat x), LT.lt.{0} Nat instLTNat n (Part.get.{0} Nat x h))
-Case conversion may be inaccurate. Consider using '#align part_enat.coe_lt_iff PartENat.coe_lt_iffₓ'. -/
 theorem coe_lt_iff (n : ℕ) (x : PartENat) : (n : PartENat) < x ↔ ∀ h : x.Dom, n < x.get h :=
   by
   rw [← some_eq_coe]
@@ -485,22 +371,10 @@ theorem eq_zero_iff {x : PartENat} : x = 0 ↔ x ≤ 0 :=
 #align part_enat.eq_zero_iff PartENat.eq_zero_iff
 -/
 
-/- warning: part_enat.ne_zero_iff -> PartENat.ne_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat}, Iff (Ne.{1} PartENat x (OfNat.ofNat.{0} PartENat 0 (OfNat.mk.{0} PartENat 0 (Zero.zero.{0} PartENat PartENat.hasZero)))) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Bot.bot.{0} PartENat PartENat.hasBot) x)
-but is expected to have type
-  forall {x : PartENat}, Iff (Ne.{1} PartENat x (OfNat.ofNat.{0} PartENat 0 (Zero.toOfNat0.{0} PartENat PartENat.instZeroPartENat))) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Bot.bot.{0} PartENat PartENat.instBotPartENat) x)
-Case conversion may be inaccurate. Consider using '#align part_enat.ne_zero_iff PartENat.ne_zero_iffₓ'. -/
 theorem ne_zero_iff {x : PartENat} : x ≠ 0 ↔ ⊥ < x :=
   bot_lt_iff_ne_bot.symm
 #align part_enat.ne_zero_iff PartENat.ne_zero_iff
 
-/- warning: part_enat.dom_of_lt -> PartENat.dom_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Part.Dom.{0} Nat x)
-but is expected to have type
-  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Part.Dom.{0} Nat x)
-Case conversion may be inaccurate. Consider using '#align part_enat.dom_of_lt PartENat.dom_of_ltₓ'. -/
 theorem dom_of_lt {x y : PartENat} : x < y → x.Dom :=
   PartENat.casesOn x not_top_lt fun _ _ => dom_natCast _
 #align part_enat.dom_of_lt PartENat.dom_of_lt
@@ -511,44 +385,20 @@ theorem top_eq_none : (⊤ : PartENat) = none :=
 #align part_enat.top_eq_none PartENat.top_eq_none
 -/
 
-/- warning: part_enat.coe_lt_top -> PartENat.natCast_lt_top is a dubious translation:
-lean 3 declaration is
-  forall (x : Nat), LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) (Top.top.{0} PartENat PartENat.hasTop)
-but is expected to have type
-  forall (x : Nat), LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) (Top.top.{0} PartENat PartENat.instTopPartENat)
-Case conversion may be inaccurate. Consider using '#align part_enat.coe_lt_top PartENat.natCast_lt_topₓ'. -/
 @[simp]
 theorem natCast_lt_top (x : ℕ) : (x : PartENat) < ⊤ :=
   Ne.lt_top fun h => absurd (congr_arg Dom h) <| by simpa only [dom_coe] using true_ne_false
 #align part_enat.coe_lt_top PartENat.natCast_lt_top
 
-/- warning: part_enat.coe_ne_top -> PartENat.natCast_ne_top is a dubious translation:
-lean 3 declaration is
-  forall (x : Nat), Ne.{1} PartENat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) (Top.top.{0} PartENat PartENat.hasTop)
-but is expected to have type
-  forall (x : Nat), Ne.{1} PartENat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) (Top.top.{0} PartENat PartENat.instTopPartENat)
-Case conversion may be inaccurate. Consider using '#align part_enat.coe_ne_top PartENat.natCast_ne_topₓ'. -/
 @[simp]
 theorem natCast_ne_top (x : ℕ) : (x : PartENat) ≠ ⊤ :=
   ne_of_lt (natCast_lt_top x)
 #align part_enat.coe_ne_top PartENat.natCast_ne_top
 
-/- warning: part_enat.not_is_max_coe -> PartENat.not_isMax_natCast is a dubious translation:
-lean 3 declaration is
-  forall (x : Nat), Not (IsMax.{0} PartENat PartENat.hasLe ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x))
-but is expected to have type
-  forall (x : Nat), Not (IsMax.{0} PartENat PartENat.instLEPartENat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x))
-Case conversion may be inaccurate. Consider using '#align part_enat.not_is_max_coe PartENat.not_isMax_natCastₓ'. -/
 theorem not_isMax_natCast (x : ℕ) : ¬IsMax (x : PartENat) :=
   not_isMax_of_lt (natCast_lt_top x)
 #align part_enat.not_is_max_coe PartENat.not_isMax_natCast
 
-/- warning: part_enat.ne_top_iff -> PartENat.ne_top_iff is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat}, Iff (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) (Exists.{1} Nat (fun (n : Nat) => Eq.{1} PartENat x ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n)))
-but is expected to have type
-  forall {x : PartENat}, Iff (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) (Exists.{1} Nat (fun (n : Nat) => Eq.{1} PartENat x (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n)))
-Case conversion may be inaccurate. Consider using '#align part_enat.ne_top_iff PartENat.ne_top_iffₓ'. -/
 theorem ne_top_iff {x : PartENat} : x ≠ ⊤ ↔ ∃ n : ℕ, x = n := by
   simpa only [← some_eq_coe] using Part.ne_none_iff
 #align part_enat.ne_top_iff PartENat.ne_top_iff
@@ -565,22 +415,10 @@ theorem not_dom_iff_eq_top {x : PartENat} : ¬x.Dom ↔ x = ⊤ :=
 #align part_enat.not_dom_iff_eq_top PartENat.not_dom_iff_eq_top
 -/
 
-/- warning: part_enat.ne_top_of_lt -> PartENat.ne_top_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop))
-but is expected to have type
-  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat))
-Case conversion may be inaccurate. Consider using '#align part_enat.ne_top_of_lt PartENat.ne_top_of_ltₓ'. -/
 theorem ne_top_of_lt {x y : PartENat} (h : x < y) : x ≠ ⊤ :=
   ne_of_lt <| lt_of_lt_of_le h le_top
 #align part_enat.ne_top_of_lt PartENat.ne_top_of_lt
 
-/- warning: part_enat.eq_top_iff_forall_lt -> PartENat.eq_top_iff_forall_lt is a dubious translation:
-lean 3 declaration is
-  forall (x : PartENat), Iff (Eq.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) (forall (n : Nat), LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) x)
-but is expected to have type
-  forall (x : PartENat), Iff (Eq.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) (forall (n : Nat), LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) x)
-Case conversion may be inaccurate. Consider using '#align part_enat.eq_top_iff_forall_lt PartENat.eq_top_iff_forall_ltₓ'. -/
 theorem eq_top_iff_forall_lt (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : PartENat) < x :=
   by
   constructor
@@ -588,23 +426,11 @@ theorem eq_top_iff_forall_lt (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : Part
   · contrapose!; rw [ne_top_iff]; rintro ⟨n, rfl⟩; exact ⟨n, irrefl _⟩
 #align part_enat.eq_top_iff_forall_lt PartENat.eq_top_iff_forall_lt
 
-/- warning: part_enat.eq_top_iff_forall_le -> PartENat.eq_top_iff_forall_le is a dubious translation:
-lean 3 declaration is
-  forall (x : PartENat), Iff (Eq.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) (forall (n : Nat), LE.le.{0} PartENat PartENat.hasLe ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) x)
-but is expected to have type
-  forall (x : PartENat), Iff (Eq.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) (forall (n : Nat), LE.le.{0} PartENat PartENat.instLEPartENat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) x)
-Case conversion may be inaccurate. Consider using '#align part_enat.eq_top_iff_forall_le PartENat.eq_top_iff_forall_leₓ'. -/
 theorem eq_top_iff_forall_le (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : PartENat) ≤ x :=
   (eq_top_iff_forall_lt x).trans
     ⟨fun h n => (h n).le, fun h n => lt_of_lt_of_le (coe_lt_coe.mpr n.lt_succ_self) (h (n + 1))⟩
 #align part_enat.eq_top_iff_forall_le PartENat.eq_top_iff_forall_le
 
-/- warning: part_enat.pos_iff_one_le -> PartENat.pos_iff_one_le is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat}, Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (OfNat.ofNat.{0} PartENat 0 (OfNat.mk.{0} PartENat 0 (Zero.zero.{0} PartENat PartENat.hasZero))) x) (LE.le.{0} PartENat PartENat.hasLe (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne))) x)
-but is expected to have type
-  forall {x : PartENat}, Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (OfNat.ofNat.{0} PartENat 0 (Zero.toOfNat0.{0} PartENat PartENat.instZeroPartENat)) x) (LE.le.{0} PartENat PartENat.instLEPartENat (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat)) x)
-Case conversion may be inaccurate. Consider using '#align part_enat.pos_iff_one_le PartENat.pos_iff_one_leₓ'. -/
 theorem pos_iff_one_le {x : PartENat} : 0 < x ↔ 1 ≤ x :=
   PartENat.casesOn x (by simp only [iff_true_iff, le_top, coe_lt_top, ← @Nat.cast_zero PartENat])
     fun n => by rw [← Nat.cast_zero, ← Nat.cast_one, PartENat.coe_lt_coe, PartENat.coe_le_coe]; rfl
@@ -653,12 +479,6 @@ instance : CanonicallyOrderedAddMonoid PartENat :=
           ⟨(b - a : ℕ), by
             rw [← Nat.cast_add, coe_inj, add_comm, tsub_add_cancel_of_le (coe_le_coe.1 h)]⟩ }
 
-/- warning: part_enat.eq_coe_sub_of_add_eq_coe -> PartENat.eq_natCast_sub_of_add_eq_natCast is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat} {n : Nat} (h : Eq.{1} PartENat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x y) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n)), Eq.{1} PartENat x ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) n (Part.get.{0} Nat y (PartENat.dom_of_le_natCast y n (LE.le.trans_eq.{0} PartENat (PartialOrder.toPreorder.{0} PartENat (OrderedAddCommMonoid.toPartialOrder.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.canonicallyOrderedAddMonoid))) y (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat (AddZeroClass.toHasAdd.{0} PartENat (AddMonoid.toAddZeroClass.{0} PartENat (AddCommMonoid.toAddMonoid.{0} PartENat (OrderedAddCommMonoid.toAddCommMonoid.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.canonicallyOrderedAddMonoid)))))) x y) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) (le_add_left.{0} PartENat PartENat.canonicallyOrderedAddMonoid y x y (le_rfl.{0} PartENat (PartialOrder.toPreorder.{0} PartENat (OrderedAddCommMonoid.toPartialOrder.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.canonicallyOrderedAddMonoid))) y)) h)))))
-but is expected to have type
-  forall {x : PartENat} {y : PartENat} {n : Nat} (h : Eq.{1} PartENat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x y) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n)), Eq.{1} PartENat x (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) n (Part.get.{0} Nat y (PartENat.dom_of_le_natCast y n (LE.le.trans_eq.{0} PartENat (PartialOrder.toPreorder.{0} PartENat (OrderedAddCommMonoid.toPartialOrder.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.instCanonicallyOrderedAddMonoidPartENat))) y (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat (AddZeroClass.toAdd.{0} PartENat (AddMonoid.toAddZeroClass.{0} PartENat (AddCommMonoid.toAddMonoid.{0} PartENat (OrderedAddCommMonoid.toAddCommMonoid.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.instCanonicallyOrderedAddMonoidPartENat)))))) x y) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) (le_add_left.{0} PartENat PartENat.instCanonicallyOrderedAddMonoidPartENat y x y (le_rfl.{0} PartENat (PartialOrder.toPreorder.{0} PartENat (OrderedAddCommMonoid.toPartialOrder.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.instCanonicallyOrderedAddMonoidPartENat))) y)) h)))))
-Case conversion may be inaccurate. Consider using '#align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_natCast_sub_of_add_eq_natCastₓ'. -/
 theorem eq_natCast_sub_of_add_eq_natCast {x y : PartENat} {n : ℕ} (h : x + y = n) :
     x = ↑(n - y.get (dom_of_le_natCast ((le_add_left le_rfl).trans_eq h))) :=
   by
@@ -668,12 +488,6 @@ theorem eq_natCast_sub_of_add_eq_natCast {x y : PartENat} {n : ℕ} (h : x + y =
   rw [get_coe, coe_inj, eq_tsub_of_add_eq h]
 #align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_natCast_sub_of_add_eq_natCast
 
-/- warning: part_enat.add_lt_add_right -> PartENat.add_lt_add_right is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat} {z : PartENat}, (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.hasTop)) -> (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x z) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) y z))
-but is expected to have type
-  forall {x : PartENat} {y : PartENat} {z : PartENat}, (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x z) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) y z))
-Case conversion may be inaccurate. Consider using '#align part_enat.add_lt_add_right PartENat.add_lt_add_rightₓ'. -/
 protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ ⊤) : x + z < y + z :=
   by
   rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
@@ -683,52 +497,22 @@ protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ 
   norm_cast  at h; apply_mod_cast add_lt_add_right h
 #align part_enat.add_lt_add_right PartENat.add_lt_add_right
 
-/- warning: part_enat.add_lt_add_iff_right -> PartENat.add_lt_add_iff_right is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat} {z : PartENat}, (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.hasTop)) -> (Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x z) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) y z)) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
-but is expected to have type
-  forall {x : PartENat} {y : PartENat} {z : PartENat}, (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x z) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) y z)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
-Case conversion may be inaccurate. Consider using '#align part_enat.add_lt_add_iff_right PartENat.add_lt_add_iff_rightₓ'. -/
 protected theorem add_lt_add_iff_right {x y z : PartENat} (hz : z ≠ ⊤) : x + z < y + z ↔ x < y :=
   ⟨lt_of_add_lt_add_right, fun h => PartENat.add_lt_add_right h hz⟩
 #align part_enat.add_lt_add_iff_right PartENat.add_lt_add_iff_right
 
-/- warning: part_enat.add_lt_add_iff_left -> PartENat.add_lt_add_iff_left is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat} {z : PartENat}, (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.hasTop)) -> (Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) z x) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) z y)) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
-but is expected to have type
-  forall {x : PartENat} {y : PartENat} {z : PartENat}, (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) z x) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) z y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
-Case conversion may be inaccurate. Consider using '#align part_enat.add_lt_add_iff_left PartENat.add_lt_add_iff_leftₓ'. -/
 protected theorem add_lt_add_iff_left {x y z : PartENat} (hz : z ≠ ⊤) : z + x < z + y ↔ x < y := by
   rw [add_comm z, add_comm z, PartENat.add_lt_add_iff_right hz]
 #align part_enat.add_lt_add_iff_left PartENat.add_lt_add_iff_left
 
-/- warning: part_enat.lt_add_iff_pos_right -> PartENat.lt_add_iff_pos_right is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) -> (Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x y)) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (OfNat.ofNat.{0} PartENat 0 (OfNat.mk.{0} PartENat 0 (Zero.zero.{0} PartENat PartENat.hasZero))) y))
-but is expected to have type
-  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (OfNat.ofNat.{0} PartENat 0 (Zero.toOfNat0.{0} PartENat PartENat.instZeroPartENat)) y))
-Case conversion may be inaccurate. Consider using '#align part_enat.lt_add_iff_pos_right PartENat.lt_add_iff_pos_rightₓ'. -/
 protected theorem lt_add_iff_pos_right {x y : PartENat} (hx : x ≠ ⊤) : x < x + y ↔ 0 < y := by
   conv_rhs => rw [← PartENat.add_lt_add_iff_left hx]; rw [add_zero]
 #align part_enat.lt_add_iff_pos_right PartENat.lt_add_iff_pos_right
 
-/- warning: part_enat.lt_add_one -> PartENat.lt_add_one is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) -> (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne)))))
-but is expected to have type
-  forall {x : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat))))
-Case conversion may be inaccurate. Consider using '#align part_enat.lt_add_one PartENat.lt_add_oneₓ'. -/
 theorem lt_add_one {x : PartENat} (hx : x ≠ ⊤) : x < x + 1 := by
   rw [PartENat.lt_add_iff_pos_right hx]; norm_cast; norm_num
 #align part_enat.lt_add_one PartENat.lt_add_one
 
-/- warning: part_enat.le_of_lt_add_one -> PartENat.le_of_lt_add_one is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) y (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne))))) -> (LE.le.{0} PartENat PartENat.hasLe x y)
-but is expected to have type
-  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) y (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat)))) -> (LE.le.{0} PartENat PartENat.instLEPartENat x y)
-Case conversion may be inaccurate. Consider using '#align part_enat.le_of_lt_add_one PartENat.le_of_lt_add_oneₓ'. -/
 theorem le_of_lt_add_one {x y : PartENat} (h : x < y + 1) : x ≤ y :=
   by
   induction' y using PartENat.casesOn with n; apply le_top
@@ -736,12 +520,6 @@ theorem le_of_lt_add_one {x y : PartENat} (h : x < y + 1) : x ≤ y :=
   apply_mod_cast Nat.le_of_lt_succ; apply_mod_cast h
 #align part_enat.le_of_lt_add_one PartENat.le_of_lt_add_one
 
-/- warning: part_enat.add_one_le_of_lt -> PartENat.add_one_le_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (LE.le.{0} PartENat PartENat.hasLe (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne)))) y)
-but is expected to have type
-  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (LE.le.{0} PartENat PartENat.instLEPartENat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat))) y)
-Case conversion may be inaccurate. Consider using '#align part_enat.add_one_le_of_lt PartENat.add_one_le_of_ltₓ'. -/
 theorem add_one_le_of_lt {x y : PartENat} (h : x < y) : x + 1 ≤ y :=
   by
   induction' y using PartENat.casesOn with n; apply le_top
@@ -749,12 +527,6 @@ theorem add_one_le_of_lt {x y : PartENat} (h : x < y) : x + 1 ≤ y :=
   apply_mod_cast Nat.succ_le_of_lt; apply_mod_cast h
 #align part_enat.add_one_le_of_lt PartENat.add_one_le_of_lt
 
-/- warning: part_enat.add_one_le_iff_lt -> PartENat.add_one_le_iff_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) -> (Iff (LE.le.{0} PartENat PartENat.hasLe (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne)))) y) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
-but is expected to have type
-  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (Iff (LE.le.{0} PartENat PartENat.instLEPartENat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat))) y) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
-Case conversion may be inaccurate. Consider using '#align part_enat.add_one_le_iff_lt PartENat.add_one_le_iff_ltₓ'. -/
 theorem add_one_le_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x + 1 ≤ y ↔ x < y :=
   by
   constructor; swap; exact add_one_le_of_lt
@@ -763,12 +535,6 @@ theorem add_one_le_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x + 1 ≤ y ↔ x
   apply_mod_cast Nat.lt_of_succ_le; apply_mod_cast h
 #align part_enat.add_one_le_iff_lt PartENat.add_one_le_iff_lt
 
-/- warning: part_enat.lt_add_one_iff_lt -> PartENat.lt_add_one_iff_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) -> (Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) y (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne))))) (LE.le.{0} PartENat PartENat.hasLe x y))
-but is expected to have type
-  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) y (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat)))) (LE.le.{0} PartENat PartENat.instLEPartENat x y))
-Case conversion may be inaccurate. Consider using '#align part_enat.lt_add_one_iff_lt PartENat.lt_add_one_iff_ltₓ'. -/
 theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x ≤ y :=
   by
   constructor; exact le_of_lt_add_one
@@ -843,45 +609,21 @@ theorem toWithTop_some (n : ℕ) : toWithTop (some n) = n :=
 #align part_enat.to_with_top_some PartENat.toWithTop_some
 -/
 
-/- warning: part_enat.to_with_top_coe -> PartENat.toWithTop_natCast is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat) {_x : Decidable (Part.Dom.{0} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n))}, Eq.{1} ENat (PartENat.toWithTop ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) _x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat ENat (HasLiftT.mk.{1, 1} Nat ENat (CoeTCₓ.coe.{1, 1} Nat ENat ENat.hasCoeT)) n)
-but is expected to have type
-  forall (n : Nat) {_x : Decidable (Part.Dom.{0} Nat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n))}, Eq.{1} ENat (PartENat.toWithTop (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) _x) (Nat.cast.{0} ENat (CanonicallyOrderedCommSemiring.toNatCast.{0} ENat instENatCanonicallyOrderedCommSemiring) n)
-Case conversion may be inaccurate. Consider using '#align part_enat.to_with_top_coe PartENat.toWithTop_natCastₓ'. -/
 theorem toWithTop_natCast (n : ℕ) {_ : Decidable (n : PartENat).Dom} : toWithTop n = n := by
   simp only [← some_eq_coe, ← to_with_top_some]
 #align part_enat.to_with_top_coe PartENat.toWithTop_natCast
 
-/- warning: part_enat.to_with_top_coe' -> PartENat.toWithTop_natCast' is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat) {h : Decidable (Part.Dom.{0} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n))}, Eq.{1} ENat (PartENat.toWithTop ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) h) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat ENat (HasLiftT.mk.{1, 1} Nat ENat (CoeTCₓ.coe.{1, 1} Nat ENat ENat.hasCoeT)) n)
-but is expected to have type
-  forall (n : Nat) {h : Decidable (Part.Dom.{0} Nat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n))}, Eq.{1} ENat (PartENat.toWithTop (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) h) (Nat.cast.{0} ENat (CanonicallyOrderedCommSemiring.toNatCast.{0} ENat instENatCanonicallyOrderedCommSemiring) n)
-Case conversion may be inaccurate. Consider using '#align part_enat.to_with_top_coe' PartENat.toWithTop_natCast'ₓ'. -/
 @[simp]
 theorem toWithTop_natCast' (n : ℕ) {h : Decidable (n : PartENat).Dom} :
     toWithTop (n : PartENat) = n := by convert to_with_top_coe n
 #align part_enat.to_with_top_coe' PartENat.toWithTop_natCast'
 
-/- warning: part_enat.to_with_top_le -> PartENat.toWithTop_le is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LE.le.{0} ENat (Preorder.toHasLe.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LE.le.{0} PartENat PartENat.hasLe x y)
-but is expected to have type
-  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
-Case conversion may be inaccurate. Consider using '#align part_enat.to_with_top_le PartENat.toWithTop_leₓ'. -/
 @[simp]
 theorem toWithTop_le {x y : PartENat} :
     ∀ [Decidable x.Dom] [Decidable y.Dom], to_with_top x ≤ to_with_top y ↔ x ≤ y :=
   PartENat.casesOn y (by simp) (PartENat.casesOn x (by simp) (by intros <;> simp))
 #align part_enat.to_with_top_le PartENat.toWithTop_le
 
-/- warning: part_enat.to_with_top_lt -> PartENat.toWithTop_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LT.lt.{0} ENat (Preorder.toHasLt.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
-but is expected to have type
-  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
-Case conversion may be inaccurate. Consider using '#align part_enat.to_with_top_lt PartENat.toWithTop_ltₓ'. -/
 @[simp]
 theorem toWithTop_lt {x y : PartENat} [Decidable x.Dom] [Decidable y.Dom] :
     toWithTop x < toWithTop y ↔ x < y :=
@@ -894,12 +636,6 @@ section WithTopEquiv
 
 open Classical
 
-/- warning: part_enat.to_with_top_add -> PartENat.toWithTop_add is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, Eq.{1} ENat (PartENat.toWithTop (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x y) (And.decidable (Part.Dom.{0} Nat x) (Part.Dom.{0} Nat y) (Classical.propDecidable (Part.Dom.{0} Nat x)) (Classical.propDecidable (Part.Dom.{0} Nat y)))) (HAdd.hAdd.{0, 0, 0} ENat ENat ENat (instHAdd.{0} ENat (Distrib.toHasAdd.{0} ENat (NonUnitalNonAssocSemiring.toDistrib.{0} ENat (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENat (Semiring.toNonAssocSemiring.{0} ENat (OrderedSemiring.toSemiring.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))))) (PartENat.toWithTop x (Classical.propDecidable (Part.Dom.{0} Nat x))) (PartENat.toWithTop y (Classical.propDecidable (Part.Dom.{0} Nat y))))
-but is expected to have type
-  forall {x : PartENat} {y : PartENat}, Eq.{1} ENat (PartENat.toWithTop (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x y) (Classical.propDecidable (Part.Dom.{0} Nat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x y)))) (HAdd.hAdd.{0, 0, 0} ENat ENat ENat (instHAdd.{0} ENat (Distrib.toAdd.{0} ENat (NonUnitalNonAssocSemiring.toDistrib.{0} ENat (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENat (Semiring.toNonAssocSemiring.{0} ENat (OrderedSemiring.toSemiring.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring)))))))) (PartENat.toWithTop x (Classical.propDecidable (Part.Dom.{0} Nat x))) (PartENat.toWithTop y (Classical.propDecidable (Part.Dom.{0} Nat y))))
-Case conversion may be inaccurate. Consider using '#align part_enat.to_with_top_add PartENat.toWithTop_addₓ'. -/
 @[simp]
 theorem toWithTop_add {x y : PartENat} : toWithTop (x + y) = toWithTop x + toWithTop y := by
   apply PartENat.casesOn y <;> apply PartENat.casesOn x <;> simp [← Nat.cast_add, ← ENat.coe_add]
@@ -941,34 +677,16 @@ theorem withTopEquiv_zero : withTopEquiv 0 = 0 := by
 #align part_enat.with_top_equiv_zero PartENat.withTopEquiv_zero
 -/
 
-/- warning: part_enat.with_top_equiv_le -> PartENat.withTopEquiv_le is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ENat (Preorder.toHasLe.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.hasLe x y)
-but is expected to have type
-  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (Preorder.toLE.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteSemilatticeInf.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteLattice.toCompleteSemilatticeInf.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteLinearOrder.toCompleteLattice.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) instCompleteLinearOrderENat))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
-Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_le PartENat.withTopEquiv_leₓ'. -/
 @[simp]
 theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔ x ≤ y :=
   toWithTop_le
 #align part_enat.with_top_equiv_le PartENat.withTopEquiv_le
 
-/- warning: part_enat.with_top_equiv_lt -> PartENat.withTopEquiv_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ENat (Preorder.toHasLt.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
-but is expected to have type
-  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteSemilatticeInf.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteLattice.toCompleteSemilatticeInf.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteLinearOrder.toCompleteLattice.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) instCompleteLinearOrderENat))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
-Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_lt PartENat.withTopEquiv_ltₓ'. -/
 @[simp]
 theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x < y :=
   toWithTop_lt
 #align part_enat.with_top_equiv_lt PartENat.withTopEquiv_lt
 
-/- warning: part_enat.with_top_order_iso -> PartENat.withTopOrderIso is a dubious translation:
-lean 3 declaration is
-  OrderIso.{0, 0} PartENat ENat PartENat.hasLe (Preorder.toHasLe.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder)))))
-but is expected to have type
-  OrderIso.{0, 0} PartENat ENat PartENat.instLEPartENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat)))))
-Case conversion may be inaccurate. Consider using '#align part_enat.with_top_order_iso PartENat.withTopOrderIsoₓ'. -/
 /-- `to_with_top` induces an order isomorphism between `part_enat` and `ℕ∞`. -/
 noncomputable def withTopOrderIso : PartENat ≃o ℕ∞ :=
   { withTopEquiv with map_rel_iff' := fun _ _ => withTopEquiv_le }
@@ -1002,23 +720,11 @@ theorem withTopEquiv_symm_le {x y : ℕ∞} : withTopEquiv.symm x ≤ withTopEqu
 #align part_enat.with_top_equiv_symm_le PartENat.withTopEquiv_symm_le
 -/
 
-/- warning: part_enat.with_top_equiv_symm_lt -> PartENat.withTopEquiv_symm_lt is a dubious translation:
-lean 3 declaration is
-  forall {x : ENat} {y : ENat}, Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (coeFn.{1, 1} (Equiv.{1, 1} ENat PartENat) (fun (_x : Equiv.{1, 1} ENat PartENat) => ENat -> PartENat) (Equiv.hasCoeToFun.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) x) (coeFn.{1, 1} (Equiv.{1, 1} ENat PartENat) (fun (_x : Equiv.{1, 1} ENat PartENat) => ENat -> PartENat) (Equiv.hasCoeToFun.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) y)) (LT.lt.{0} ENat (Preorder.toHasLt.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) x y)
-but is expected to have type
-  forall {x : ENat} {y : ENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ENat) => PartENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ENat) => PartENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ENat) => PartENat) x) PartENat.partialOrder)) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} ENat PartENat) ENat (fun (_x : ENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ENat) => PartENat) _x) (Equiv.instFunLikeEquiv.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} ENat PartENat) ENat (fun (_x : ENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ENat) => PartENat) _x) (Equiv.instFunLikeEquiv.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) y)) (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat))))) x y)
-Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_symm_lt PartENat.withTopEquiv_symm_ltₓ'. -/
 @[simp]
 theorem withTopEquiv_symm_lt {x y : ℕ∞} : withTopEquiv.symm x < withTopEquiv.symm y ↔ x < y := by
   rw [← with_top_equiv_lt] <;> simp
 #align part_enat.with_top_equiv_symm_lt PartENat.withTopEquiv_symm_lt
 
-/- warning: part_enat.with_top_add_equiv -> PartENat.withTopAddEquiv is a dubious translation:
-lean 3 declaration is
-  AddEquiv.{0, 0} PartENat ENat PartENat.hasAdd (Distrib.toHasAdd.{0} ENat (NonUnitalNonAssocSemiring.toDistrib.{0} ENat (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENat (Semiring.toNonAssocSemiring.{0} ENat (OrderedSemiring.toSemiring.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))))
-but is expected to have type
-  AddEquiv.{0, 0} PartENat ENat PartENat.instAddPartENat (Distrib.toAdd.{0} ENat (NonUnitalNonAssocSemiring.toDistrib.{0} ENat (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENat (Semiring.toNonAssocSemiring.{0} ENat (OrderedSemiring.toSemiring.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring)))))))
-Case conversion may be inaccurate. Consider using '#align part_enat.with_top_add_equiv PartENat.withTopAddEquivₓ'. -/
 /-- `to_with_top` induces an additive monoid isomorphism between `part_enat` and `ℕ∞`. -/
 noncomputable def withTopAddEquiv : PartENat ≃+ ℕ∞ :=
   { withTopEquiv with
@@ -1027,12 +733,6 @@ noncomputable def withTopAddEquiv : PartENat ≃+ ℕ∞ :=
 
 end WithTopEquiv
 
-/- warning: part_enat.lt_wf -> PartENat.lt_wf is a dubious translation:
-lean 3 declaration is
-  WellFounded.{1} PartENat (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)))
-but is expected to have type
-  WellFounded.{1} PartENat (fun (x._@.Mathlib.Data.Nat.PartENat._hyg.5731 : PartENat) (x._@.Mathlib.Data.Nat.PartENat._hyg.5733 : PartENat) => LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x._@.Mathlib.Data.Nat.PartENat._hyg.5731 x._@.Mathlib.Data.Nat.PartENat._hyg.5733)
-Case conversion may be inaccurate. Consider using '#align part_enat.lt_wf PartENat.lt_wfₓ'. -/
 theorem lt_wf : @WellFounded PartENat (· < ·) := by
   classical
     change WellFounded fun a b : PartENat => a < b
@@ -1072,12 +772,6 @@ theorem find_dom (h : ∃ n, P n) : (find P).Dom :=
 #align part_enat.find_dom PartENat.find_dom
 -/
 
-/- warning: part_enat.lt_find -> PartENat.lt_find is a dubious translation:
-lean 3 declaration is
-  forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), (forall (m : Nat), (LE.le.{0} Nat Nat.hasLe m n) -> (Not (P m))) -> (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) (PartENat.find P (fun (a : Nat) => _inst_1 a)))
-but is expected to have type
-  forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), (forall (m : Nat), (LE.le.{0} Nat instLENat m n) -> (Not (P m))) -> (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) (PartENat.find P (fun (a : Nat) => _inst_1 a)))
-Case conversion may be inaccurate. Consider using '#align part_enat.lt_find PartENat.lt_findₓ'. -/
 theorem lt_find (n : ℕ) (h : ∀ m ≤ n, ¬P m) : (n : PartENat) < find P :=
   by
   rw [coe_lt_iff]; intro h'; rw [find_get]
@@ -1086,12 +780,6 @@ theorem lt_find (n : ℕ) (h : ∀ m ≤ n, ¬P m) : (n : PartENat) < find P :=
   exact h _ this
 #align part_enat.lt_find PartENat.lt_find
 
-/- warning: part_enat.lt_find_iff -> PartENat.lt_find_iff is a dubious translation:
-lean 3 declaration is
-  forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) (PartENat.find P (fun (a : Nat) => _inst_1 a))) (forall (m : Nat), (LE.le.{0} Nat Nat.hasLe m n) -> (Not (P m)))
-but is expected to have type
-  forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) (PartENat.find P (fun (a : Nat) => _inst_1 a))) (forall (m : Nat), (LE.le.{0} Nat instLENat m n) -> (Not (P m)))
-Case conversion may be inaccurate. Consider using '#align part_enat.lt_find_iff PartENat.lt_find_iffₓ'. -/
 theorem lt_find_iff (n : ℕ) : (n : PartENat) < find P ↔ ∀ m ≤ n, ¬P m :=
   by
   refine' ⟨_, lt_find P n⟩
@@ -1101,12 +789,6 @@ theorem lt_find_iff (n : ℕ) : (n : PartENat) < find P ↔ ∀ m ≤ n, ¬P m :
   · exact not_exists.mp H m
 #align part_enat.lt_find_iff PartENat.lt_find_iff
 
-/- warning: part_enat.find_le -> PartENat.find_le is a dubious translation:
-lean 3 declaration is
-  forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), (P n) -> (LE.le.{0} PartENat PartENat.hasLe (PartENat.find P (fun (a : Nat) => _inst_1 a)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n))
-but is expected to have type
-  forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), (P n) -> (LE.le.{0} PartENat PartENat.instLEPartENat (PartENat.find P (fun (a : Nat) => _inst_1 a)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n))
-Case conversion may be inaccurate. Consider using '#align part_enat.find_le PartENat.find_leₓ'. -/
 theorem find_le (n : ℕ) (h : P n) : find P ≤ n := by rw [le_coe_iff];
   refine' ⟨⟨_, h⟩, @Nat.find_min' P _ _ _ h⟩
 #align part_enat.find_le PartENat.find_le

114ff8a4

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -185,10 +185,8 @@ but is expected to have type
   forall {P : PartENat -> Prop} (a : PartENat), (P (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (forall (n : Nat), P (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n)) -> (P a)
 Case conversion may be inaccurate. Consider using '#align part_enat.cases_on PartENat.casesOnₓ'. -/
 @[elab_as_elim]
-protected theorem casesOn {P : PartENat → Prop} : ∀ a : PartENat, P ⊤ → (∀ n : ℕ, P n) → P a :=
-  by
-  simp only [← some_eq_coe]
-  exact PartENat.casesOn'
+protected theorem casesOn {P : PartENat → Prop} : ∀ a : PartENat, P ⊤ → (∀ n : ℕ, P n) → P a := by
+  simp only [← some_eq_coe]; exact PartENat.casesOn'
 #align part_enat.cases_on PartENat.casesOn
 
 #print PartENat.top_add /-
@@ -211,9 +209,7 @@ but is expected to have type
   forall {x : PartENat} (h : Part.Dom.{0} Nat x), Eq.{1} PartENat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) (Part.get.{0} Nat x h)) x
 Case conversion may be inaccurate. Consider using '#align part_enat.coe_get PartENat.natCast_getₓ'. -/
 @[simp]
-theorem natCast_get {x : PartENat} (h : x.Dom) : (x.get h : PartENat) = x :=
-  by
-  rw [← some_eq_coe]
+theorem natCast_get {x : PartENat} (h : x.Dom) : (x.get h : PartENat) = x := by rw [← some_eq_coe];
   exact Part.ext' (iff_of_true trivial h) fun _ _ => rfl
 #align part_enat.coe_get PartENat.natCast_get
 
@@ -245,10 +241,7 @@ but is expected to have type
   forall {x : Nat} {y : PartENat} (h : Part.Dom.{0} Nat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) y)), Eq.{1} Nat (Part.get.{0} Nat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) y) h) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) x (Part.get.{0} Nat y (And.right (Part.Dom.{0} Nat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x)) (Part.Dom.{0} Nat y) h)))
 Case conversion may be inaccurate. Consider using '#align part_enat.coe_add_get PartENat.coe_add_getₓ'. -/
 theorem coe_add_get {x : ℕ} {y : PartENat} (h : ((x : PartENat) + y).Dom) :
-    get ((x : PartENat) + y) h = x + get y h.2 :=
-  by
-  simp only [← some_eq_coe] at h⊢
-  rfl
+    get ((x : PartENat) + y) h = x + get y h.2 := by simp only [← some_eq_coe] at h⊢; rfl
 #align part_enat.coe_add_get PartENat.coe_add_get
 
 #print PartENat.get_add /-
@@ -305,9 +298,7 @@ lean 3 declaration is
 but is expected to have type
   forall {x : PartENat} {y : Nat}, (LE.le.{0} PartENat PartENat.instLEPartENat x (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) y)) -> (Part.Dom.{0} Nat x)
 Case conversion may be inaccurate. Consider using '#align part_enat.dom_of_le_coe PartENat.dom_of_le_natCastₓ'. -/
-theorem dom_of_le_natCast {x : PartENat} {y : ℕ} (h : x ≤ y) : x.Dom :=
-  by
-  rw [← some_eq_coe] at h
+theorem dom_of_le_natCast {x : PartENat} {y : ℕ} (h : x ≤ y) : x.Dom := by rw [← some_eq_coe] at h;
   exact dom_of_le_some h
 #align part_enat.dom_of_le_coe PartENat.dom_of_le_natCast
 
@@ -317,9 +308,7 @@ instance decidableLe (x y : PartENat) [Decidable x.Dom] [Decidable y.Dom] : Deci
     decidable_of_decidable_of_iff
         (show Decidable (∀ hy : (y : PartENat).Dom, x.get hx ≤ (y : PartENat).get hy) from
           forallPropDecidable _) <|
-      by
-      dsimp [(· ≤ ·)]
-      simp only [hx, exists_prop_of_true, forall_true_iff]
+      by dsimp [(· ≤ ·)]; simp only [hx, exists_prop_of_true, forall_true_iff]
   else
     if hy : y.Dom then isFalse fun h => hx <| dom_of_le_of_dom h hy
     else isTrue ⟨fun h => (hy h).elim, fun h => (hy h).elim⟩
@@ -368,19 +357,14 @@ theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.ge
   constructor
   · rintro ⟨⟨hyx, H⟩, h⟩
     by_cases hx : x.dom
-    · use hx
-      intro hy
-      specialize H hy
-      specialize h fun _ => hy
-      rw [not_forall] at h
-      cases' h with hx' h
-      rw [not_le] at h
-      exact h
+    · use hx; intro hy
+      specialize H hy; specialize h fun _ => hy
+      rw [not_forall] at h; cases' h with hx' h
+      rw [not_le] at h; exact h
     · specialize h fun hx' => (hx hx').elim
-      rw [not_forall] at h
-      cases' h with hx' h
+      rw [not_forall] at h; cases' h with hx' h
       exact (hx hx').elim
-  · rintro ⟨hx, H⟩
+  · rintro ⟨hx, H⟩;
     exact ⟨⟨fun _ => hx, fun hy => (H hy).le⟩, fun hxy h => not_lt_of_le (h _) (H _)⟩
 #align part_enat.lt_def PartENat.lt_def
 
@@ -391,9 +375,7 @@ but is expected to have type
   forall {x : Nat} {y : Nat}, Iff (LE.le.{0} PartENat PartENat.instLEPartENat (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) y)) (LE.le.{0} Nat instLENat x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.coe_le_coe PartENat.coe_le_coeₓ'. -/
 @[simp, norm_cast]
-theorem coe_le_coe {x y : ℕ} : (x : PartENat) ≤ y ↔ x ≤ y :=
-  by
-  rw [← some_eq_coe, ← some_eq_coe]
+theorem coe_le_coe {x y : ℕ} : (x : PartENat) ≤ y ↔ x ≤ y := by rw [← some_eq_coe, ← some_eq_coe];
   exact ⟨fun ⟨_, h⟩ => h trivial, fun h => ⟨fun _ => trivial, fun _ => h⟩⟩
 #align part_enat.coe_le_coe PartENat.coe_le_coe
 
@@ -602,12 +584,8 @@ Case conversion may be inaccurate. Consider using '#align part_enat.eq_top_iff_f
 theorem eq_top_iff_forall_lt (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : PartENat) < x :=
   by
   constructor
-  · rintro rfl n
-    exact coe_lt_top _
-  · contrapose!
-    rw [ne_top_iff]
-    rintro ⟨n, rfl⟩
-    exact ⟨n, irrefl _⟩
+  · rintro rfl n; exact coe_lt_top _
+  · contrapose!; rw [ne_top_iff]; rintro ⟨n, rfl⟩; exact ⟨n, irrefl _⟩
 #align part_enat.eq_top_iff_forall_lt PartENat.eq_top_iff_forall_lt
 
 /- warning: part_enat.eq_top_iff_forall_le -> PartENat.eq_top_iff_forall_le is a dubious translation:
@@ -629,10 +607,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align part_enat.pos_iff_one_le PartENat.pos_iff_one_leₓ'. -/
 theorem pos_iff_one_le {x : PartENat} : 0 < x ↔ 1 ≤ x :=
   PartENat.casesOn x (by simp only [iff_true_iff, le_top, coe_lt_top, ← @Nat.cast_zero PartENat])
-    fun n =>
-    by
-    rw [← Nat.cast_zero, ← Nat.cast_one, PartENat.coe_lt_coe, PartENat.coe_le_coe]
-    rfl
+    fun n => by rw [← Nat.cast_zero, ← Nat.cast_one, PartENat.coe_lt_coe, PartENat.coe_le_coe]; rfl
 #align part_enat.pos_iff_one_le PartENat.pos_iff_one_le
 
 instance : IsTotal PartENat (· ≤ ·)
@@ -704,8 +679,7 @@ protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ 
   rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
   rcases ne_top_iff.mp hz with ⟨k, rfl⟩
   induction' y using PartENat.casesOn with n
-  · rw [top_add]
-    apply_mod_cast coe_lt_top
+  · rw [top_add]; apply_mod_cast coe_lt_top
   norm_cast  at h; apply_mod_cast add_lt_add_right h
 #align part_enat.add_lt_add_right PartENat.add_lt_add_right
 
@@ -735,10 +709,8 @@ lean 3 declaration is
 but is expected to have type
   forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (OfNat.ofNat.{0} PartENat 0 (Zero.toOfNat0.{0} PartENat PartENat.instZeroPartENat)) y))
 Case conversion may be inaccurate. Consider using '#align part_enat.lt_add_iff_pos_right PartENat.lt_add_iff_pos_rightₓ'. -/
-protected theorem lt_add_iff_pos_right {x y : PartENat} (hx : x ≠ ⊤) : x < x + y ↔ 0 < y :=
-  by
-  conv_rhs => rw [← PartENat.add_lt_add_iff_left hx]
-  rw [add_zero]
+protected theorem lt_add_iff_pos_right {x y : PartENat} (hx : x ≠ ⊤) : x < x + y ↔ 0 < y := by
+  conv_rhs => rw [← PartENat.add_lt_add_iff_left hx]; rw [add_zero]
 #align part_enat.lt_add_iff_pos_right PartENat.lt_add_iff_pos_right
 
 /- warning: part_enat.lt_add_one -> PartENat.lt_add_one is a dubious translation:
@@ -747,11 +719,8 @@ lean 3 declaration is
 but is expected to have type
   forall {x : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat))))
 Case conversion may be inaccurate. Consider using '#align part_enat.lt_add_one PartENat.lt_add_oneₓ'. -/
-theorem lt_add_one {x : PartENat} (hx : x ≠ ⊤) : x < x + 1 :=
-  by
-  rw [PartENat.lt_add_iff_pos_right hx]
-  norm_cast
-  norm_num
+theorem lt_add_one {x : PartENat} (hx : x ≠ ⊤) : x < x + 1 := by
+  rw [PartENat.lt_add_iff_pos_right hx]; norm_cast; norm_num
 #align part_enat.lt_add_one PartENat.lt_add_one
 
 /- warning: part_enat.le_of_lt_add_one -> PartENat.le_of_lt_add_one is a dubious translation:
@@ -804,9 +773,7 @@ theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x 
   by
   constructor; exact le_of_lt_add_one
   intro h; rcases ne_top_iff.mp hx with ⟨m, rfl⟩
-  induction' y using PartENat.casesOn with n;
-  · rw [top_add]
-    apply coe_lt_top
+  induction' y using PartENat.casesOn with n; · rw [top_add]; apply coe_lt_top
   apply_mod_cast Nat.lt_succ_of_le; apply_mod_cast h
 #align part_enat.lt_add_one_iff_lt PartENat.lt_add_one_iff_lt
 
@@ -1130,10 +1097,7 @@ theorem lt_find_iff (n : ℕ) : (n : PartENat) < find P ↔ ∀ m ≤ n, ¬P m :
   refine' ⟨_, lt_find P n⟩
   intro h m hm
   by_cases H : (find P).Dom
-  · apply Nat.find_min H
-    rw [coe_lt_iff] at h
-    specialize h H
-    exact lt_of_le_of_lt hm h
+  · apply Nat.find_min H; rw [coe_lt_iff] at h; specialize h H; exact lt_of_le_of_lt hm h
   · exact not_exists.mp H m
 #align part_enat.lt_find_iff PartENat.lt_find_iff
 
@@ -1143,9 +1107,7 @@ lean 3 declaration is
 but is expected to have type
   forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), (P n) -> (LE.le.{0} PartENat PartENat.instLEPartENat (PartENat.find P (fun (a : Nat) => _inst_1 a)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n))
 Case conversion may be inaccurate. Consider using '#align part_enat.find_le PartENat.find_leₓ'. -/
-theorem find_le (n : ℕ) (h : P n) : find P ≤ n :=
-  by
-  rw [le_coe_iff]
+theorem find_le (n : ℕ) (h : P n) : find P ≤ n := by rw [le_coe_iff];
   refine' ⟨⟨_, h⟩, @Nat.find_min' P _ _ _ h⟩
 #align part_enat.find_le PartENat.find_le

114ff8a4

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -978,7 +978,7 @@ theorem withTopEquiv_zero : withTopEquiv 0 = 0 := by
 lean 3 declaration is
   forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ENat (Preorder.toHasLe.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.hasLe x y)
 but is expected to have type
-  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLE.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteSemilatticeInf.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLattice.toCompleteSemilatticeInf.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLinearOrder.toCompleteLattice.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instCompleteLinearOrderENat))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
+  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (Preorder.toLE.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteSemilatticeInf.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteLattice.toCompleteSemilatticeInf.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteLinearOrder.toCompleteLattice.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) instCompleteLinearOrderENat))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_le PartENat.withTopEquiv_leₓ'. -/
 @[simp]
 theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔ x ≤ y :=
@@ -989,7 +989,7 @@ theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔
 lean 3 declaration is
   forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ENat (Preorder.toHasLt.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 but is expected to have type
-  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteSemilatticeInf.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLattice.toCompleteSemilatticeInf.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLinearOrder.toCompleteLattice.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instCompleteLinearOrderENat))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
+  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteSemilatticeInf.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteLattice.toCompleteSemilatticeInf.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) (CompleteLinearOrder.toCompleteLattice.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) x) instCompleteLinearOrderENat))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_lt PartENat.withTopEquiv_ltₓ'. -/
 @[simp]
 theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x < y :=
@@ -1039,7 +1039,7 @@ theorem withTopEquiv_symm_le {x y : ℕ∞} : withTopEquiv.symm x ≤ withTopEqu
 lean 3 declaration is
   forall {x : ENat} {y : ENat}, Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (coeFn.{1, 1} (Equiv.{1, 1} ENat PartENat) (fun (_x : Equiv.{1, 1} ENat PartENat) => ENat -> PartENat) (Equiv.hasCoeToFun.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) x) (coeFn.{1, 1} (Equiv.{1, 1} ENat PartENat) (fun (_x : Equiv.{1, 1} ENat PartENat) => ENat -> PartENat) (Equiv.hasCoeToFun.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) y)) (LT.lt.{0} ENat (Preorder.toHasLt.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) x y)
 but is expected to have type
-  forall {x : ENat} {y : ENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ENat) => PartENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ENat) => PartENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ENat) => PartENat) x) PartENat.partialOrder)) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} ENat PartENat) ENat (fun (_x : ENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ENat) => PartENat) _x) (Equiv.instFunLikeEquiv.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} ENat PartENat) ENat (fun (_x : ENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ENat) => PartENat) _x) (Equiv.instFunLikeEquiv.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) y)) (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat))))) x y)
+  forall {x : ENat} {y : ENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ENat) => PartENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ENat) => PartENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ENat) => PartENat) x) PartENat.partialOrder)) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} ENat PartENat) ENat (fun (_x : ENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ENat) => PartENat) _x) (Equiv.instFunLikeEquiv.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} ENat PartENat) ENat (fun (_x : ENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ENat) => PartENat) _x) (Equiv.instFunLikeEquiv.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) y)) (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat))))) x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_symm_lt PartENat.withTopEquiv_symm_ltₓ'. -/
 @[simp]
 theorem withTopEquiv_symm_lt {x y : ℕ∞} : withTopEquiv.symm x < withTopEquiv.symm y ↔ x < y := by

114ff8a4

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -356,7 +356,12 @@ instance : PartialOrder PartENat where
   le_antisymm := fun x y ⟨hxy₁, hxy₂⟩ ⟨hyx₁, hyx₂⟩ =>
     Part.ext' ⟨hyx₁, hxy₁⟩ fun _ _ => le_antisymm (hxy₂ _) (hyx₂ _)
 
-#print PartENat.lt_def /-
+/- warning: part_enat.lt_def -> PartENat.lt_def is a dubious translation:
+lean 3 declaration is
+  forall (x : PartENat) (y : PartENat), Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) (Exists.{0} (Part.Dom.{0} Nat x) (fun (hx : Part.Dom.{0} Nat x) => forall (hy : Part.Dom.{0} Nat y), LT.lt.{0} Nat Nat.hasLt (Part.get.{0} Nat x hx) (Part.get.{0} Nat y hy)))
+but is expected to have type
+  forall (x : PartENat) (y : PartENat), Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) (Exists.{0} (Part.Dom.{0} Nat x) (fun (hx : Part.Dom.{0} Nat x) => forall (hy : Part.Dom.{0} Nat y), LT.lt.{0} Nat instLTNat (Part.get.{0} Nat x hx) (Part.get.{0} Nat y hy)))
+Case conversion may be inaccurate. Consider using '#align part_enat.lt_def PartENat.lt_defₓ'. -/
 theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.get hx < y.get hy :=
   by
   rw [lt_iff_le_not_le, le_def, le_def, not_exists]
@@ -378,7 +383,6 @@ theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.ge
   · rintro ⟨hx, H⟩
     exact ⟨⟨fun _ => hx, fun hy => (H hy).le⟩, fun hxy h => not_lt_of_le (h _) (H _)⟩
 #align part_enat.lt_def PartENat.lt_def
--/
 
 /- warning: part_enat.coe_le_coe -> PartENat.coe_le_coe is a dubious translation:
 lean 3 declaration is
@@ -395,7 +399,7 @@ theorem coe_le_coe {x y : ℕ} : (x : PartENat) ≤ y ↔ x ≤ y :=
 
 /- warning: part_enat.coe_lt_coe -> PartENat.coe_lt_coe is a dubious translation:
 lean 3 declaration is
-  forall {x : Nat} {y : Nat}, Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) y)) (LT.lt.{0} Nat Nat.hasLt x y)
+  forall {x : Nat} {y : Nat}, Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) y)) (LT.lt.{0} Nat Nat.hasLt x y)
 but is expected to have type
   forall {x : Nat} {y : Nat}, Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) y)) (LT.lt.{0} Nat instLTNat x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.coe_lt_coe PartENat.coe_lt_coeₓ'. -/
@@ -428,7 +432,7 @@ theorem le_coe_iff (x : PartENat) (n : ℕ) : x ≤ n ↔ ∃ h : x.Dom, x.get h
 
 /- warning: part_enat.lt_coe_iff -> PartENat.lt_coe_iff is a dubious translation:
 lean 3 declaration is
-  forall (x : PartENat) (n : Nat), Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n)) (Exists.{0} (Part.Dom.{0} Nat x) (fun (h : Part.Dom.{0} Nat x) => LT.lt.{0} Nat Nat.hasLt (Part.get.{0} Nat x h) n))
+  forall (x : PartENat) (n : Nat), Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n)) (Exists.{0} (Part.Dom.{0} Nat x) (fun (h : Part.Dom.{0} Nat x) => LT.lt.{0} Nat Nat.hasLt (Part.get.{0} Nat x h) n))
 but is expected to have type
   forall (x : PartENat) (n : Nat), Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n)) (Exists.{0} (Part.Dom.{0} Nat x) (fun (h : Part.Dom.{0} Nat x) => LT.lt.{0} Nat instLTNat (Part.get.{0} Nat x h) n))
 Case conversion may be inaccurate. Consider using '#align part_enat.lt_coe_iff PartENat.lt_coe_iffₓ'. -/
@@ -451,7 +455,7 @@ theorem coe_le_iff (n : ℕ) (x : PartENat) : (n : PartENat) ≤ x ↔ ∀ h : x
 
 /- warning: part_enat.coe_lt_iff -> PartENat.coe_lt_iff is a dubious translation:
 lean 3 declaration is
-  forall (n : Nat) (x : PartENat), Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) x) (forall (h : Part.Dom.{0} Nat x), LT.lt.{0} Nat Nat.hasLt n (Part.get.{0} Nat x h))
+  forall (n : Nat) (x : PartENat), Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) x) (forall (h : Part.Dom.{0} Nat x), LT.lt.{0} Nat Nat.hasLt n (Part.get.{0} Nat x h))
 but is expected to have type
   forall (n : Nat) (x : PartENat), Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) x) (forall (h : Part.Dom.{0} Nat x), LT.lt.{0} Nat instLTNat n (Part.get.{0} Nat x h))
 Case conversion may be inaccurate. Consider using '#align part_enat.coe_lt_iff PartENat.coe_lt_iffₓ'. -/
@@ -499,17 +503,25 @@ theorem eq_zero_iff {x : PartENat} : x = 0 ↔ x ≤ 0 :=
 #align part_enat.eq_zero_iff PartENat.eq_zero_iff
 -/
 
-#print PartENat.ne_zero_iff /-
+/- warning: part_enat.ne_zero_iff -> PartENat.ne_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat}, Iff (Ne.{1} PartENat x (OfNat.ofNat.{0} PartENat 0 (OfNat.mk.{0} PartENat 0 (Zero.zero.{0} PartENat PartENat.hasZero)))) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Bot.bot.{0} PartENat PartENat.hasBot) x)
+but is expected to have type
+  forall {x : PartENat}, Iff (Ne.{1} PartENat x (OfNat.ofNat.{0} PartENat 0 (Zero.toOfNat0.{0} PartENat PartENat.instZeroPartENat))) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Bot.bot.{0} PartENat PartENat.instBotPartENat) x)
+Case conversion may be inaccurate. Consider using '#align part_enat.ne_zero_iff PartENat.ne_zero_iffₓ'. -/
 theorem ne_zero_iff {x : PartENat} : x ≠ 0 ↔ ⊥ < x :=
   bot_lt_iff_ne_bot.symm
 #align part_enat.ne_zero_iff PartENat.ne_zero_iff
--/
 
-#print PartENat.dom_of_lt /-
+/- warning: part_enat.dom_of_lt -> PartENat.dom_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Part.Dom.{0} Nat x)
+but is expected to have type
+  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Part.Dom.{0} Nat x)
+Case conversion may be inaccurate. Consider using '#align part_enat.dom_of_lt PartENat.dom_of_ltₓ'. -/
 theorem dom_of_lt {x y : PartENat} : x < y → x.Dom :=
   PartENat.casesOn x not_top_lt fun _ _ => dom_natCast _
 #align part_enat.dom_of_lt PartENat.dom_of_lt
--/
 
 #print PartENat.top_eq_none /-
 theorem top_eq_none : (⊤ : PartENat) = none :=
@@ -519,7 +531,7 @@ theorem top_eq_none : (⊤ : PartENat) = none :=
 
 /- warning: part_enat.coe_lt_top -> PartENat.natCast_lt_top is a dubious translation:
 lean 3 declaration is
-  forall (x : Nat), LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) (Top.top.{0} PartENat PartENat.hasTop)
+  forall (x : Nat), LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) x) (Top.top.{0} PartENat PartENat.hasTop)
 but is expected to have type
   forall (x : Nat), LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) x) (Top.top.{0} PartENat PartENat.instTopPartENat)
 Case conversion may be inaccurate. Consider using '#align part_enat.coe_lt_top PartENat.natCast_lt_topₓ'. -/
@@ -571,15 +583,19 @@ theorem not_dom_iff_eq_top {x : PartENat} : ¬x.Dom ↔ x = ⊤ :=
 #align part_enat.not_dom_iff_eq_top PartENat.not_dom_iff_eq_top
 -/
 
-#print PartENat.ne_top_of_lt /-
+/- warning: part_enat.ne_top_of_lt -> PartENat.ne_top_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop))
+but is expected to have type
+  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat))
+Case conversion may be inaccurate. Consider using '#align part_enat.ne_top_of_lt PartENat.ne_top_of_ltₓ'. -/
 theorem ne_top_of_lt {x y : PartENat} (h : x < y) : x ≠ ⊤ :=
   ne_of_lt <| lt_of_lt_of_le h le_top
 #align part_enat.ne_top_of_lt PartENat.ne_top_of_lt
--/
 
 /- warning: part_enat.eq_top_iff_forall_lt -> PartENat.eq_top_iff_forall_lt is a dubious translation:
 lean 3 declaration is
-  forall (x : PartENat), Iff (Eq.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) (forall (n : Nat), LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) x)
+  forall (x : PartENat), Iff (Eq.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) (forall (n : Nat), LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) x)
 but is expected to have type
   forall (x : PartENat), Iff (Eq.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) (forall (n : Nat), LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) x)
 Case conversion may be inaccurate. Consider using '#align part_enat.eq_top_iff_forall_lt PartENat.eq_top_iff_forall_ltₓ'. -/
@@ -605,7 +621,12 @@ theorem eq_top_iff_forall_le (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : Part
     ⟨fun h n => (h n).le, fun h n => lt_of_lt_of_le (coe_lt_coe.mpr n.lt_succ_self) (h (n + 1))⟩
 #align part_enat.eq_top_iff_forall_le PartENat.eq_top_iff_forall_le
 
-#print PartENat.pos_iff_one_le /-
+/- warning: part_enat.pos_iff_one_le -> PartENat.pos_iff_one_le is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat}, Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (OfNat.ofNat.{0} PartENat 0 (OfNat.mk.{0} PartENat 0 (Zero.zero.{0} PartENat PartENat.hasZero))) x) (LE.le.{0} PartENat PartENat.hasLe (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne))) x)
+but is expected to have type
+  forall {x : PartENat}, Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (OfNat.ofNat.{0} PartENat 0 (Zero.toOfNat0.{0} PartENat PartENat.instZeroPartENat)) x) (LE.le.{0} PartENat PartENat.instLEPartENat (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat)) x)
+Case conversion may be inaccurate. Consider using '#align part_enat.pos_iff_one_le PartENat.pos_iff_one_leₓ'. -/
 theorem pos_iff_one_le {x : PartENat} : 0 < x ↔ 1 ≤ x :=
   PartENat.casesOn x (by simp only [iff_true_iff, le_top, coe_lt_top, ← @Nat.cast_zero PartENat])
     fun n =>
@@ -613,7 +634,6 @@ theorem pos_iff_one_le {x : PartENat} : 0 < x ↔ 1 ≤ x :=
     rw [← Nat.cast_zero, ← Nat.cast_one, PartENat.coe_lt_coe, PartENat.coe_le_coe]
     rfl
 #align part_enat.pos_iff_one_le PartENat.pos_iff_one_le
--/
 
 instance : IsTotal PartENat (· ≤ ·)
     where Total x y :=
@@ -673,7 +693,12 @@ theorem eq_natCast_sub_of_add_eq_natCast {x y : PartENat} {n : ℕ} (h : x + y =
   rw [get_coe, coe_inj, eq_tsub_of_add_eq h]
 #align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_natCast_sub_of_add_eq_natCast
 
-#print PartENat.add_lt_add_right /-
+/- warning: part_enat.add_lt_add_right -> PartENat.add_lt_add_right is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat} {y : PartENat} {z : PartENat}, (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.hasTop)) -> (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x z) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) y z))
+but is expected to have type
+  forall {x : PartENat} {y : PartENat} {z : PartENat}, (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x z) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) y z))
+Case conversion may be inaccurate. Consider using '#align part_enat.add_lt_add_right PartENat.add_lt_add_rightₓ'. -/
 protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ ⊤) : x + z < y + z :=
   by
   rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
@@ -683,56 +708,84 @@ protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ 
     apply_mod_cast coe_lt_top
   norm_cast  at h; apply_mod_cast add_lt_add_right h
 #align part_enat.add_lt_add_right PartENat.add_lt_add_right
--/
 
-#print PartENat.add_lt_add_iff_right /-
+/- warning: part_enat.add_lt_add_iff_right -> PartENat.add_lt_add_iff_right is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat} {y : PartENat} {z : PartENat}, (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.hasTop)) -> (Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x z) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) y z)) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
+but is expected to have type
+  forall {x : PartENat} {y : PartENat} {z : PartENat}, (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x z) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) y z)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
+Case conversion may be inaccurate. Consider using '#align part_enat.add_lt_add_iff_right PartENat.add_lt_add_iff_rightₓ'. -/
 protected theorem add_lt_add_iff_right {x y z : PartENat} (hz : z ≠ ⊤) : x + z < y + z ↔ x < y :=
   ⟨lt_of_add_lt_add_right, fun h => PartENat.add_lt_add_right h hz⟩
 #align part_enat.add_lt_add_iff_right PartENat.add_lt_add_iff_right
--/
 
-#print PartENat.add_lt_add_iff_left /-
+/- warning: part_enat.add_lt_add_iff_left -> PartENat.add_lt_add_iff_left is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat} {y : PartENat} {z : PartENat}, (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.hasTop)) -> (Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) z x) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) z y)) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
+but is expected to have type
+  forall {x : PartENat} {y : PartENat} {z : PartENat}, (Ne.{1} PartENat z (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) z x) (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) z y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
+Case conversion may be inaccurate. Consider using '#align part_enat.add_lt_add_iff_left PartENat.add_lt_add_iff_leftₓ'. -/
 protected theorem add_lt_add_iff_left {x y z : PartENat} (hz : z ≠ ⊤) : z + x < z + y ↔ x < y := by
   rw [add_comm z, add_comm z, PartENat.add_lt_add_iff_right hz]
 #align part_enat.add_lt_add_iff_left PartENat.add_lt_add_iff_left
--/
 
-#print PartENat.lt_add_iff_pos_right /-
+/- warning: part_enat.lt_add_iff_pos_right -> PartENat.lt_add_iff_pos_right is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) -> (Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x y)) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (OfNat.ofNat.{0} PartENat 0 (OfNat.mk.{0} PartENat 0 (Zero.zero.{0} PartENat PartENat.hasZero))) y))
+but is expected to have type
+  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (OfNat.ofNat.{0} PartENat 0 (Zero.toOfNat0.{0} PartENat PartENat.instZeroPartENat)) y))
+Case conversion may be inaccurate. Consider using '#align part_enat.lt_add_iff_pos_right PartENat.lt_add_iff_pos_rightₓ'. -/
 protected theorem lt_add_iff_pos_right {x y : PartENat} (hx : x ≠ ⊤) : x < x + y ↔ 0 < y :=
   by
   conv_rhs => rw [← PartENat.add_lt_add_iff_left hx]
   rw [add_zero]
 #align part_enat.lt_add_iff_pos_right PartENat.lt_add_iff_pos_right
--/
 
-#print PartENat.lt_add_one /-
+/- warning: part_enat.lt_add_one -> PartENat.lt_add_one is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) -> (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne)))))
+but is expected to have type
+  forall {x : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat))))
+Case conversion may be inaccurate. Consider using '#align part_enat.lt_add_one PartENat.lt_add_oneₓ'. -/
 theorem lt_add_one {x : PartENat} (hx : x ≠ ⊤) : x < x + 1 :=
   by
   rw [PartENat.lt_add_iff_pos_right hx]
   norm_cast
   norm_num
 #align part_enat.lt_add_one PartENat.lt_add_one
--/
 
-#print PartENat.le_of_lt_add_one /-
+/- warning: part_enat.le_of_lt_add_one -> PartENat.le_of_lt_add_one is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) y (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne))))) -> (LE.le.{0} PartENat PartENat.hasLe x y)
+but is expected to have type
+  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) y (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat)))) -> (LE.le.{0} PartENat PartENat.instLEPartENat x y)
+Case conversion may be inaccurate. Consider using '#align part_enat.le_of_lt_add_one PartENat.le_of_lt_add_oneₓ'. -/
 theorem le_of_lt_add_one {x y : PartENat} (h : x < y + 1) : x ≤ y :=
   by
   induction' y using PartENat.casesOn with n; apply le_top
   rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
   apply_mod_cast Nat.le_of_lt_succ; apply_mod_cast h
 #align part_enat.le_of_lt_add_one PartENat.le_of_lt_add_one
--/
 
-#print PartENat.add_one_le_of_lt /-
+/- warning: part_enat.add_one_le_of_lt -> PartENat.add_one_le_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (LE.le.{0} PartENat PartENat.hasLe (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne)))) y)
+but is expected to have type
+  forall {x : PartENat} {y : PartENat}, (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y) -> (LE.le.{0} PartENat PartENat.instLEPartENat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat))) y)
+Case conversion may be inaccurate. Consider using '#align part_enat.add_one_le_of_lt PartENat.add_one_le_of_ltₓ'. -/
 theorem add_one_le_of_lt {x y : PartENat} (h : x < y) : x + 1 ≤ y :=
   by
   induction' y using PartENat.casesOn with n; apply le_top
   rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
   apply_mod_cast Nat.succ_le_of_lt; apply_mod_cast h
 #align part_enat.add_one_le_of_lt PartENat.add_one_le_of_lt
--/
 
-#print PartENat.add_one_le_iff_lt /-
+/- warning: part_enat.add_one_le_iff_lt -> PartENat.add_one_le_iff_lt is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) -> (Iff (LE.le.{0} PartENat PartENat.hasLe (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne)))) y) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
+but is expected to have type
+  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (Iff (LE.le.{0} PartENat PartENat.instLEPartENat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat))) y) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y))
+Case conversion may be inaccurate. Consider using '#align part_enat.add_one_le_iff_lt PartENat.add_one_le_iff_ltₓ'. -/
 theorem add_one_le_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x + 1 ≤ y ↔ x < y :=
   by
   constructor; swap; exact add_one_le_of_lt
@@ -740,9 +793,13 @@ theorem add_one_le_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x + 1 ≤ y ↔ x
   induction' y using PartENat.casesOn with n; apply coe_lt_top
   apply_mod_cast Nat.lt_of_succ_le; apply_mod_cast h
 #align part_enat.add_one_le_iff_lt PartENat.add_one_le_iff_lt
--/
 
-#print PartENat.lt_add_one_iff_lt /-
+/- warning: part_enat.lt_add_one_iff_lt -> PartENat.lt_add_one_iff_lt is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.hasTop)) -> (Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) y (OfNat.ofNat.{0} PartENat 1 (OfNat.mk.{0} PartENat 1 (One.one.{0} PartENat PartENat.hasOne))))) (LE.le.{0} PartENat PartENat.hasLe x y))
+but is expected to have type
+  forall {x : PartENat} {y : PartENat}, (Ne.{1} PartENat x (Top.top.{0} PartENat PartENat.instTopPartENat)) -> (Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) y (OfNat.ofNat.{0} PartENat 1 (One.toOfNat1.{0} PartENat PartENat.instOnePartENat)))) (LE.le.{0} PartENat PartENat.instLEPartENat x y))
+Case conversion may be inaccurate. Consider using '#align part_enat.lt_add_one_iff_lt PartENat.lt_add_one_iff_ltₓ'. -/
 theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x ≤ y :=
   by
   constructor; exact le_of_lt_add_one
@@ -752,7 +809,6 @@ theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x 
     apply coe_lt_top
   apply_mod_cast Nat.lt_succ_of_le; apply_mod_cast h
 #align part_enat.lt_add_one_iff_lt PartENat.lt_add_one_iff_lt
--/
 
 #print PartENat.add_eq_top_iff /-
 theorem add_eq_top_iff {a b : PartENat} : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ := by
@@ -843,7 +899,7 @@ theorem toWithTop_natCast' (n : ℕ) {h : Decidable (n : PartENat).Dom} :
 
 /- warning: part_enat.to_with_top_le -> PartENat.toWithTop_le is a dubious translation:
 lean 3 declaration is
-  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LE.le.{0} PartENat PartENat.hasLe x y)
+  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LE.le.{0} ENat (Preorder.toHasLe.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LE.le.{0} PartENat PartENat.hasLe x y)
 but is expected to have type
   forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.to_with_top_le PartENat.toWithTop_leₓ'. -/
@@ -855,7 +911,7 @@ theorem toWithTop_le {x y : PartENat} :
 
 /- warning: part_enat.to_with_top_lt -> PartENat.toWithTop_lt is a dubious translation:
 lean 3 declaration is
-  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
+  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LT.lt.{0} ENat (Preorder.toHasLt.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 but is expected to have type
   forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.to_with_top_lt PartENat.toWithTop_ltₓ'. -/
@@ -920,7 +976,7 @@ theorem withTopEquiv_zero : withTopEquiv 0 = 0 := by
 
 /- warning: part_enat.with_top_equiv_le -> PartENat.withTopEquiv_le is a dubious translation:
 lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.hasLe x y)
+  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ENat (Preorder.toHasLe.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.hasLe x y)
 but is expected to have type
   forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLE.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteSemilatticeInf.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLattice.toCompleteSemilatticeInf.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLinearOrder.toCompleteLattice.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instCompleteLinearOrderENat))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_le PartENat.withTopEquiv_leₓ'. -/
@@ -931,7 +987,7 @@ theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔
 
 /- warning: part_enat.with_top_equiv_lt -> PartENat.withTopEquiv_lt is a dubious translation:
 lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
+  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ENat (Preorder.toHasLt.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 but is expected to have type
   forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteSemilatticeInf.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLattice.toCompleteSemilatticeInf.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLinearOrder.toCompleteLattice.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instCompleteLinearOrderENat))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_lt PartENat.withTopEquiv_ltₓ'. -/
@@ -942,7 +998,7 @@ theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x
 
 /- warning: part_enat.with_top_order_iso -> PartENat.withTopOrderIso is a dubious translation:
 lean 3 declaration is
-  OrderIso.{0, 0} PartENat ENat PartENat.hasLe (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder)))))
+  OrderIso.{0, 0} PartENat ENat PartENat.hasLe (Preorder.toHasLe.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder)))))
 but is expected to have type
   OrderIso.{0, 0} PartENat ENat PartENat.instLEPartENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat)))))
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_order_iso PartENat.withTopOrderIsoₓ'. -/
@@ -979,12 +1035,16 @@ theorem withTopEquiv_symm_le {x y : ℕ∞} : withTopEquiv.symm x ≤ withTopEqu
 #align part_enat.with_top_equiv_symm_le PartENat.withTopEquiv_symm_le
 -/
 
-#print PartENat.withTopEquiv_symm_lt /-
+/- warning: part_enat.with_top_equiv_symm_lt -> PartENat.withTopEquiv_symm_lt is a dubious translation:
+lean 3 declaration is
+  forall {x : ENat} {y : ENat}, Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (coeFn.{1, 1} (Equiv.{1, 1} ENat PartENat) (fun (_x : Equiv.{1, 1} ENat PartENat) => ENat -> PartENat) (Equiv.hasCoeToFun.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) x) (coeFn.{1, 1} (Equiv.{1, 1} ENat PartENat) (fun (_x : Equiv.{1, 1} ENat PartENat) => ENat -> PartENat) (Equiv.hasCoeToFun.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) y)) (LT.lt.{0} ENat (Preorder.toHasLt.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) x y)
+but is expected to have type
+  forall {x : ENat} {y : ENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ENat) => PartENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ENat) => PartENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ENat) => PartENat) x) PartENat.partialOrder)) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} ENat PartENat) ENat (fun (_x : ENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ENat) => PartENat) _x) (Equiv.instFunLikeEquiv.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} ENat PartENat) ENat (fun (_x : ENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ENat) => PartENat) _x) (Equiv.instFunLikeEquiv.{1, 1} ENat PartENat) (Equiv.symm.{1, 1} PartENat ENat PartENat.withTopEquiv) y)) (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat))))) x y)
+Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_symm_lt PartENat.withTopEquiv_symm_ltₓ'. -/
 @[simp]
 theorem withTopEquiv_symm_lt {x y : ℕ∞} : withTopEquiv.symm x < withTopEquiv.symm y ↔ x < y := by
   rw [← with_top_equiv_lt] <;> simp
 #align part_enat.with_top_equiv_symm_lt PartENat.withTopEquiv_symm_lt
--/
 
 /- warning: part_enat.with_top_add_equiv -> PartENat.withTopAddEquiv is a dubious translation:
 lean 3 declaration is
@@ -1000,14 +1060,18 @@ noncomputable def withTopAddEquiv : PartENat ≃+ ℕ∞ :=
 
 end WithTopEquiv
 
-#print PartENat.lt_wf /-
+/- warning: part_enat.lt_wf -> PartENat.lt_wf is a dubious translation:
+lean 3 declaration is
+  WellFounded.{1} PartENat (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)))
+but is expected to have type
+  WellFounded.{1} PartENat (fun (x._@.Mathlib.Data.Nat.PartENat._hyg.5731 : PartENat) (x._@.Mathlib.Data.Nat.PartENat._hyg.5733 : PartENat) => LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x._@.Mathlib.Data.Nat.PartENat._hyg.5731 x._@.Mathlib.Data.Nat.PartENat._hyg.5733)
+Case conversion may be inaccurate. Consider using '#align part_enat.lt_wf PartENat.lt_wfₓ'. -/
 theorem lt_wf : @WellFounded PartENat (· < ·) := by
   classical
     change WellFounded fun a b : PartENat => a < b
     simp_rw [← to_with_top_lt]
     exact InvImage.wf _ (WithTop.wellFounded_lt Nat.lt_wfRel)
 #align part_enat.lt_wf PartENat.lt_wf
--/
 
 instance : WellFoundedLT PartENat :=
   ⟨lt_wf⟩
@@ -1043,7 +1107,7 @@ theorem find_dom (h : ∃ n, P n) : (find P).Dom :=
 
 /- warning: part_enat.lt_find -> PartENat.lt_find is a dubious translation:
 lean 3 declaration is
-  forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), (forall (m : Nat), (LE.le.{0} Nat Nat.hasLe m n) -> (Not (P m))) -> (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) (PartENat.find P (fun (a : Nat) => _inst_1 a)))
+  forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), (forall (m : Nat), (LE.le.{0} Nat Nat.hasLe m n) -> (Not (P m))) -> (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) (PartENat.find P (fun (a : Nat) => _inst_1 a)))
 but is expected to have type
   forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), (forall (m : Nat), (LE.le.{0} Nat instLENat m n) -> (Not (P m))) -> (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) (PartENat.find P (fun (a : Nat) => _inst_1 a)))
 Case conversion may be inaccurate. Consider using '#align part_enat.lt_find PartENat.lt_findₓ'. -/
@@ -1057,7 +1121,7 @@ theorem lt_find (n : ℕ) (h : ∀ m ≤ n, ¬P m) : (n : PartENat) < find P :=
 
 /- warning: part_enat.lt_find_iff -> PartENat.lt_find_iff is a dubious translation:
 lean 3 declaration is
-  forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) (PartENat.find P (fun (a : Nat) => _inst_1 a))) (forall (m : Nat), (LE.le.{0} Nat Nat.hasLe m n) -> (Not (P m)))
+  forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), Iff (LT.lt.{0} PartENat (Preorder.toHasLt.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) (PartENat.find P (fun (a : Nat) => _inst_1 a))) (forall (m : Nat), (LE.le.{0} Nat Nat.hasLe m n) -> (Not (P m)))
 but is expected to have type
   forall (P : Nat -> Prop) [_inst_1 : DecidablePred.{1} Nat P] (n : Nat), Iff (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) (PartENat.find P (fun (a : Nat) => _inst_1 a))) (forall (m : Nat), (LE.le.{0} Nat instLENat m n) -> (Not (P m)))
 Case conversion may be inaccurate. Consider using '#align part_enat.lt_find_iff PartENat.lt_find_iffₓ'. -/

114ff8a4

bump to nightly-2023-04-28-18

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

7a408b20

Diff

@@ -845,7 +845,7 @@ theorem toWithTop_natCast' (n : ℕ) {h : Decidable (n : PartENat).Dom} :
 lean 3 declaration is
   forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LE.le.{0} PartENat PartENat.hasLe x y)
 but is expected to have type
-  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
+  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.to_with_top_le PartENat.toWithTop_leₓ'. -/
 @[simp]
 theorem toWithTop_le {x y : PartENat} :
@@ -857,7 +857,7 @@ theorem toWithTop_le {x y : PartENat} :
 lean 3 declaration is
   forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 but is expected to have type
-  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
+  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.to_with_top_lt PartENat.toWithTop_ltₓ'. -/
 @[simp]
 theorem toWithTop_lt {x y : PartENat} [Decidable x.Dom] [Decidable y.Dom] :
@@ -922,7 +922,7 @@ theorem withTopEquiv_zero : withTopEquiv 0 = 0 := by
 lean 3 declaration is
   forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.hasLe x y)
 but is expected to have type
-  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLE.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedSemiring.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedCommSemiring.toOrderedSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instENatCanonicallyOrderedCommSemiring))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
+  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLE.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteSemilatticeInf.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLattice.toCompleteSemilatticeInf.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLinearOrder.toCompleteLattice.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instCompleteLinearOrderENat))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_le PartENat.withTopEquiv_leₓ'. -/
 @[simp]
 theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔ x ≤ y :=
@@ -933,7 +933,7 @@ theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔
 lean 3 declaration is
   forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 but is expected to have type
-  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedSemiring.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedCommSemiring.toOrderedSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instENatCanonicallyOrderedCommSemiring))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
+  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteSemilatticeInf.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLattice.toCompleteSemilatticeInf.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CompleteLinearOrder.toCompleteLattice.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instCompleteLinearOrderENat))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_lt PartENat.withTopEquiv_ltₓ'. -/
 @[simp]
 theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x < y :=
@@ -944,7 +944,7 @@ theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x
 lean 3 declaration is
   OrderIso.{0, 0} PartENat ENat PartENat.hasLe (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder)))))
 but is expected to have type
-  OrderIso.{0, 0} PartENat ENat PartENat.instLEPartENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring)))))
+  OrderIso.{0, 0} PartENat ENat PartENat.instLEPartENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat instCompleteLinearOrderENat)))))
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_order_iso PartENat.withTopOrderIsoₓ'. -/
 /-- `to_with_top` induces an order isomorphism between `part_enat` and `ℕ∞`. -/
 noncomputable def withTopOrderIso : PartENat ≃o ℕ∞ :=

114ff8a4

bump to nightly-2023-04-27-02

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

5e92de8b

Diff

@@ -843,7 +843,7 @@ theorem toWithTop_natCast' (n : ℕ) {h : Decidable (n : PartENat).Dom} :
 
 /- warning: part_enat.to_with_top_le -> PartENat.toWithTop_le is a dubious translation:
 lean 3 declaration is
-  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LE.le.{0} PartENat PartENat.hasLe x y)
+  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LE.le.{0} PartENat PartENat.hasLe x y)
 but is expected to have type
   forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.to_with_top_le PartENat.toWithTop_leₓ'. -/
@@ -855,7 +855,7 @@ theorem toWithTop_le {x y : PartENat} :
 
 /- warning: part_enat.to_with_top_lt -> PartENat.toWithTop_lt is a dubious translation:
 lean 3 declaration is
-  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
+  forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 but is expected to have type
   forall {x : PartENat} {y : PartENat} [_inst_1 : Decidable (Part.Dom.{0} Nat x)] [_inst_2 : Decidable (Part.Dom.{0} Nat y)], Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring))))) (PartENat.toWithTop x _inst_1) (PartENat.toWithTop y _inst_2)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.to_with_top_lt PartENat.toWithTop_ltₓ'. -/
@@ -920,7 +920,7 @@ theorem withTopEquiv_zero : withTopEquiv 0 = 0 := by
 
 /- warning: part_enat.with_top_equiv_le -> PartENat.withTopEquiv_le is a dubious translation:
 lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.hasLe x y)
+  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.hasLe x y)
 but is expected to have type
   forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLE.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedSemiring.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedCommSemiring.toOrderedSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instENatCanonicallyOrderedCommSemiring))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_le PartENat.withTopEquiv_leₓ'. -/
@@ -931,7 +931,7 @@ theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔
 
 /- warning: part_enat.with_top_equiv_lt -> PartENat.withTopEquiv_lt is a dubious translation:
 lean 3 declaration is
-  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
+  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 but is expected to have type
   forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedSemiring.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedCommSemiring.toOrderedSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instENatCanonicallyOrderedCommSemiring))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_lt PartENat.withTopEquiv_ltₓ'. -/
@@ -942,7 +942,7 @@ theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x
 
 /- warning: part_enat.with_top_order_iso -> PartENat.withTopOrderIso is a dubious translation:
 lean 3 declaration is
-  OrderIso.{0, 0} PartENat ENat PartENat.hasLe (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring))))))
+  OrderIso.{0, 0} PartENat ENat PartENat.hasLe (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (CompleteSemilatticeInf.toPartialOrder.{0} ENat (CompleteLattice.toCompleteSemilatticeInf.{0} ENat (CompleteLinearOrder.toCompleteLattice.{0} ENat ENat.completeLinearOrder)))))
 but is expected to have type
   OrderIso.{0, 0} PartENat ENat PartENat.instLEPartENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring)))))
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_order_iso PartENat.withTopOrderIsoₓ'. -/

114ff8a4

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -341,7 +341,7 @@ def natCast_AddMonoidHom : ℕ →+ PartENat :=
 lean 3 declaration is
   Eq.{1} (Nat -> PartENat) (coeFn.{1, 1} (AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne)))) (fun (_x : AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne)))) => Nat -> PartENat) (AddMonoidHom.hasCoeToFun.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne)))) PartENat.natCast_AddMonoidHom) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))))
 but is expected to have type
-  Eq.{1} (forall (ᾰ : Nat), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : Nat) => PartENat) ᾰ) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : Nat) => PartENat) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) Nat PartENat (AddZeroClass.toAdd.{0} Nat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (AddZeroClass.toAdd.{0} PartENat (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat))) (AddMonoidHom.addMonoidHomClass.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))))) PartENat.natCast_AddMonoidHom) PartENat.some
+  Eq.{1} (forall (ᾰ : Nat), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : Nat) => PartENat) ᾰ) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : Nat) => PartENat) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) Nat PartENat (AddZeroClass.toAdd.{0} Nat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid)) (AddZeroClass.toAdd.{0} PartENat (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))) Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat))) (AddMonoidHom.addMonoidHomClass.{0, 0} Nat PartENat (AddMonoid.toAddZeroClass.{0} Nat Nat.addMonoid) (AddMonoid.toAddZeroClass.{0} PartENat (AddMonoidWithOne.toAddMonoid.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)))))) PartENat.natCast_AddMonoidHom) PartENat.some
 Case conversion may be inaccurate. Consider using '#align part_enat.coe_coe_hom PartENat.coe_coeHomₓ'. -/
 @[simp]
 theorem coe_coeHom : ⇑natCast_AddMonoidHom = coe :=
@@ -922,7 +922,7 @@ theorem withTopEquiv_zero : withTopEquiv 0 = 0 := by
 lean 3 declaration is
   forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ENat (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.hasLe x y)
 but is expected to have type
-  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) (Preorder.toLE.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) (OrderedSemiring.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) (OrderedCommSemiring.toOrderedSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) instENatCanonicallyOrderedCommSemiring))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
+  forall {x : PartENat} {y : PartENat}, Iff (LE.le.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLE.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedSemiring.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedCommSemiring.toOrderedSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instENatCanonicallyOrderedCommSemiring))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LE.le.{0} PartENat PartENat.instLEPartENat x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_le PartENat.withTopEquiv_leₓ'. -/
 @[simp]
 theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔ x ≤ y :=
@@ -933,7 +933,7 @@ theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔
 lean 3 declaration is
   forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ENat (Preorder.toLT.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (coeFn.{1, 1} (Equiv.{1, 1} PartENat ENat) (fun (_x : Equiv.{1, 1} PartENat ENat) => PartENat -> ENat) (Equiv.hasCoeToFun.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 but is expected to have type
-  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) (OrderedSemiring.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) (OrderedCommSemiring.toOrderedSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) x) instENatCanonicallyOrderedCommSemiring))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
+  forall {x : PartENat} {y : PartENat}, Iff (LT.lt.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (Preorder.toLT.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (PartialOrder.toPreorder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedSemiring.toPartialOrder.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (OrderedCommSemiring.toOrderedSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) x) instENatCanonicallyOrderedCommSemiring))))) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv x) (FunLike.coe.{1, 1, 1} (Equiv.{1, 1} PartENat ENat) PartENat (fun (_x : PartENat) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : PartENat) => ENat) _x) (Equiv.instFunLikeEquiv.{1, 1} PartENat ENat) PartENat.withTopEquiv y)) (LT.lt.{0} PartENat (Preorder.toLT.{0} PartENat (PartialOrder.toPreorder.{0} PartENat PartENat.partialOrder)) x y)
 Case conversion may be inaccurate. Consider using '#align part_enat.with_top_equiv_lt PartENat.withTopEquiv_ltₓ'. -/
 @[simp]
 theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x < y :=

114ff8a4

bump to nightly-2023-03-07-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/3b267e70a936eebb21ab546f49a8df34dd300b25

e067364a

Diff

@@ -658,14 +658,20 @@ instance : CanonicallyOrderedAddMonoid PartENat :=
           ⟨(b - a : ℕ), by
             rw [← Nat.cast_add, coe_inj, add_comm, tsub_add_cancel_of_le (coe_le_coe.1 h)]⟩ }
 
-theorem eq_coe_sub_of_add_eq_coe {x y : PartENat} {n : ℕ} (h : x + y = n) :
+/- warning: part_enat.eq_coe_sub_of_add_eq_coe -> PartENat.eq_natCast_sub_of_add_eq_natCast is a dubious translation:
+lean 3 declaration is
+  forall {x : PartENat} {y : PartENat} {n : Nat} (h : Eq.{1} PartENat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.hasAdd) x y) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n)), Eq.{1} PartENat x ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) n (Part.get.{0} Nat y (PartENat.dom_of_le_natCast y n (LE.le.trans_eq.{0} PartENat (PartialOrder.toPreorder.{0} PartENat (OrderedAddCommMonoid.toPartialOrder.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.canonicallyOrderedAddMonoid))) y (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat (AddZeroClass.toHasAdd.{0} PartENat (AddMonoid.toAddZeroClass.{0} PartENat (AddCommMonoid.toAddMonoid.{0} PartENat (OrderedAddCommMonoid.toAddCommMonoid.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.canonicallyOrderedAddMonoid)))))) x y) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat PartENat (HasLiftT.mk.{1, 1} Nat PartENat (CoeTCₓ.coe.{1, 1} Nat PartENat (Nat.castCoe.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.addCommMonoidWithOne))))) n) (le_add_left.{0} PartENat PartENat.canonicallyOrderedAddMonoid y x y (le_rfl.{0} PartENat (PartialOrder.toPreorder.{0} PartENat (OrderedAddCommMonoid.toPartialOrder.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.canonicallyOrderedAddMonoid))) y)) h)))))
+but is expected to have type
+  forall {x : PartENat} {y : PartENat} {n : Nat} (h : Eq.{1} PartENat (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat PartENat.instAddPartENat) x y) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n)), Eq.{1} PartENat x (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) n (Part.get.{0} Nat y (PartENat.dom_of_le_natCast y n (LE.le.trans_eq.{0} PartENat (PartialOrder.toPreorder.{0} PartENat (OrderedAddCommMonoid.toPartialOrder.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.instCanonicallyOrderedAddMonoidPartENat))) y (HAdd.hAdd.{0, 0, 0} PartENat PartENat PartENat (instHAdd.{0} PartENat (AddZeroClass.toAdd.{0} PartENat (AddMonoid.toAddZeroClass.{0} PartENat (AddCommMonoid.toAddMonoid.{0} PartENat (OrderedAddCommMonoid.toAddCommMonoid.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.instCanonicallyOrderedAddMonoidPartENat)))))) x y) (Nat.cast.{0} PartENat (AddMonoidWithOne.toNatCast.{0} PartENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} PartENat PartENat.instAddCommMonoidWithOnePartENat)) n) (le_add_left.{0} PartENat PartENat.instCanonicallyOrderedAddMonoidPartENat y x y (le_rfl.{0} PartENat (PartialOrder.toPreorder.{0} PartENat (OrderedAddCommMonoid.toPartialOrder.{0} PartENat (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{0} PartENat PartENat.instCanonicallyOrderedAddMonoidPartENat))) y)) h)))))
+Case conversion may be inaccurate. Consider using '#align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_natCast_sub_of_add_eq_natCastₓ'. -/
+theorem eq_natCast_sub_of_add_eq_natCast {x y : PartENat} {n : ℕ} (h : x + y = n) :
     x = ↑(n - y.get (dom_of_le_natCast ((le_add_left le_rfl).trans_eq h))) :=
   by
   lift x to ℕ using dom_of_le_coe ((le_add_right le_rfl).trans_eq h)
   lift y to ℕ using dom_of_le_coe ((le_add_left le_rfl).trans_eq h)
   rw [← Nat.cast_add, coe_inj] at h
   rw [get_coe, coe_inj, eq_tsub_of_add_eq h]
-#align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_coe_sub_of_add_eq_coe
+#align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_natCast_sub_of_add_eq_natCast
 
 #print PartENat.add_lt_add_right /-
 protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ ⊤) : x + z < y + z :=

114ff8a4

bump to nightly-2023-02-28-04

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

2097f8af

Diff

@@ -160,7 +160,7 @@ instance : Top PartENat :=
 instance : Bot PartENat :=
   ⟨0⟩
 
-instance : HasSup PartENat :=
+instance : Sup PartENat :=
   ⟨fun x y => ⟨x.Dom ∧ y.Dom, fun h => x.get h.1 ⊔ y.get h.2⟩⟩
 
 #print PartENat.le_def /-

114ff8a4

bump to nightly-2023-02-28-03

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

ead5cda8

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 
 ! This file was ported from Lean 3 source module data.nat.part_enat
-! leanprover-community/mathlib commit 50832daea47b195a48b5b33b1c8b2162c48c3afc
+! leanprover-community/mathlib commit 114ff8a4a7935cb7531062200bff375e7b1d6d85
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -148,6 +148,9 @@ theorem dom_natCast (x : ℕ) : (x : PartENat).Dom :=
   trivial
 #align part_enat.dom_coe PartENat.dom_natCast
 
+instance : CanLift PartENat ℕ coe Dom :=
+  ⟨fun n hn => ⟨n.get hn, Part.some_get _⟩⟩
+
 instance : LE PartENat :=
   ⟨fun x y => ∃ h : y.Dom → x.Dom, ∀ hy : y.Dom, x.get (h hy) ≤ y.get hy⟩
 
@@ -655,6 +658,15 @@ instance : CanonicallyOrderedAddMonoid PartENat :=
           ⟨(b - a : ℕ), by
             rw [← Nat.cast_add, coe_inj, add_comm, tsub_add_cancel_of_le (coe_le_coe.1 h)]⟩ }
 
+theorem eq_coe_sub_of_add_eq_coe {x y : PartENat} {n : ℕ} (h : x + y = n) :
+    x = ↑(n - y.get (dom_of_le_natCast ((le_add_left le_rfl).trans_eq h))) :=
+  by
+  lift x to ℕ using dom_of_le_coe ((le_add_right le_rfl).trans_eq h)
+  lift y to ℕ using dom_of_le_coe ((le_add_left le_rfl).trans_eq h)
+  rw [← Nat.cast_add, coe_inj] at h
+  rw [get_coe, coe_inj, eq_tsub_of_add_eq h]
+#align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_coe_sub_of_add_eq_coe
+
 #print PartENat.add_lt_add_right /-
 protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ ⊤) : x + z < y + z :=
   by

50832dae

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

3ff3f2d6

fix: improve simp lemmas around PartENat.ofENat (#11553)

5d242aa4

Diff

@@ -687,21 +687,43 @@ instance : Coe ℕ∞ PartENat := ⟨ofENat⟩
 example (n : ℕ) : ((n : ℕ∞) : PartENat) = ↑n := rfl
 
 -- Porting note (#10756): new lemma
-@[simp]
-lemma ofENat_none : ofENat Option.none = ⊤ := rfl
+@[simp, norm_cast]
+lemma ofENat_top : ofENat ⊤ = ⊤ := rfl
 
 -- Porting note (#10756): new lemma
-@[simp]
-lemma ofENat_some (n : ℕ) : ofENat (Option.some n) = ↑n := rfl
+@[simp, norm_cast]
+lemma ofENat_coe (n : ℕ) : ofENat n = n := rfl
+
+@[simp, norm_cast]
+theorem ofENat_zero : ofENat 0 = 0 := rfl
+
+@[simp, norm_cast]
+theorem ofENat_one : ofENat 1 = 1 := rfl
+
+@[simp, norm_cast]
+theorem ofENat_ofNat (n : Nat) [n.AtLeastTwo] : ofENat (no_index (OfNat.ofNat n)) = OfNat.ofNat n :=
+  rfl
 
 -- Porting note (#10756): new theorem
 @[simp, norm_cast]
 theorem toWithTop_ofENat (n : ℕ∞) {_ : Decidable (n : PartENat).Dom} : toWithTop (↑n) = n := by
-  induction n with
-  | none => simp; rfl
-  | some n =>
-    simp only [toWithTop_natCast', ofENat_some]
-    rfl
+  cases n using ENat.recTopCoe with
+  | top => simp
+  | coe n => simp
+
+@[simp, norm_cast]
+theorem ofENat_toWithTop (x : PartENat) {_ : Decidable (x : PartENat).Dom} : toWithTop x = x := by
+  induction x using PartENat.casesOn <;> simp
+
+@[simp, norm_cast]
+theorem ofENat_le {x y : ℕ∞} : ofENat x ≤ ofENat y ↔ x ≤ y := by
+  classical
+  rw [← toWithTop_le, toWithTop_ofENat, toWithTop_ofENat]
+
+@[simp, norm_cast]
+theorem ofENat_lt {x y : ℕ∞} : ofENat x < ofENat y ↔ x < y := by
+  classical
+  rw [← toWithTop_lt, toWithTop_ofENat, toWithTop_ofENat]
 
 section WithTopEquiv
 
@@ -717,98 +739,75 @@ theorem toWithTop_add {x y : PartENat} : toWithTop (x + y) = toWithTop x + toWit
   · simp_rw [toWithTop_natCast', ← Nat.cast_add, toWithTop_natCast', forall_const]
 #align part_enat.to_with_top_add PartENat.toWithTop_add
 
--- Porting note: The old proof of `right_inv` didn't work.
--- (`by cases x; simp [with_top_equiv._match_1]; refl`)
--- In order to get it to work, I introduced some new statements (see above),
--- in particular `toWithTop_ofENat`.
 /-- `Equiv` between `PartENat` and `ℕ∞` (for the order isomorphism see
 `withTopOrderIso`). -/
+@[simps]
 noncomputable def withTopEquiv : PartENat ≃ ℕ∞ where
   toFun x := toWithTop x
   invFun x := ↑x
-  left_inv x := by
-    induction x using PartENat.casesOn <;>
-    simp <;>
-    rfl
-  right_inv x := by
-    simp [toWithTop_ofENat]
+  left_inv x := by simp
+  right_inv x := by simp
 #align part_enat.with_top_equiv PartENat.withTopEquiv
 
-@[simp]
-theorem withTopEquiv_top : withTopEquiv ⊤ = ⊤ :=
-  toWithTop_top'
+theorem withTopEquiv_top : withTopEquiv ⊤ = ⊤ := by
+  simp
 #align part_enat.with_top_equiv_top PartENat.withTopEquiv_top
 
-@[simp]
-theorem withTopEquiv_natCast (n : Nat) : withTopEquiv n = n :=
-  toWithTop_natCast' _
+theorem withTopEquiv_natCast (n : Nat) : withTopEquiv n = n := by
+  simp
 #align part_enat.with_top_equiv_coe PartENat.withTopEquiv_natCast
 
-@[simp]
 theorem withTopEquiv_zero : withTopEquiv 0 = 0 := by
-  simpa only [Nat.cast_zero] using withTopEquiv_natCast 0
+  simp
 #align part_enat.with_top_equiv_zero PartENat.withTopEquiv_zero
 
-@[simp]
 theorem withTopEquiv_one : withTopEquiv 1 = 1 := by
-  simpa only [Nat.cast_one] using withTopEquiv_natCast 1
+  simp
 
-@[simp]
 theorem withTopEquiv_ofNat (n : Nat) [n.AtLeastTwo] :
-    withTopEquiv (no_index (OfNat.ofNat n)) = OfNat.ofNat n :=
-  withTopEquiv_natCast n
+    withTopEquiv (no_index (OfNat.ofNat n)) = OfNat.ofNat n := by
+  simp
 
-@[simp]
-theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔ x ≤ y :=
-  toWithTop_le
+theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔ x ≤ y := by
+  simp
 #align part_enat.with_top_equiv_le PartENat.withTopEquiv_le
 
-@[simp]
-theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x < y :=
-  toWithTop_lt
+theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x < y := by
+  simp
 #align part_enat.with_top_equiv_lt PartENat.withTopEquiv_lt
 
-/-- `to_WithTop` induces an order isomorphism between `PartENat` and `ℕ∞`. -/
-noncomputable def withTopOrderIso : PartENat ≃o ℕ∞ :=
-  { withTopEquiv with map_rel_iff' := @fun _ _ => withTopEquiv_le }
-#align part_enat.with_top_order_iso PartENat.withTopOrderIso
-
-@[simp]
-theorem withTopEquiv_symm_top : withTopEquiv.symm ⊤ = ⊤ :=
-  rfl
+theorem withTopEquiv_symm_top : withTopEquiv.symm ⊤ = ⊤ := by
+  simp
 #align part_enat.with_top_equiv_symm_top PartENat.withTopEquiv_symm_top
 
-@[simp]
-theorem withTopEquiv_symm_coe (n : Nat) : withTopEquiv.symm n = n :=
-  rfl
+theorem withTopEquiv_symm_coe (n : Nat) : withTopEquiv.symm n = n := by
+  simp
 #align part_enat.with_top_equiv_symm_coe PartENat.withTopEquiv_symm_coe
 
-@[simp]
-theorem withTopEquiv_symm_zero : withTopEquiv.symm 0 = 0 :=
-  rfl
+theorem withTopEquiv_symm_zero : withTopEquiv.symm 0 = 0 := by
+  simp
 #align part_enat.with_top_equiv_symm_zero PartENat.withTopEquiv_symm_zero
 
-@[simp]
-theorem withTopEquiv_symm_one : withTopEquiv.symm 1 = 1 :=
-  rfl
+theorem withTopEquiv_symm_one : withTopEquiv.symm 1 = 1 := by
+  simp
 
-@[simp]
 theorem withTopEquiv_symm_ofNat (n : Nat) [n.AtLeastTwo] :
-    withTopEquiv.symm (no_index (OfNat.ofNat n)) = OfNat.ofNat n :=
-  rfl
+    withTopEquiv.symm (no_index (OfNat.ofNat n)) = OfNat.ofNat n := by
+  simp
 
-@[simp]
 theorem withTopEquiv_symm_le {x y : ℕ∞} : withTopEquiv.symm x ≤ withTopEquiv.symm y ↔ x ≤ y := by
-  rw [← withTopEquiv_le]
   simp
 #align part_enat.with_top_equiv_symm_le PartENat.withTopEquiv_symm_le
 
-@[simp]
 theorem withTopEquiv_symm_lt {x y : ℕ∞} : withTopEquiv.symm x < withTopEquiv.symm y ↔ x < y := by
-  rw [← withTopEquiv_lt]
   simp
 #align part_enat.with_top_equiv_symm_lt PartENat.withTopEquiv_symm_lt
 
+/-- `toWithTop` induces an order isomorphism between `PartENat` and `ℕ∞`. -/
+noncomputable def withTopOrderIso : PartENat ≃o ℕ∞ :=
+  { withTopEquiv with map_rel_iff' := @fun _ _ => withTopEquiv_le }
+#align part_enat.with_top_order_iso PartENat.withTopOrderIso
+
 /-- `toWithTop` induces an additive monoid isomorphism between `PartENat` and `ℕ∞`. -/
 noncomputable def withTopAddEquiv : PartENat ≃+ ℕ∞ :=
   { withTopEquiv with

3ff3f2d6

chore: classify new instance porting notes (#11433)

Classifies by adding issue number #10754 to porting notes claiming "new instance".

39175345

Diff

@@ -680,7 +680,7 @@ def ofENat : ℕ∞ → PartENat :=
   | Option.none => none
   | Option.some n => some n
 
--- Porting note: new
+-- Porting note (#10754): new instance
 instance : Coe ℕ∞ PartENat := ⟨ofENat⟩
 
 -- Porting note: new. This could probably be moved to tests or removed.

3ff3f2d6

chore: classify new theorem / theorem porting notes (#11432)

Classifies by adding issue number #10756 to porting notes claiming anything equivalent to:

"added theorem"
"added theorems"
"new theorem"
"new theorems"
"added lemma"
"new lemma"
"new lemmas"

55fe4027

Diff

@@ -686,15 +686,15 @@ instance : Coe ℕ∞ PartENat := ⟨ofENat⟩
 -- Porting note: new. This could probably be moved to tests or removed.
 example (n : ℕ) : ((n : ℕ∞) : PartENat) = ↑n := rfl
 
--- Porting note: new
+-- Porting note (#10756): new lemma
 @[simp]
 lemma ofENat_none : ofENat Option.none = ⊤ := rfl
 
--- Porting note: new
+-- Porting note (#10756): new lemma
 @[simp]
 lemma ofENat_some (n : ℕ) : ofENat (Option.some n) = ↑n := rfl
 
--- Porting note: new
+-- Porting note (#10756): new theorem
 @[simp, norm_cast]
 theorem toWithTop_ofENat (n : ℕ∞) {_ : Decidable (n : PartENat).Dom} : toWithTop (↑n) = n := by
   induction n with

3ff3f2d6

chore: remove tactics (#11365)

More tactics that are not used, found using the linter at #11308.

The PR consists of tactic removals, whitespace changes and replacing a porting note by an explanation.

c33c2724

Diff

@@ -728,7 +728,6 @@ noncomputable def withTopEquiv : PartENat ≃ ℕ∞ where
   invFun x := ↑x
   left_inv x := by
     induction x using PartENat.casesOn <;>
-    intros <;>
     simp <;>
     rfl
   right_inv x := by

3ff3f2d6

refactor: do not allow nsmul and zsmul to default automatically (#6262)

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

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

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

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

e42f78a9

Diff

@@ -96,6 +96,7 @@ instance addCommMonoid : AddCommMonoid PartENat where
   zero_add x := Part.ext' (true_and_iff _) fun _ _ => zero_add _
   add_zero x := Part.ext' (and_true_iff _) fun _ _ => add_zero _
   add_assoc x y z := Part.ext' and_assoc fun _ _ => add_assoc _ _ _
+  nsmul := nsmulRec
 
 instance : AddCommMonoidWithOne PartENat :=
   { PartENat.addCommMonoid with

3ff3f2d6

chore: scope open Classical (#11199)

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.

c747be0a

Diff

@@ -41,7 +41,7 @@ with `+` and `≤`.
 clear what `0 * ⊤` should be. `mul` is hence left undefined. Similarly `⊤ - ⊤` is ambiguous
 so there is no `-` defined on `PartENat`.
 
-Before the `open Classical` line, various proofs are made with decidability assumptions.
+Before the `open scoped Classical` line, various proofs are made with decidability assumptions.
 This can cause issues -- see for example the non-simp lemma `toWithTopZero` proved by `rfl`,
 followed by `@[simp] lemma toWithTopZero'` whose proof uses `convert`.
 
@@ -704,7 +704,7 @@ theorem toWithTop_ofENat (n : ℕ∞) {_ : Decidable (n : PartENat).Dom} : toWit
 
 section WithTopEquiv
 
-open Classical
+open scoped Classical
 
 @[simp]
 theorem toWithTop_add {x y : PartENat} : toWithTop (x + y) = toWithTop x + toWithTop y := by

3ff3f2d6

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

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

8be0b69c

Diff

@@ -709,7 +709,7 @@ open Classical
 @[simp]
 theorem toWithTop_add {x y : PartENat} : toWithTop (x + y) = toWithTop x + toWithTop y := by
   refine PartENat.casesOn y ?_ ?_ <;> refine PartENat.casesOn x ?_ ?_
-  --Porting note: was `simp [← Nat.cast_add, ← ENat.coe_add]`
+  -- Porting note: was `simp [← Nat.cast_add, ← ENat.coe_add]`
   · simp only [add_top, toWithTop_top', _root_.add_top]
   · simp only [add_top, toWithTop_top', toWithTop_natCast', _root_.add_top, forall_const]
   · simp only [top_add, toWithTop_top', toWithTop_natCast', _root_.top_add, forall_const]

3ff3f2d6

style: reduce spacing variation in "porting note" comments (#10886)

In this pull request, I have systematically eliminated the leading whitespace preceding the colon (:) within all unlabelled or unclassified porting notes. This adjustment facilitates a more efficient review process for the remaining notes by ensuring no entries are overlooked due to formatting inconsistencies.

86b84c52

Diff

@@ -671,7 +671,7 @@ theorem toWithTop_lt {x y : PartENat} [Decidable x.Dom] [Decidable y.Dom] :
 
 end WithTop
 
--- Porting note : new, extracted from `withTopEquiv`.
+-- Porting note: new, extracted from `withTopEquiv`.
 /-- Coercion from `ℕ∞` to `PartENat`. -/
 @[coe]
 def ofENat : ℕ∞ → PartENat :=
@@ -679,21 +679,21 @@ def ofENat : ℕ∞ → PartENat :=
   | Option.none => none
   | Option.some n => some n
 
--- Porting note : new
+-- Porting note: new
 instance : Coe ℕ∞ PartENat := ⟨ofENat⟩
 
 -- Porting note: new. This could probably be moved to tests or removed.
 example (n : ℕ) : ((n : ℕ∞) : PartENat) = ↑n := rfl
 
--- Porting note : new
+-- Porting note: new
 @[simp]
 lemma ofENat_none : ofENat Option.none = ⊤ := rfl
 
--- Porting note : new
+-- Porting note: new
 @[simp]
 lemma ofENat_some (n : ℕ) : ofENat (Option.some n) = ↑n := rfl
 
--- Porting note : new
+-- Porting note: new
 @[simp, norm_cast]
 theorem toWithTop_ofENat (n : ℕ∞) {_ : Decidable (n : PartENat).Dom} : toWithTop (↑n) = n := by
   induction n with

3ff3f2d6

chore: remove terminal, terminal refines (#10762)

I replaced a few "terminal" refine/refine's with exact.

The strategy was very simple-minded: essentially any refine whose following line had smaller indentation got replaced by exact and then I cleaned up the mess.

This PR certainly leaves some further terminal refines, but maybe the current change is beneficial.

ea36aa7d

Diff

@@ -875,7 +875,7 @@ theorem lt_find_iff (n : ℕ) : (n : PartENat) < find P ↔ ∀ m ≤ n, ¬P m :
 
 theorem find_le (n : ℕ) (h : P n) : find P ≤ n := by
   rw [le_coe_iff]
-  refine' ⟨⟨_, h⟩, @Nat.find_min' P _ _ _ h⟩
+  exact ⟨⟨_, h⟩, @Nat.find_min' P _ _ _ h⟩
 #align part_enat.find_le PartENat.find_le
 
 theorem find_eq_top_iff : find P = ⊤ ↔ ∀ n, ¬P n :=

3ff3f2d6

chore: space after ← (#8178)

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

5fb9beab

Diff

@@ -561,7 +561,7 @@ theorem add_eq_top_iff {a b : PartENat} : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ :=
   refine PartENat.casesOn a ?_ ?_
   <;> refine PartENat.casesOn b ?_ ?_
   <;> simp [top_add, add_top]
-  simp only [←Nat.cast_add, PartENat.natCast_ne_top, forall_const, not_false_eq_true]
+  simp only [← Nat.cast_add, PartENat.natCast_ne_top, forall_const, not_false_eq_true]
 #align part_enat.add_eq_top_iff PartENat.add_eq_top_iff
 
 protected theorem add_right_cancel_iff {a b c : PartENat} (hc : c ≠ ⊤) : a + c = b + c ↔ a = b := by
@@ -569,7 +569,7 @@ protected theorem add_right_cancel_iff {a b c : PartENat} (hc : c ≠ ⊤) : a +
   refine PartENat.casesOn a ?_ ?_
   <;> refine PartENat.casesOn b ?_ ?_
   <;> simp [add_eq_top_iff, natCast_ne_top, @eq_comm _ (⊤ : PartENat), top_add]
-  simp only [←Nat.cast_add, add_left_cancel_iff, PartENat.natCast_inj, add_comm, forall_const]
+  simp only [← Nat.cast_add, add_left_cancel_iff, PartENat.natCast_inj, add_comm, forall_const]
 #align part_enat.add_right_cancel_iff PartENat.add_right_cancel_iff
 
 protected theorem add_left_cancel_iff {a b c : PartENat} (ha : a ≠ ⊤) : a + b = a + c ↔ b = c := by

3ff3f2d6

chore: bump to v4.3.0-rc2 (#8366)

PR contents

This is the supremum of

#8284
#8056
#8023
#8332
#8226 (already approved)
#7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

switching to using explicit lemmas that have the intended level of application
(config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

40b64f79

Diff

@@ -561,7 +561,7 @@ theorem add_eq_top_iff {a b : PartENat} : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ :=
   refine PartENat.casesOn a ?_ ?_
   <;> refine PartENat.casesOn b ?_ ?_
   <;> simp [top_add, add_top]
-  simp only [←Nat.cast_add, PartENat.natCast_ne_top, forall_const]
+  simp only [←Nat.cast_add, PartENat.natCast_ne_top, forall_const, not_false_eq_true]
 #align part_enat.add_eq_top_iff PartENat.add_eq_top_iff
 
 protected theorem add_right_cancel_iff {a b c : PartENat} (hc : c ≠ ⊤) : a + c = b + c ↔ a = b := by
@@ -697,7 +697,7 @@ lemma ofENat_some (n : ℕ) : ofENat (Option.some n) = ↑n := rfl
 @[simp, norm_cast]
 theorem toWithTop_ofENat (n : ℕ∞) {_ : Decidable (n : PartENat).Dom} : toWithTop (↑n) = n := by
   induction n with
-  | none => simp
+  | none => simp; rfl
   | some n =>
     simp only [toWithTop_natCast', ofENat_some]
     rfl

3ff3f2d6

style: add missing spaces around colons (#8293)

This is not exhaustive

c488ddff

Diff

@@ -210,7 +210,7 @@ theorem get_one (h : (1 : PartENat).Dom) : (1 : PartENat).get h = 1 :=
 
 -- See note [no_index around OfNat.ofNat]
 @[simp]
-theorem get_ofNat' (x : ℕ) [x.AtLeastTwo] (h : (no_index (OfNat.ofNat x: PartENat)).Dom) :
+theorem get_ofNat' (x : ℕ) [x.AtLeastTwo] (h : (no_index (OfNat.ofNat x : PartENat)).Dom) :
     Part.get (no_index (OfNat.ofNat x : PartENat)) h = (no_index (OfNat.ofNat x)) :=
   get_natCast' x h

3ff3f2d6

chore(PartENat): golf and improve ofNat support (#8002)

This PR adds simp lemmas for OfNat.ofNat n : PartENat, 0 : PartENat, and 1 : PartENat in every place where there was a simp lemma for ((n : ℕ) : PartENat). This is necessary for simp confluence in the presence of lemmas such as Nat.cast_ofNat. In addition, instances for CharZero and ZeroLEOneClass are provided so that the lemmas from Data/Nat/Cast/Order.lean will apply, golfing some proofs.

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

8e84de5e

Diff

@@ -108,9 +108,12 @@ theorem some_eq_natCast (n : ℕ) : some n = n :=
   rfl
 #align part_enat.some_eq_coe PartENat.some_eq_natCast
 
-@[simp, norm_cast]
+instance : CharZero PartENat where
+  cast_injective := Part.some_injective
+
+/-- Alias of `Nat.cast_inj` specialized to `PartENat` --/
 theorem natCast_inj {x y : ℕ} : (x : PartENat) = y ↔ x = y :=
-  Part.some_inj
+  Nat.cast_inj
 #align part_enat.coe_inj PartENat.natCast_inj
 
 @[simp]
@@ -118,6 +121,19 @@ theorem dom_natCast (x : ℕ) : (x : PartENat).Dom :=
   trivial
 #align part_enat.dom_coe PartENat.dom_natCast
 
+-- See note [no_index around OfNat.ofNat]
+@[simp]
+theorem dom_ofNat (x : ℕ) [x.AtLeastTwo] : (no_index (OfNat.ofNat x : PartENat)).Dom :=
+  trivial
+
+@[simp]
+theorem dom_zero : (0 : PartENat).Dom :=
+  trivial
+
+@[simp]
+theorem dom_one : (1 : PartENat).Dom :=
+  trivial
+
 instance : CanLift PartENat ℕ (↑) Dom :=
   ⟨fun n hn => ⟨n.get hn, Part.some_get _⟩⟩
 
@@ -192,6 +208,12 @@ theorem get_one (h : (1 : PartENat).Dom) : (1 : PartENat).get h = 1 :=
   rfl
 #align part_enat.get_one PartENat.get_one
 
+-- See note [no_index around OfNat.ofNat]
+@[simp]
+theorem get_ofNat' (x : ℕ) [x.AtLeastTwo] (h : (no_index (OfNat.ofNat x: PartENat)).Dom) :
+    Part.get (no_index (OfNat.ofNat x : PartENat)) h = (no_index (OfNat.ofNat x)) :=
+  get_natCast' x h
+
 nonrec theorem get_eq_iff_eq_some {a : PartENat} {ha : a.Dom} {b : ℕ} : a.get ha = b ↔ a = some b :=
   get_eq_iff_eq_some
 #align part_enat.get_eq_iff_eq_some PartENat.get_eq_iff_eq_some
@@ -220,17 +242,9 @@ instance decidableLe (x y : PartENat) [Decidable x.Dom] [Decidable y.Dom] : Deci
     else isTrue ⟨fun h => (hy h).elim, fun h => (hy h).elim⟩
 #align part_enat.decidable_le PartENat.decidableLe
 
-/-- The coercion `ℕ → PartENat` preserves `0` and addition. -/
-def natCast_AddMonoidHom : ℕ →+ PartENat where
-  toFun := some
-  map_zero' := Nat.cast_zero
-  map_add' := Nat.cast_add
-#align part_enat.coe_hom PartENat.natCast_AddMonoidHom
-
-@[simp]
-theorem coe_coeHom : natCast_AddMonoidHom = some :=
-  rfl
-#align part_enat.coe_coe_hom PartENat.coe_coeHom
+-- Porting note: Removed. Use `Nat.castAddMonoidHom` instead.
+#noalign part_enat.coe_hom
+#noalign part_enat.coe_coe_hom
 
 instance partialOrder : PartialOrder PartENat where
   le := (· ≤ ·)
@@ -262,14 +276,41 @@ theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.ge
     exact ⟨⟨fun _ => hx, fun hy => (H hy).le⟩, fun hxy h => not_lt_of_le (h _) (H _)⟩
 #align part_enat.lt_def PartENat.lt_def
 
-@[simp, norm_cast]
-theorem coe_le_coe {x y : ℕ} : (x : PartENat) ≤ y ↔ x ≤ y := by
-  exact ⟨fun ⟨_, h⟩ => h trivial, fun h => ⟨fun _ => trivial, fun _ => h⟩⟩
+noncomputable instance orderedAddCommMonoid : OrderedAddCommMonoid PartENat :=
+  { PartENat.partialOrder, PartENat.addCommMonoid with
+    add_le_add_left := fun a b ⟨h₁, h₂⟩ c =>
+      PartENat.casesOn c (by simp [top_add]) fun c =>
+        ⟨fun h => And.intro (dom_natCast _) (h₁ h.2), fun h => by
+          simpa only [coe_add_get] using add_le_add_left (h₂ _) c⟩ }
+
+instance semilatticeSup : SemilatticeSup PartENat :=
+  { PartENat.partialOrder with
+    sup := (· ⊔ ·)
+    le_sup_left := fun _ _ => ⟨And.left, fun _ => le_sup_left⟩
+    le_sup_right := fun _ _ => ⟨And.right, fun _ => le_sup_right⟩
+    sup_le := fun _ _ _ ⟨hx₁, hx₂⟩ ⟨hy₁, hy₂⟩ =>
+      ⟨fun hz => ⟨hx₁ hz, hy₁ hz⟩, fun _ => sup_le (hx₂ _) (hy₂ _)⟩ }
+#align part_enat.semilattice_sup PartENat.semilatticeSup
+
+instance orderBot : OrderBot PartENat where
+  bot := ⊥
+  bot_le _ := ⟨fun _ => trivial, fun _ => Nat.zero_le _⟩
+#align part_enat.order_bot PartENat.orderBot
+
+instance orderTop : OrderTop PartENat where
+  top := ⊤
+  le_top _ := ⟨fun h => False.elim h, fun hy => False.elim hy⟩
+#align part_enat.order_top PartENat.orderTop
+
+instance : ZeroLEOneClass PartENat where
+  zero_le_one := bot_le
+
+/-- Alias of `Nat.cast_le` specialized to `PartENat` --/
+theorem coe_le_coe {x y : ℕ} : (x : PartENat) ≤ y ↔ x ≤ y := Nat.cast_le
 #align part_enat.coe_le_coe PartENat.coe_le_coe
 
-@[simp, norm_cast]
-theorem coe_lt_coe {x y : ℕ} : (x : PartENat) < y ↔ x < y := by
-  rw [lt_iff_le_not_le, lt_iff_le_not_le, coe_le_coe, coe_le_coe]
+/-- Alias of `Nat.cast_lt` specialized to `PartENat` --/
+theorem coe_lt_coe {x y : ℕ} : (x : PartENat) < y ↔ x < y := Nat.cast_lt
 #align part_enat.coe_lt_coe PartENat.coe_lt_coe
 
 @[simp]
@@ -300,29 +341,6 @@ theorem coe_lt_iff (n : ℕ) (x : PartENat) : (n : PartENat) < x ↔ ∀ h : x.D
   rfl
 #align part_enat.coe_lt_iff PartENat.coe_lt_iff
 
-instance NeZero.one : NeZero (1 : PartENat) :=
-  ⟨natCast_inj.not.mpr (by decide)⟩
-#align part_enat.ne_zero.one PartENat.NeZero.one
-
-instance semilatticeSup : SemilatticeSup PartENat :=
-  { PartENat.partialOrder with
-    sup := (· ⊔ ·)
-    le_sup_left := fun _ _ => ⟨And.left, fun _ => le_sup_left⟩
-    le_sup_right := fun _ _ => ⟨And.right, fun _ => le_sup_right⟩
-    sup_le := fun _ _ _ ⟨hx₁, hx₂⟩ ⟨hy₁, hy₂⟩ =>
-      ⟨fun hz => ⟨hx₁ hz, hy₁ hz⟩, fun _ => sup_le (hx₂ _) (hy₂ _)⟩ }
-#align part_enat.semilattice_sup PartENat.semilatticeSup
-
-instance orderBot : OrderBot PartENat where
-  bot := ⊥
-  bot_le _ := ⟨fun _ => trivial, fun _ => Nat.zero_le _⟩
-#align part_enat.order_bot PartENat.orderBot
-
-instance orderTop : OrderTop PartENat where
-  top := ⊤
-  le_top _ := ⟨fun h => False.elim h, fun hy => False.elim hy⟩
-#align part_enat.order_top PartENat.orderTop
-
 nonrec theorem eq_zero_iff {x : PartENat} : x = 0 ↔ x ≤ 0 :=
   eq_bot_iff
 #align part_enat.eq_zero_iff PartENat.eq_zero_iff
@@ -344,11 +362,37 @@ theorem natCast_lt_top (x : ℕ) : (x : PartENat) < ⊤ :=
   Ne.lt_top fun h => absurd (congr_arg Dom h) <| by simp only [dom_natCast]; exact true_ne_false
 #align part_enat.coe_lt_top PartENat.natCast_lt_top
 
+@[simp]
+theorem zero_lt_top : (0 : PartENat) < ⊤ :=
+  natCast_lt_top 0
+
+@[simp]
+theorem one_lt_top : (1 : PartENat) < ⊤ :=
+  natCast_lt_top 1
+
+-- See note [no_index around OfNat.ofNat]
+@[simp]
+theorem ofNat_lt_top (x : ℕ) [x.AtLeastTwo] : (no_index (OfNat.ofNat x : PartENat)) < ⊤ :=
+  natCast_lt_top x
+
 @[simp]
 theorem natCast_ne_top (x : ℕ) : (x : PartENat) ≠ ⊤ :=
   ne_of_lt (natCast_lt_top x)
 #align part_enat.coe_ne_top PartENat.natCast_ne_top
 
+@[simp]
+theorem zero_ne_top : (0 : PartENat) ≠ ⊤ :=
+  natCast_ne_top 0
+
+@[simp]
+theorem one_ne_top : (1 : PartENat) ≠ ⊤ :=
+  natCast_ne_top 1
+
+-- See note [no_index around OfNat.ofNat]
+@[simp]
+theorem ofNat_ne_top (x : ℕ) [x.AtLeastTwo] : (no_index (OfNat.ofNat x : PartENat)) ≠ ⊤ :=
+  natCast_ne_top x
+
 theorem not_isMax_natCast (x : ℕ) : ¬IsMax (x : PartENat) :=
   not_isMax_of_lt (natCast_lt_top x)
 #align part_enat.not_is_max_coe PartENat.not_isMax_natCast
@@ -419,13 +463,6 @@ noncomputable instance lattice : Lattice PartENat :=
     inf_le_right := min_le_right
     le_inf := fun _ _ _ => le_min }
 
-noncomputable instance orderedAddCommMonoid : OrderedAddCommMonoid PartENat :=
-  { PartENat.linearOrder, PartENat.addCommMonoid with
-    add_le_add_left := fun a b ⟨h₁, h₂⟩ c =>
-      PartENat.casesOn c (by simp [top_add]) fun c =>
-        ⟨fun h => And.intro (dom_natCast _) (h₁ h.2), fun h => by
-          simpa only [coe_add_get] using add_le_add_left (h₂ _) c⟩ }
-
 noncomputable instance : CanonicallyOrderedAddCommMonoid PartENat :=
   { PartENat.semilatticeSup, PartENat.orderBot,
     PartENat.orderedAddCommMonoid with
@@ -568,6 +605,15 @@ theorem toWithTop_zero' {h : Decidable (0 : PartENat).Dom} : toWithTop 0 = 0 :=
   convert toWithTop_zero
 #align part_enat.to_with_top_zero' PartENat.toWithTop_zero'
 
+theorem toWithTop_one :
+    have : Decidable (1 : PartENat).Dom := someDecidable 1
+    toWithTop 1 = 1 :=
+  rfl
+
+@[simp]
+theorem toWithTop_one' {h : Decidable (1 : PartENat).Dom} : toWithTop 1 = 1 := by
+  convert toWithTop_one
+
 theorem toWithTop_some (n : ℕ) : toWithTop (some n) = n :=
   rfl
 #align part_enat.to_with_top_some PartENat.toWithTop_some
@@ -578,11 +624,15 @@ theorem toWithTop_natCast (n : ℕ) {_ : Decidable (n : PartENat).Dom} : toWithT
 #align part_enat.to_with_top_coe PartENat.toWithTop_natCast
 
 @[simp]
-theorem toWithTop_natCast' (n : ℕ) {h : Decidable (n : PartENat).Dom} :
+theorem toWithTop_natCast' (n : ℕ) {_ : Decidable (n : PartENat).Dom} :
     toWithTop (n : PartENat) = n := by
   rw [toWithTop_natCast n]
 #align part_enat.to_with_top_coe' PartENat.toWithTop_natCast'
 
+@[simp]
+theorem toWithTop_ofNat (n : ℕ) [n.AtLeastTwo] {_ : Decidable (OfNat.ofNat n : PartENat).Dom} :
+    toWithTop (no_index (OfNat.ofNat n : PartENat)) = OfNat.ofNat n := toWithTop_natCast' n
+
 -- Porting note: statement changed. Mathlib 3 statement was
 -- ```
 -- @[simp] lemma to_with_top_le {x y : part_enat} :
@@ -699,6 +749,15 @@ theorem withTopEquiv_zero : withTopEquiv 0 = 0 := by
   simpa only [Nat.cast_zero] using withTopEquiv_natCast 0
 #align part_enat.with_top_equiv_zero PartENat.withTopEquiv_zero
 
+@[simp]
+theorem withTopEquiv_one : withTopEquiv 1 = 1 := by
+  simpa only [Nat.cast_one] using withTopEquiv_natCast 1
+
+@[simp]
+theorem withTopEquiv_ofNat (n : Nat) [n.AtLeastTwo] :
+    withTopEquiv (no_index (OfNat.ofNat n)) = OfNat.ofNat n :=
+  withTopEquiv_natCast n
+
 @[simp]
 theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔ x ≤ y :=
   toWithTop_le
@@ -729,6 +788,15 @@ theorem withTopEquiv_symm_zero : withTopEquiv.symm 0 = 0 :=
   rfl
 #align part_enat.with_top_equiv_symm_zero PartENat.withTopEquiv_symm_zero
 
+@[simp]
+theorem withTopEquiv_symm_one : withTopEquiv.symm 1 = 1 :=
+  rfl
+
+@[simp]
+theorem withTopEquiv_symm_ofNat (n : Nat) [n.AtLeastTwo] :
+    withTopEquiv.symm (no_index (OfNat.ofNat n)) = OfNat.ofNat n :=
+  rfl
+
 @[simp]
 theorem withTopEquiv_symm_le {x y : ℕ∞} : withTopEquiv.symm x ≤ withTopEquiv.symm y ↔ x ≤ y := by
   rw [← withTopEquiv_le]

3ff3f2d6

feat: Shorthands for well-foundedness of < and > (#7865)

We already have WellFoundedLT/WellFoundedGT as wrappers around IsWellFounded, but we didn't have the corresponding wrapper lemmas.

0030ea77

Diff

@@ -755,7 +755,7 @@ theorem lt_wf : @WellFounded PartENat (· < ·) := by
   classical
     change WellFounded fun a b : PartENat => a < b
     simp_rw [← withTopEquiv_lt]
-    exact InvImage.wf _ (WithTop.wellFounded_lt Nat.lt_wfRel.wf)
+    exact InvImage.wf _ wellFounded_lt
 #align part_enat.lt_wf PartENat.lt_wf
 
 instance : WellFoundedLT PartENat :=

3ff3f2d6

refactor(Algebra/Hom): transpose Hom and file name (#8095)

I believe the file defining a type of morphisms belongs alongside the file defining the structure this morphism works on. So I would like to reorganize the files in the Mathlib.Algebra.Hom folder so that e.g. Mathlib.Algebra.Hom.Ring becomes Mathlib.Algebra.Ring.Hom and Mathlib.Algebra.Hom.NonUnitalAlg becomes Mathlib.Algebra.Algebra.NonUnitalHom.

While fixing the imports I went ahead and sorted them for good luck.

The full list of changes is: renamed: Mathlib/Algebra/Hom/NonUnitalAlg.lean -> Mathlib/Algebra/Algebra/NonUnitalHom.lean renamed: Mathlib/Algebra/Hom/Aut.lean -> Mathlib/Algebra/Group/Aut.lean renamed: Mathlib/Algebra/Hom/Commute.lean -> Mathlib/Algebra/Group/Commute/Hom.lean renamed: Mathlib/Algebra/Hom/Embedding.lean -> Mathlib/Algebra/Group/Embedding.lean renamed: Mathlib/Algebra/Hom/Equiv/Basic.lean -> Mathlib/Algebra/Group/Equiv/Basic.lean renamed: Mathlib/Algebra/Hom/Equiv/TypeTags.lean -> Mathlib/Algebra/Group/Equiv/TypeTags.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/Basic.lean -> Mathlib/Algebra/Group/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/GroupWithZero.lean -> Mathlib/Algebra/GroupWithZero/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Freiman.lean -> Mathlib/Algebra/Group/Freiman.lean renamed: Mathlib/Algebra/Hom/Group/Basic.lean -> Mathlib/Algebra/Group/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Group/Defs.lean -> Mathlib/Algebra/Group/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/GroupAction.lean -> Mathlib/GroupTheory/GroupAction/Hom.lean renamed: Mathlib/Algebra/Hom/GroupInstances.lean -> Mathlib/Algebra/Group/Hom/Instances.lean renamed: Mathlib/Algebra/Hom/Iterate.lean -> Mathlib/Algebra/GroupPower/IterateHom.lean renamed: Mathlib/Algebra/Hom/Centroid.lean -> Mathlib/Algebra/Ring/CentroidHom.lean renamed: Mathlib/Algebra/Hom/Ring/Basic.lean -> Mathlib/Algebra/Ring/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Ring/Defs.lean -> Mathlib/Algebra/Ring/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/Units.lean -> Mathlib/Algebra/Group/Units/Hom.lean

Zulip thread: https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Reorganizing.20.60Mathlib.2EAlgebra.2EHom.60

92fe122e

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 -/
-import Mathlib.Algebra.Hom.Equiv.Basic
-import Mathlib.Data.Part
+import Mathlib.Algebra.Group.Equiv.Basic
 import Mathlib.Data.ENat.Lattice
+import Mathlib.Data.Part
 import Mathlib.Tactic.NormNum
 
 #align_import data.nat.part_enat from "leanprover-community/mathlib"@"3ff3f2d6a3118b8711063de7111a0d77a53219a8"

3ff3f2d6

chore: rename CanonicallyOrderedAddMonoid to ..AddCommMonoid (#7503)

Renames:

CanonicallyOrderedMonoid -> CanonicallyOrderedCommMonoid

CanonicallyOrderedAddMonoid -> CanonicallyOrderedAddCommMonoid

CanonicallyLinearOrderedMonoid -> CanonicallyLinearOrderedCommMonoid

CanonicallyLinearOrderedAddMonoid -> CanonicallyLinearOrderedAddCommMonoid

f3bc24c3

Diff

@@ -21,7 +21,7 @@ implementation. Use `ℕ∞` instead unless you care about computability.
 The following instances are defined:
 
 * `OrderedAddCommMonoid PartENat`
-* `CanonicallyOrderedAddMonoid PartENat`
+* `CanonicallyOrderedAddCommMonoid PartENat`
 * `CompleteLinearOrder PartENat`
 
 There is no additive analogue of `MonoidWithZero`; if there were then `PartENat` could
@@ -426,7 +426,7 @@ noncomputable instance orderedAddCommMonoid : OrderedAddCommMonoid PartENat :=
         ⟨fun h => And.intro (dom_natCast _) (h₁ h.2), fun h => by
           simpa only [coe_add_get] using add_le_add_left (h₂ _) c⟩ }
 
-noncomputable instance : CanonicallyOrderedAddMonoid PartENat :=
+noncomputable instance : CanonicallyOrderedAddCommMonoid PartENat :=
   { PartENat.semilatticeSup, PartENat.orderBot,
     PartENat.orderedAddCommMonoid with
     le_self_add := fun a b =>

3ff3f2d6

chore: cleanup some spaces (#7490)

Purely cosmetic PR

39a866a8

Diff

@@ -502,7 +502,7 @@ theorem add_one_le_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x + 1 ≤ y ↔ x
   norm_cast; apply Nat.lt_of_succ_le; norm_cast at h
 #align part_enat.add_one_le_iff_lt PartENat.add_one_le_iff_lt
 
-theorem coe_succ_le_iff {n : ℕ} {e : PartENat} : ↑n.succ ≤ e ↔ ↑n < e:= by
+theorem coe_succ_le_iff {n : ℕ} {e : PartENat} : ↑n.succ ≤ e ↔ ↑n < e := by
   rw [Nat.succ_eq_add_one n, Nat.cast_add, Nat.cast_one, add_one_le_iff_lt (natCast_ne_top n)]
 #align part_enat.coe_succ_le_succ_iff PartENat.coe_succ_le_iff

3ff3f2d6

chore: simplify by rfl (#7039)

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

8908a0a5

Diff

@@ -637,11 +637,11 @@ example (n : ℕ) : ((n : ℕ∞) : PartENat) = ↑n := rfl
 
 -- Porting note : new
 @[simp]
-lemma ofENat_none : ofENat Option.none = ⊤ := by rfl
+lemma ofENat_none : ofENat Option.none = ⊤ := rfl
 
 -- Porting note : new
 @[simp]
-lemma ofENat_some (n : ℕ) : ofENat (Option.some n) = ↑n := by rfl
+lemma ofENat_some (n : ℕ) : ofENat (Option.some n) = ↑n := rfl
 
 -- Porting note : new
 @[simp, norm_cast]

3ff3f2d6

chore: remove nolint from partENat (#6664)

Adding nolints seems the wrong solution here, the linter is right to complain, theses lemmas should just be used by hand until the general instance is proved

c198eb67

Diff

@@ -149,18 +149,12 @@ protected theorem casesOn {P : PartENat → Prop} : ∀ a : PartENat, P ⊤ →
   exact PartENat.casesOn'
 #align part_enat.cases_on PartENat.casesOn
 
--- Porting note : The last instance in this file (`LinearOrderedAddCommMonoidWithTop`)
--- causes the linter to complain here because with that instance `simp` could
--- proof `top_add`. Therefore the linter has been silenced here.
-@[nolint simpNF, simp]
+-- not a simp lemma as we will provide a `LinearOrderedAddCommMonoidWithTop` instance later
 theorem top_add (x : PartENat) : ⊤ + x = ⊤ :=
   Part.ext' (false_and_iff _) fun h => h.left.elim
 #align part_enat.top_add PartENat.top_add
 
--- Porting note : The last instance in this file (`LinearOrderedAddCommMonoidWithTop`)
--- causes the linter to complain here because with that instance `simp` could
--- proof `add_top`. Therefore the linter has been silenced here.@[nolint simpNF, simp]
-@[nolint simpNF, simp]
+-- not a simp lemma as we will provide a `LinearOrderedAddCommMonoidWithTop` instance later
 theorem add_top (x : PartENat) : x + ⊤ = ⊤ := by rw [add_comm, top_add]
 #align part_enat.add_top PartENat.add_top
 
@@ -428,7 +422,7 @@ noncomputable instance lattice : Lattice PartENat :=
 noncomputable instance orderedAddCommMonoid : OrderedAddCommMonoid PartENat :=
   { PartENat.linearOrder, PartENat.addCommMonoid with
     add_le_add_left := fun a b ⟨h₁, h₂⟩ c =>
-      PartENat.casesOn c (by simp) fun c =>
+      PartENat.casesOn c (by simp [top_add]) fun c =>
         ⟨fun h => And.intro (dom_natCast _) (h₁ h.2), fun h => by
           simpa only [coe_add_get] using add_le_add_left (h₂ _) c⟩ }
 
@@ -529,7 +523,7 @@ lemma lt_coe_succ_iff_le {x : PartENat} {n : ℕ} (hx : x ≠ ⊤) : x < n.succ
 theorem add_eq_top_iff {a b : PartENat} : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ := by
   refine PartENat.casesOn a ?_ ?_
   <;> refine PartENat.casesOn b ?_ ?_
-  <;> simp
+  <;> simp [top_add, add_top]
   simp only [←Nat.cast_add, PartENat.natCast_ne_top, forall_const]
 #align part_enat.add_eq_top_iff PartENat.add_eq_top_iff
 
@@ -537,7 +531,7 @@ protected theorem add_right_cancel_iff {a b c : PartENat} (hc : c ≠ ⊤) : a +
   rcases ne_top_iff.1 hc with ⟨c, rfl⟩
   refine PartENat.casesOn a ?_ ?_
   <;> refine PartENat.casesOn b ?_ ?_
-  <;> simp [add_eq_top_iff, natCast_ne_top, @eq_comm _ (⊤ : PartENat)]
+  <;> simp [add_eq_top_iff, natCast_ne_top, @eq_comm _ (⊤ : PartENat), top_add]
   simp only [←Nat.cast_add, add_left_cancel_iff, PartENat.natCast_inj, add_comm, forall_const]
 #align part_enat.add_right_cancel_iff PartENat.add_right_cancel_iff

3ff3f2d6

chore: tidy various files (#6274)

6b9326b4

Diff

@@ -226,7 +226,7 @@ instance decidableLe (x y : PartENat) [Decidable x.Dom] [Decidable y.Dom] : Deci
     else isTrue ⟨fun h => (hy h).elim, fun h => (hy h).elim⟩
 #align part_enat.decidable_le PartENat.decidableLe
 
-/-- The coercion `ℕ → partENat` preserves `0` and addition. -/
+/-- The coercion `ℕ → PartENat` preserves `0` and addition. -/
 def natCast_AddMonoidHom : ℕ →+ PartENat where
   toFun := some
   map_zero' := Nat.cast_zero
@@ -398,7 +398,7 @@ theorem pos_iff_one_le {x : PartENat} : 0 < x ↔ 1 ≤ x :=
       rfl
 #align part_enat.pos_iff_one_le PartENat.pos_iff_one_le
 
-instance isTotal: IsTotal PartENat (· ≤ ·) where
+instance isTotal : IsTotal PartENat (· ≤ ·) where
   total x y :=
     PartENat.casesOn (P := fun z => z ≤ y ∨ y ≤ z) x (Or.inr le_top)
       (PartENat.casesOn y (fun _ => Or.inl le_top) fun x y =>
@@ -415,17 +415,17 @@ noncomputable instance linearOrder : LinearOrder PartENat :=
       rw [@sup_eq_maxDefault PartENat _ (id _) _]
       rfl }
 
-instance boundedOrder: BoundedOrder PartENat :=
+instance boundedOrder : BoundedOrder PartENat :=
   { PartENat.orderTop, PartENat.orderBot with }
 
-noncomputable instance lattice: Lattice PartENat :=
+noncomputable instance lattice : Lattice PartENat :=
   { PartENat.semilatticeSup with
     inf := min
     inf_le_left := min_le_left
     inf_le_right := min_le_right
     le_inf := fun _ _ _ => le_min }
 
-noncomputable instance orderedAddCommMonoid: OrderedAddCommMonoid PartENat :=
+noncomputable instance orderedAddCommMonoid : OrderedAddCommMonoid PartENat :=
   { PartENat.linearOrder, PartENat.addCommMonoid with
     add_le_add_left := fun a b ⟨h₁, h₂⟩ c =>
       PartENat.casesOn c (by simp) fun c =>
@@ -522,8 +522,8 @@ theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x 
   norm_cast; apply Nat.lt_succ_of_le; norm_cast at h
 #align part_enat.lt_add_one_iff_lt PartENat.lt_add_one_iff_lt
 
-lemma lt_coe_succ_iff_le {x : PartENat} {n : ℕ} (hx : x ≠ ⊤) : x < n.succ ↔ x ≤ n :=
-by rw [Nat.succ_eq_add_one n, Nat.cast_add, Nat.cast_one, lt_add_one_iff_lt hx]
+lemma lt_coe_succ_iff_le {x : PartENat} {n : ℕ} (hx : x ≠ ⊤) : x < n.succ ↔ x ≤ n := by
+  rw [Nat.succ_eq_add_one n, Nat.cast_add, Nat.cast_one, lt_add_one_iff_lt hx]
 #align part_enat.lt_coe_succ_iff_le PartENat.lt_coe_succ_iff_le
 
 theorem add_eq_top_iff {a b : PartENat} : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ := by
@@ -767,9 +767,9 @@ theorem lt_wf : @WellFounded PartENat (· < ·) := by
 instance : WellFoundedLT PartENat :=
   ⟨lt_wf⟩
 
-instance isWellOrder: IsWellOrder PartENat (· < ·) := {}
+instance isWellOrder : IsWellOrder PartENat (· < ·) := {}
 
-instance wellFoundedRelation: WellFoundedRelation PartENat :=
+instance wellFoundedRelation : WellFoundedRelation PartENat :=
   ⟨(· < ·), lt_wf⟩
 
 section Find

3ff3f2d6

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
-
-! This file was ported from Lean 3 source module data.nat.part_enat
-! leanprover-community/mathlib commit 3ff3f2d6a3118b8711063de7111a0d77a53219a8
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Hom.Equiv.Basic
 import Mathlib.Data.Part
 import Mathlib.Data.ENat.Lattice
 import Mathlib.Tactic.NormNum
 
+#align_import data.nat.part_enat from "leanprover-community/mathlib"@"3ff3f2d6a3118b8711063de7111a0d77a53219a8"
+
 /-!
 # Natural numbers with infinity

3ff3f2d6

feat:add correct SHA to earlier PR (#5799)

Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr>

5d83d804

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 
 ! This file was ported from Lean 3 source module data.nat.part_enat
-! leanprover-community/mathlib commit 114ff8a4a7935cb7531062200bff375e7b1d6d85
+! leanprover-community/mathlib commit 3ff3f2d6a3118b8711063de7111a0d77a53219a8
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

114ff8a4

feat(SetTheory/Cardinal/Finite): prove lemmas about PartENat.card (#5307)

Prove lemmas to handle PartENat.card Inspired from the similar lemmas for Nat.card This is a mathlib4 companion to the PR #19198 of mathlib3

Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr>

9f3a6c79

Diff

@@ -511,6 +511,10 @@ theorem add_one_le_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x + 1 ≤ y ↔ x
   norm_cast; apply Nat.lt_of_succ_le; norm_cast at h
 #align part_enat.add_one_le_iff_lt PartENat.add_one_le_iff_lt
 
+theorem coe_succ_le_iff {n : ℕ} {e : PartENat} : ↑n.succ ≤ e ↔ ↑n < e:= by
+  rw [Nat.succ_eq_add_one n, Nat.cast_add, Nat.cast_one, add_one_le_iff_lt (natCast_ne_top n)]
+#align part_enat.coe_succ_le_succ_iff PartENat.coe_succ_le_iff
+
 theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x ≤ y := by
   refine ⟨le_of_lt_add_one, fun h => ?_⟩
   rcases ne_top_iff.mp hx with ⟨m, rfl⟩
@@ -521,6 +525,10 @@ theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x 
   norm_cast; apply Nat.lt_succ_of_le; norm_cast at h
 #align part_enat.lt_add_one_iff_lt PartENat.lt_add_one_iff_lt
 
+lemma lt_coe_succ_iff_le {x : PartENat} {n : ℕ} (hx : x ≠ ⊤) : x < n.succ ↔ x ≤ n :=
+by rw [Nat.succ_eq_add_one n, Nat.cast_add, Nat.cast_one, lt_add_one_iff_lt hx]
+#align part_enat.lt_coe_succ_iff_le PartENat.lt_coe_succ_iff_le
+
 theorem add_eq_top_iff {a b : PartENat} : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ := by
   refine PartENat.casesOn a ?_ ?_
   <;> refine PartENat.casesOn b ?_ ?_

114ff8a4

chore: tidy various files (#5449)

ff656fa9

Diff

@@ -382,9 +382,8 @@ theorem eq_top_iff_forall_lt (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : Part
   constructor
   · rintro rfl n
     exact natCast_lt_top _
-  · -- Porting note: was `contrapose!`
-    contrapose
-    rw [←Ne, ne_top_iff, not_forall]
+  · contrapose!
+    rw [ne_top_iff]
     rintro ⟨n, rfl⟩
     exact ⟨n, irrefl _⟩
 #align part_enat.eq_top_iff_forall_lt PartENat.eq_top_iff_forall_lt
@@ -792,10 +791,8 @@ theorem lt_find (n : ℕ) (h : ∀ m ≤ n, ¬P m) : (n : PartENat) < find P :=
   rw [find_get]
   have h₂ := @Nat.find_spec P _ h₁
   revert h₂
-  contrapose
-  intro h₂
-  rw [not_lt] at h₂
-  exact h _ h₂
+  contrapose!
+  exact h _
 #align part_enat.lt_find PartENat.lt_find
 
 theorem lt_find_iff (n : ℕ) : (n : PartENat) < find P ↔ ∀ m ≤ n, ¬P m := by

114ff8a4

chore: fix grammar 2/3 (#5002)

Part 2 of #5001

9e80ae3b

Diff

@@ -543,7 +543,7 @@ protected theorem add_left_cancel_iff {a b c : PartENat} (ha : a ≠ ⊤) : a +
 
 section WithTop
 
-/-- Computably converts an `PartENat` to a `ℕ∞`. -/
+/-- Computably converts a `PartENat` to a `ℕ∞`. -/
 def toWithTop (x : PartENat) [Decidable x.Dom] : ℕ∞ :=
   x.toOption
 #align part_enat.to_with_top PartENat.toWithTop

114ff8a4

chore: fix typos (#4518)

I ran codespell Mathlib and got tired halfway through the suggestions.

92beef58

Diff

@@ -624,7 +624,7 @@ theorem toWithTop_lt {x y : PartENat} [Decidable x.Dom] [Decidable y.Dom] :
 end WithTop
 
 -- Porting note : new, extracted from `withTopEquiv`.
-/-- Coersion from `ℕ∞` to `PartENat`. -/
+/-- Coercion from `ℕ∞` to `PartENat`. -/
 @[coe]
 def ofENat : ℕ∞ → PartENat :=
   fun x => match x with

114ff8a4

chore: fix upper/lowercase in comments (#4360)

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

27d257fc

Diff

@@ -16,7 +16,7 @@ import Mathlib.Tactic.NormNum
 /-!
 # Natural numbers with infinity
 
-The natural numbers and an extra `top` element `⊤`. This implementation uses `part ℕ` as an
+The natural numbers and an extra `top` element `⊤`. This implementation uses `Part ℕ` as an
 implementation. Use `ℕ∞` instead unless you care about computability.
 
 ## Main definitions

114ff8a4

fix: correct names of LinearOrder decidable fields (#4006)

This renames

decidable_eq to decidableEq
decidable_lt to decidableLT
decidable_le to decidableLE
decidableLT_of_decidableLE to decidableLTOfDecidableLE
decidableEq_of_decidableLE to decidableEqOfDecidableLE

These fields are data not proofs, so they should be lowerCamelCased.

e7280432

Diff

@@ -411,7 +411,7 @@ instance isTotal: IsTotal PartENat (· ≤ ·) where
 noncomputable instance linearOrder : LinearOrder PartENat :=
   { PartENat.partialOrder with
     le_total := IsTotal.total
-    decidable_le := Classical.decRel _
+    decidableLE := Classical.decRel _
     max := (· ⊔ ·)
     -- Porting note: was `max_def := @sup_eq_maxDefault _ _ (id _) _ }`
     max_def := fun a b => by

114ff8a4

chore: bye-bye, solo bys! (#3825)

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

14167e48

Diff

@@ -397,10 +397,9 @@ theorem eq_top_iff_forall_le (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : Part
 theorem pos_iff_one_le {x : PartENat} : 0 < x ↔ 1 ≤ x :=
   PartENat.casesOn x
     (by simp only [iff_true_iff, le_top, natCast_lt_top, ← @Nat.cast_zero PartENat])
-    fun n =>
-    by
-    rw [← Nat.cast_zero, ← Nat.cast_one, PartENat.coe_lt_coe, PartENat.coe_le_coe]
-    rfl
+    fun n => by
+      rw [← Nat.cast_zero, ← Nat.cast_one, PartENat.coe_lt_coe, PartENat.coe_le_coe]
+      rfl
 #align part_enat.pos_iff_one_le PartENat.pos_iff_one_le
 
 instance isTotal: IsTotal PartENat (· ≤ ·) where
@@ -409,7 +408,7 @@ instance isTotal: IsTotal PartENat (· ≤ ·) where
       (PartENat.casesOn y (fun _ => Or.inl le_top) fun x y =>
         (le_total x y).elim (Or.inr ∘ coe_le_coe.2) (Or.inl ∘ coe_le_coe.2))
 
-noncomputable instance linearOrder: LinearOrder PartENat :=
+noncomputable instance linearOrder : LinearOrder PartENat :=
   { PartENat.partialOrder with
     le_total := IsTotal.total
     decidable_le := Classical.decRel _

114ff8a4

fix: use Nat.lt_wfRel.wf instead of IsWellFounded.fix.proof_1 in PartENat.lt_wf (#2348)

Simplifies the proof and makes it more closely match the mathlib3 version.

Avoids using the proof_1 lemma, which is automatically generated by this code in core. It's probably bad style to directly use such things.

601c3f93

Diff

@@ -754,15 +754,11 @@ noncomputable def withTopAddEquiv : PartENat ≃+ ℕ∞ :=
 
 end WithTopEquiv
 
--- Porting note: `Nat.lt_wfRel` changed in core,
--- the last line of the mathlib3 proof was:
--- `exact InvImage.wf _ (WithTop.wellFounded_lt Nat.lt_wfRel)`
 theorem lt_wf : @WellFounded PartENat (· < ·) := by
   classical
     change WellFounded fun a b : PartENat => a < b
     simp_rw [← withTopEquiv_lt]
-    refine InvImage.wf _ (WithTop.wellFounded_lt ?_)
-    exact IsWellFounded.fix.proof_1 fun y x => y < x
+    exact InvImage.wf _ (WithTop.wellFounded_lt Nat.lt_wfRel.wf)
 #align part_enat.lt_wf PartENat.lt_wf
 
 instance : WellFoundedLT PartENat :=

114ff8a4

feat: sync Data.Nat.PartENat (#2670)

0a519846

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 
 ! This file was ported from Lean 3 source module data.nat.part_enat
-! leanprover-community/mathlib commit f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c
+! leanprover-community/mathlib commit 114ff8a4a7935cb7531062200bff375e7b1d6d85
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -121,6 +121,9 @@ theorem dom_natCast (x : ℕ) : (x : PartENat).Dom :=
   trivial
 #align part_enat.dom_coe PartENat.dom_natCast
 
+instance : CanLift PartENat ℕ (↑) Dom :=
+  ⟨fun n hn => ⟨n.get hn, Part.some_get _⟩⟩
+
 instance : LE PartENat :=
   ⟨fun x y => ∃ h : y.Dom → x.Dom, ∀ hy : y.Dom, x.get (h hy) ≤ y.get hy⟩
 
@@ -447,6 +450,14 @@ noncomputable instance : CanonicallyOrderedAddMonoid PartENat :=
           ⟨(b - a : ℕ), by
             rw [← Nat.cast_add, natCast_inj, add_comm, tsub_add_cancel_of_le (coe_le_coe.1 h)]⟩ }
 
+theorem eq_natCast_sub_of_add_eq_natCast {x y : PartENat} {n : ℕ} (h : x + y = n) :
+    x = ↑(n - y.get (dom_of_le_natCast ((le_add_left le_rfl).trans_eq h))) := by
+  lift x to ℕ using dom_of_le_natCast ((le_add_right le_rfl).trans_eq h)
+  lift y to ℕ using dom_of_le_natCast ((le_add_left le_rfl).trans_eq h)
+  rw [← Nat.cast_add, natCast_inj] at h
+  rw [get_natCast, natCast_inj, eq_tsub_of_add_eq h]
+#align part_enat.eq_coe_sub_of_add_eq_coe PartENat.eq_natCast_sub_of_add_eq_natCast
+
 protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ ⊤) : x + z < y + z := by
   rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
   rcases ne_top_iff.mp hz with ⟨k, rfl⟩

f7fc89d5

refactor: rename HasSup/HasInf to Sup/Inf (#2475)

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

294082ef

Diff

@@ -130,7 +130,7 @@ instance : Top PartENat :=
 instance : Bot PartENat :=
   ⟨0⟩
 
-instance : HasSup PartENat :=
+instance : Sup PartENat :=
   ⟨fun x y => ⟨x.Dom ∧ y.Dom, fun h => x.get h.1 ⊔ y.get h.2⟩⟩
 
 theorem le_def (x y : PartENat) :

f7fc89d5

feat: port Data.Nat.PartENat (#1892)

port of data.net.part_enat

Co-authored-by: Moritz Firsching <firsching@google.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Jon Eugster <eugster.jon@gmail.com>

60855258

`data.nat.part_enat` ⟷ `Mathlib.Data.Nat.PartENat`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 7 + 252

data.nat.part_enat ⟷ Mathlib.Data.Nat.PartENat

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 7 + 252

`data.nat.part_enat` ⟷ `Mathlib.Data.Nat.PartENat`