data.real.enat_ennreal | Mathlib porting status

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

53b216bc

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

ee05e9ce

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
-import Data.Enat.Basic
-import Data.Real.Ennreal
+import Data.ENat.Basic
+import Data.ENNReal.Basic
 
 #align_import data.real.enat_ennreal from "leanprover-community/mathlib"@"ee05e9ce1322178f0c12004eb93c00d2c8c00ed2"

ee05e9ce

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
-import Mathbin.Data.Enat.Basic
-import Mathbin.Data.Real.Ennreal
+import Data.Enat.Basic
+import Data.Real.Ennreal
 
 #align_import data.real.enat_ennreal from "leanprover-community/mathlib"@"ee05e9ce1322178f0c12004eb93c00d2c8c00ed2"

ee05e9ce

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module data.real.enat_ennreal
-! leanprover-community/mathlib commit ee05e9ce1322178f0c12004eb93c00d2c8c00ed2
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Enat.Basic
 import Mathbin.Data.Real.Ennreal
 
+#align_import data.real.enat_ennreal from "leanprover-community/mathlib"@"ee05e9ce1322178f0c12004eb93c00d2c8c00ed2"
+
 /-!
 # Coercion from `ℕ∞` to `ℝ≥0∞`

ee05e9ce

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -29,9 +29,11 @@ namespace ENat
 
 variable {m n : ℕ∞}
 
+#print ENat.hasCoeENNReal /-
 instance hasCoeENNReal : CoeTC ℕ∞ ℝ≥0∞ :=
   ⟨WithTop.map coe⟩
 #align enat.has_coe_ennreal ENat.hasCoeENNReal
+-/
 
 #print ENat.map_coe_nnreal /-
 @[simp]
@@ -40,22 +42,28 @@ theorem map_coe_nnreal : WithTop.map (coe : ℕ → ℝ≥0) = (coe : ℕ∞ →
 #align enat.map_coe_nnreal ENat.map_coe_nnreal
 -/
 
+#print ENat.toENNRealOrderEmbedding /-
 /-- Coercion `ℕ∞ → ℝ≥0∞` as an `order_embedding`. -/
 @[simps (config := { fullyApplied := false })]
 def toENNRealOrderEmbedding : ℕ∞ ↪o ℝ≥0∞ :=
   Nat.castOrderEmbedding.withTop_map
 #align enat.to_ennreal_order_embedding ENat.toENNRealOrderEmbedding
+-/
 
+#print ENat.toENNRealRingHom /-
 /-- Coercion `ℕ∞ → ℝ≥0∞` as a ring homomorphism. -/
 @[simps (config := { fullyApplied := false })]
 def toENNRealRingHom : ℕ∞ →+* ℝ≥0∞ :=
   (Nat.castRingHom ℝ≥0).withTop_map Nat.cast_injective
 #align enat.to_ennreal_ring_hom ENat.toENNRealRingHom
+-/
 
+#print ENat.toENNReal_top /-
 @[simp, norm_cast]
 theorem toENNReal_top : ((⊤ : ℕ∞) : ℝ≥0∞) = ⊤ :=
   rfl
 #align enat.coe_ennreal_top ENat.toENNReal_top
+-/
 
 #print ENat.toENNReal_coe /-
 @[simp, norm_cast]
@@ -64,35 +72,47 @@ theorem toENNReal_coe (n : ℕ) : ((n : ℕ∞) : ℝ≥0∞) = n :=
 #align enat.coe_ennreal_coe ENat.toENNReal_coe
 -/
 
+#print ENat.toENNReal_le /-
 @[simp, norm_cast]
 theorem toENNReal_le : (m : ℝ≥0∞) ≤ n ↔ m ≤ n :=
   toENNRealOrderEmbedding.le_iff_le
 #align enat.coe_ennreal_le ENat.toENNReal_le
+-/
 
+#print ENat.toENNReal_lt /-
 @[simp, norm_cast]
 theorem toENNReal_lt : (m : ℝ≥0∞) < n ↔ m < n :=
   toENNRealOrderEmbedding.lt_iff_lt
 #align enat.coe_ennreal_lt ENat.toENNReal_lt
+-/
 
+#print ENat.toENNReal_mono /-
 @[mono]
 theorem toENNReal_mono : Monotone (coe : ℕ∞ → ℝ≥0∞) :=
   toENNRealOrderEmbedding.Monotone
 #align enat.coe_ennreal_mono ENat.toENNReal_mono
+-/
 
+#print ENat.toENNReal_strictMono /-
 @[mono]
 theorem toENNReal_strictMono : StrictMono (coe : ℕ∞ → ℝ≥0∞) :=
   toENNRealOrderEmbedding.StrictMono
 #align enat.coe_ennreal_strict_mono ENat.toENNReal_strictMono
+-/
 
+#print ENat.toENNReal_zero /-
 @[simp, norm_cast]
 theorem toENNReal_zero : ((0 : ℕ∞) : ℝ≥0∞) = 0 :=
   map_zero toENNRealRingHom
 #align enat.coe_ennreal_zero ENat.toENNReal_zero
+-/
 
+#print ENat.toENNReal_add /-
 @[simp]
 theorem toENNReal_add (m n : ℕ∞) : ↑(m + n) = (m + n : ℝ≥0∞) :=
   map_add toENNRealRingHom m n
 #align enat.coe_ennreal_add ENat.toENNReal_add
+-/
 
 #print ENat.toENNReal_one /-
 @[simp]
@@ -111,25 +131,33 @@ theorem coe_eNNReal_bit1 (n : ℕ∞) : ↑(bit1 n) = bit1 (n : ℝ≥0∞) :=
   map_bit1 toENNRealRingHom n
 #align enat.coe_ennreal_bit1 ENat.coe_eNNReal_bit1
 
+#print ENat.toENNReal_mul /-
 @[simp]
 theorem toENNReal_mul (m n : ℕ∞) : ↑(m * n) = (m * n : ℝ≥0∞) :=
   map_mul toENNRealRingHom m n
 #align enat.coe_ennreal_mul ENat.toENNReal_mul
+-/
 
+#print ENat.toENNReal_min /-
 @[simp]
 theorem toENNReal_min (m n : ℕ∞) : ↑(min m n) = (min m n : ℝ≥0∞) :=
   toENNReal_mono.map_min
 #align enat.coe_ennreal_min ENat.toENNReal_min
+-/
 
+#print ENat.toENNReal_max /-
 @[simp]
 theorem toENNReal_max (m n : ℕ∞) : ↑(max m n) = (max m n : ℝ≥0∞) :=
   toENNReal_mono.map_max
 #align enat.coe_ennreal_max ENat.toENNReal_max
+-/
 
+#print ENat.toENNReal_sub /-
 @[simp]
 theorem toENNReal_sub (m n : ℕ∞) : ↑(m - n) = (m - n : ℝ≥0∞) :=
   WithTop.map_sub Nat.cast_tsub Nat.cast_zero m n
 #align enat.coe_ennreal_sub ENat.toENNReal_sub
+-/
 
 end ENat

ee05e9ce

bump to nightly-2023-06-01-04

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

4d9eaa85

Diff

@@ -101,19 +101,15 @@ theorem toENNReal_one : ((1 : ℕ∞) : ℝ≥0∞) = 1 :=
 #align enat.coe_ennreal_one ENat.toENNReal_one
 -/
 
-/- warning: enat.coe_ennreal_bit0 clashes with [anonymous] -> [anonymous]
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_bit0 [anonymous]ₓ'. -/
 @[simp]
-theorem [anonymous] (n : ℕ∞) : ↑(bit0 n) = bit0 (n : ℝ≥0∞) :=
+theorem coe_eNNReal_bit0 (n : ℕ∞) : ↑(bit0 n) = bit0 (n : ℝ≥0∞) :=
   toENNReal_add n n
-#align enat.coe_ennreal_bit0 [anonymous]
+#align enat.coe_ennreal_bit0 ENat.coe_eNNReal_bit0
 
-/- warning: enat.coe_ennreal_bit1 clashes with [anonymous] -> [anonymous]
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_bit1 [anonymous]ₓ'. -/
 @[simp]
-theorem [anonymous] (n : ℕ∞) : ↑(bit1 n) = bit1 (n : ℝ≥0∞) :=
+theorem coe_eNNReal_bit1 (n : ℕ∞) : ↑(bit1 n) = bit1 (n : ℝ≥0∞) :=
   map_bit1 toENNRealRingHom n
-#align enat.coe_ennreal_bit1 [anonymous]
+#align enat.coe_ennreal_bit1 ENat.coe_eNNReal_bit1
 
 @[simp]
 theorem toENNReal_mul (m n : ℕ∞) : ↑(m * n) = (m * n : ℝ≥0∞) :=

ee05e9ce

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -21,7 +21,7 @@ In this file we define a coercion from `ℕ∞` to `ℝ≥0∞` and prove some b
 -/
 
 
-open Classical NNReal ENNReal
+open scoped Classical NNReal ENNReal
 
 noncomputable section

ee05e9ce

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -29,12 +29,6 @@ namespace ENat
 
 variable {m n : ℕ∞}
 
-/- warning: enat.has_coe_ennreal -> ENat.hasCoeENNReal is a dubious translation:
-lean 3 declaration is
-  CoeTCₓ.{1, 1} ENat ENNReal
-but is expected to have type
-  CoeTC.{1, 1} ENat ENNReal
-Case conversion may be inaccurate. Consider using '#align enat.has_coe_ennreal ENat.hasCoeENNRealₓ'. -/
 instance hasCoeENNReal : CoeTC ℕ∞ ℝ≥0∞ :=
   ⟨WithTop.map coe⟩
 #align enat.has_coe_ennreal ENat.hasCoeENNReal
@@ -46,36 +40,18 @@ theorem map_coe_nnreal : WithTop.map (coe : ℕ → ℝ≥0) = (coe : ℕ∞ →
 #align enat.map_coe_nnreal ENat.map_coe_nnreal
 -/
 
-/- warning: enat.to_ennreal_order_embedding -> ENat.toENNRealOrderEmbedding is a dubious translation:
-lean 3 declaration is
-  OrderEmbedding.{0, 0} ENat ENNReal (Preorder.toHasLe.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))))
-but is expected to have type
-  OrderEmbedding.{0, 0} ENat ENNReal (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring))))) (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))))
-Case conversion may be inaccurate. Consider using '#align enat.to_ennreal_order_embedding ENat.toENNRealOrderEmbeddingₓ'. -/
 /-- Coercion `ℕ∞ → ℝ≥0∞` as an `order_embedding`. -/
 @[simps (config := { fullyApplied := false })]
 def toENNRealOrderEmbedding : ℕ∞ ↪o ℝ≥0∞ :=
   Nat.castOrderEmbedding.withTop_map
 #align enat.to_ennreal_order_embedding ENat.toENNRealOrderEmbedding
 
-/- warning: enat.to_ennreal_ring_hom -> ENat.toENNRealRingHom is a dubious translation:
-lean 3 declaration is
-  RingHom.{0, 0} ENat ENNReal (Semiring.toNonAssocSemiring.{0} ENat (OrderedSemiring.toSemiring.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))) (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))
-but is expected to have type
-  RingHom.{0, 0} ENat ENNReal (Semiring.toNonAssocSemiring.{0} ENat (OrderedSemiring.toSemiring.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring)))) (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))))
-Case conversion may be inaccurate. Consider using '#align enat.to_ennreal_ring_hom ENat.toENNRealRingHomₓ'. -/
 /-- Coercion `ℕ∞ → ℝ≥0∞` as a ring homomorphism. -/
 @[simps (config := { fullyApplied := false })]
 def toENNRealRingHom : ℕ∞ →+* ℝ≥0∞ :=
   (Nat.castRingHom ℝ≥0).withTop_map Nat.cast_injective
 #align enat.to_ennreal_ring_hom ENat.toENNRealRingHom
 
-/- warning: enat.coe_ennreal_top -> ENat.toENNReal_top is a dubious translation:
-lean 3 declaration is
-  Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (Top.top.{0} ENat ENat.hasTop)) (Top.top.{0} ENNReal (CompleteLattice.toHasTop.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))
-but is expected to have type
-  Eq.{1} ENNReal (ENat.toENNReal (Top.top.{0} ENat instENatTop)) (Top.top.{0} ENNReal (CompleteLattice.toTop.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_top ENat.toENNReal_topₓ'. -/
 @[simp, norm_cast]
 theorem toENNReal_top : ((⊤ : ℕ∞) : ℝ≥0∞) = ⊤ :=
   rfl
@@ -88,67 +64,31 @@ theorem toENNReal_coe (n : ℕ) : ((n : ℕ∞) : ℝ≥0∞) = n :=
 #align enat.coe_ennreal_coe ENat.toENNReal_coe
 -/
 
-/- warning: enat.coe_ennreal_le -> ENat.toENNReal_le is a dubious translation:
-lean 3 declaration is
-  forall {m : ENat} {n : ENat}, Iff (LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n)) (LE.le.{0} ENat (Preorder.toHasLe.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) m n)
-but is expected to have type
-  forall {m : ENat} {n : ENat}, Iff (LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENat.toENNReal m) (ENat.toENNReal n)) (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))))) m n)
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_le ENat.toENNReal_leₓ'. -/
 @[simp, norm_cast]
 theorem toENNReal_le : (m : ℝ≥0∞) ≤ n ↔ m ≤ n :=
   toENNRealOrderEmbedding.le_iff_le
 #align enat.coe_ennreal_le ENat.toENNReal_le
 
-/- warning: enat.coe_ennreal_lt -> ENat.toENNReal_lt is a dubious translation:
-lean 3 declaration is
-  forall {m : ENat} {n : ENat}, Iff (LT.lt.{0} ENNReal (Preorder.toHasLt.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n)) (LT.lt.{0} ENat (Preorder.toHasLt.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) m n)
-but is expected to have type
-  forall {m : ENat} {n : ENat}, Iff (LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENat.toENNReal m) (ENat.toENNReal n)) (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))))) m n)
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_lt ENat.toENNReal_ltₓ'. -/
 @[simp, norm_cast]
 theorem toENNReal_lt : (m : ℝ≥0∞) < n ↔ m < n :=
   toENNRealOrderEmbedding.lt_iff_lt
 #align enat.coe_ennreal_lt ENat.toENNReal_lt
 
-/- warning: enat.coe_ennreal_mono -> ENat.toENNReal_mono is a dubious translation:
-lean 3 declaration is
-  Monotone.{0, 0} ENat ENNReal (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring))))) (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)))
-but is expected to have type
-  Monotone.{0, 0} ENat ENNReal (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring)))) (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))) ENat.toENNReal
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_mono ENat.toENNReal_monoₓ'. -/
 @[mono]
 theorem toENNReal_mono : Monotone (coe : ℕ∞ → ℝ≥0∞) :=
   toENNRealOrderEmbedding.Monotone
 #align enat.coe_ennreal_mono ENat.toENNReal_mono
 
-/- warning: enat.coe_ennreal_strict_mono -> ENat.toENNReal_strictMono is a dubious translation:
-lean 3 declaration is
-  StrictMono.{0, 0} ENat ENNReal (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring))))) (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)))
-but is expected to have type
-  StrictMono.{0, 0} ENat ENNReal (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring)))) (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))) ENat.toENNReal
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_strict_mono ENat.toENNReal_strictMonoₓ'. -/
 @[mono]
 theorem toENNReal_strictMono : StrictMono (coe : ℕ∞ → ℝ≥0∞) :=
   toENNRealOrderEmbedding.StrictMono
 #align enat.coe_ennreal_strict_mono ENat.toENNReal_strictMono
 
-/- warning: enat.coe_ennreal_zero -> ENat.toENNReal_zero is a dubious translation:
-lean 3 declaration is
-  Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (OfNat.ofNat.{0} ENat 0 (OfNat.mk.{0} ENat 0 (Zero.zero.{0} ENat ENat.hasZero)))) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))
-but is expected to have type
-  Eq.{1} ENNReal (ENat.toENNReal (OfNat.ofNat.{0} ENat 0 (Zero.toOfNat0.{0} ENat instENatZero))) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_zero ENat.toENNReal_zeroₓ'. -/
 @[simp, norm_cast]
 theorem toENNReal_zero : ((0 : ℕ∞) : ℝ≥0∞) = 0 :=
   map_zero toENNRealRingHom
 #align enat.coe_ennreal_zero ENat.toENNReal_zero
 
-/- warning: enat.coe_ennreal_add -> ENat.toENNReal_add is a dubious translation:
-lean 3 declaration is
-  forall (m : ENat) (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (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)))))))) m n)) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
-but is expected to have type
-  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (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)))))))) m n)) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))))) (ENat.toENNReal m) (ENat.toENNReal n))
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_add ENat.toENNReal_addₓ'. -/
 @[simp]
 theorem toENNReal_add (m n : ℕ∞) : ↑(m + n) = (m + n : ℝ≥0∞) :=
   map_add toENNRealRingHom m n
@@ -162,11 +102,6 @@ theorem toENNReal_one : ((1 : ℕ∞) : ℝ≥0∞) = 1 :=
 -/
 
 /- warning: enat.coe_ennreal_bit0 clashes with [anonymous] -> [anonymous]
-warning: enat.coe_ennreal_bit0 -> [anonymous] is a dubious translation:
-lean 3 declaration is
-  forall (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (bit0.{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))))))) n)) (bit0.{0} ENNReal (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
-but is expected to have type
-  forall {n : Type.{u}} {β : Type.{v}}, (Nat -> n -> β) -> Nat -> (List.{u} n) -> (List.{v} β)
 Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_bit0 [anonymous]ₓ'. -/
 @[simp]
 theorem [anonymous] (n : ℕ∞) : ↑(bit0 n) = bit0 (n : ℝ≥0∞) :=
@@ -174,56 +109,27 @@ theorem [anonymous] (n : ℕ∞) : ↑(bit0 n) = bit0 (n : ℝ≥0∞) :=
 #align enat.coe_ennreal_bit0 [anonymous]
 
 /- warning: enat.coe_ennreal_bit1 clashes with [anonymous] -> [anonymous]
-warning: enat.coe_ennreal_bit1 -> [anonymous] is a dubious translation:
-lean 3 declaration is
-  forall (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (bit1.{0} ENat (AddMonoidWithOne.toOne.{0} ENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENat ENat.addCommMonoidWithOne)) (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))))))) n)) (bit1.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne)) (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
-but is expected to have type
-  forall {n : Type.{u}} {β : Type.{v}}, (Nat -> n -> β) -> Nat -> (List.{u} n) -> (List.{v} β)
 Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_bit1 [anonymous]ₓ'. -/
 @[simp]
 theorem [anonymous] (n : ℕ∞) : ↑(bit1 n) = bit1 (n : ℝ≥0∞) :=
   map_bit1 toENNRealRingHom n
 #align enat.coe_ennreal_bit1 [anonymous]
 
-/- warning: enat.coe_ennreal_mul -> ENat.toENNReal_mul is a dubious translation:
-lean 3 declaration is
-  forall (m : ENat) (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (HMul.hMul.{0, 0, 0} ENat ENat ENat (instHMul.{0} ENat (Distrib.toHasMul.{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)))))))) m n)) (HMul.hMul.{0, 0, 0} ENNReal ENNReal ENNReal (instHMul.{0} ENNReal (Distrib.toHasMul.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
-but is expected to have type
-  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (HMul.hMul.{0, 0, 0} ENat ENat ENat (instHMul.{0} ENat (CanonicallyOrderedCommSemiring.toMul.{0} ENat instENatCanonicallyOrderedCommSemiring)) m n)) (HMul.hMul.{0, 0, 0} ENNReal ENNReal ENNReal (instHMul.{0} ENNReal (CanonicallyOrderedCommSemiring.toMul.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)) (ENat.toENNReal m) (ENat.toENNReal n))
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_mul ENat.toENNReal_mulₓ'. -/
 @[simp]
 theorem toENNReal_mul (m n : ℕ∞) : ↑(m * n) = (m * n : ℝ≥0∞) :=
   map_mul toENNRealRingHom m n
 #align enat.coe_ennreal_mul ENat.toENNReal_mul
 
-/- warning: enat.coe_ennreal_min -> ENat.toENNReal_min is a dubious translation:
-lean 3 declaration is
-  forall (m : ENat) (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (LinearOrder.min.{0} ENat ENat.linearOrder m n)) (LinearOrder.min.{0} ENNReal (ConditionallyCompleteLinearOrder.toLinearOrder.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.completeLinearOrder))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
-but is expected to have type
-  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (Min.min.{0} ENat (CanonicallyLinearOrderedAddMonoid.toMin.{0} ENat instENatCanonicallyLinearOrderedAddMonoid) m n)) (Min.min.{0} ENNReal (CanonicallyLinearOrderedAddMonoid.toMin.{0} ENNReal ENNReal.instCanonicallyLinearOrderedAddMonoidENNReal) (ENat.toENNReal m) (ENat.toENNReal n))
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_min ENat.toENNReal_minₓ'. -/
 @[simp]
 theorem toENNReal_min (m n : ℕ∞) : ↑(min m n) = (min m n : ℝ≥0∞) :=
   toENNReal_mono.map_min
 #align enat.coe_ennreal_min ENat.toENNReal_min
 
-/- warning: enat.coe_ennreal_max -> ENat.toENNReal_max is a dubious translation:
-lean 3 declaration is
-  forall (m : ENat) (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (LinearOrder.max.{0} ENat ENat.linearOrder m n)) (LinearOrder.max.{0} ENNReal (ConditionallyCompleteLinearOrder.toLinearOrder.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.completeLinearOrder))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
-but is expected to have type
-  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (Max.max.{0} ENat (CanonicallyLinearOrderedAddMonoid.toMax.{0} ENat instENatCanonicallyLinearOrderedAddMonoid) m n)) (Max.max.{0} ENNReal (CanonicallyLinearOrderedAddMonoid.toMax.{0} ENNReal ENNReal.instCanonicallyLinearOrderedAddMonoidENNReal) (ENat.toENNReal m) (ENat.toENNReal n))
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_max ENat.toENNReal_maxₓ'. -/
 @[simp]
 theorem toENNReal_max (m n : ℕ∞) : ↑(max m n) = (max m n : ℝ≥0∞) :=
   toENNReal_mono.map_max
 #align enat.coe_ennreal_max ENat.toENNReal_max
 
-/- warning: enat.coe_ennreal_sub -> ENat.toENNReal_sub is a dubious translation:
-lean 3 declaration is
-  forall (m : ENat) (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (HSub.hSub.{0, 0, 0} ENat ENat ENat (instHSub.{0} ENat ENat.hasSub) m n)) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.hasSub) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
-but is expected to have type
-  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (HSub.hSub.{0, 0, 0} ENat ENat ENat (instHSub.{0} ENat instENatSub) m n)) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.instSub) (ENat.toENNReal m) (ENat.toENNReal n))
-Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_sub ENat.toENNReal_subₓ'. -/
 @[simp]
 theorem toENNReal_sub (m n : ℕ∞) : ↑(m - n) = (m - n : ℝ≥0∞) :=
   WithTop.map_sub Nat.cast_tsub Nat.cast_zero m n

ee05e9ce

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -48,7 +48,7 @@ theorem map_coe_nnreal : WithTop.map (coe : ℕ → ℝ≥0) = (coe : ℕ∞ →
 
 /- warning: enat.to_ennreal_order_embedding -> ENat.toENNRealOrderEmbedding is a dubious translation:
 lean 3 declaration is
-  OrderEmbedding.{0, 0} ENat ENNReal (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)))))) (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))))
+  OrderEmbedding.{0, 0} ENat ENNReal (Preorder.toHasLe.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))))
 but is expected to have type
   OrderEmbedding.{0, 0} ENat ENNReal (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring))))) (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))))
 Case conversion may be inaccurate. Consider using '#align enat.to_ennreal_order_embedding ENat.toENNRealOrderEmbeddingₓ'. -/
@@ -90,7 +90,7 @@ theorem toENNReal_coe (n : ℕ) : ((n : ℕ∞) : ℝ≥0∞) = n :=
 
 /- warning: enat.coe_ennreal_le -> ENat.toENNReal_le is a dubious translation:
 lean 3 declaration is
-  forall {m : ENat} {n : ENat}, Iff (LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n)) (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)))))) m n)
+  forall {m : ENat} {n : ENat}, Iff (LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n)) (LE.le.{0} ENat (Preorder.toHasLe.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) m n)
 but is expected to have type
   forall {m : ENat} {n : ENat}, Iff (LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENat.toENNReal m) (ENat.toENNReal n)) (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))))) m n)
 Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_le ENat.toENNReal_leₓ'. -/
@@ -101,7 +101,7 @@ theorem toENNReal_le : (m : ℝ≥0∞) ≤ n ↔ m ≤ n :=
 
 /- warning: enat.coe_ennreal_lt -> ENat.toENNReal_lt is a dubious translation:
 lean 3 declaration is
-  forall {m : ENat} {n : ENat}, Iff (LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n)) (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)))))) m n)
+  forall {m : ENat} {n : ENat}, Iff (LT.lt.{0} ENNReal (Preorder.toHasLt.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n)) (LT.lt.{0} ENat (Preorder.toHasLt.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))))) m n)
 but is expected to have type
   forall {m : ENat} {n : ENat}, Iff (LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENat.toENNReal m) (ENat.toENNReal n)) (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))))) m n)
 Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_lt ENat.toENNReal_ltₓ'. -/

ee05e9ce

bump to nightly-2023-05-15-12

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

f3ad2973

Diff

@@ -222,7 +222,7 @@ theorem toENNReal_max (m n : ℕ∞) : ↑(max m n) = (max m n : ℝ≥0∞) :=
 lean 3 declaration is
   forall (m : ENat) (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (HSub.hSub.{0, 0, 0} ENat ENat ENat (instHSub.{0} ENat ENat.hasSub) m n)) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.hasSub) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
 but is expected to have type
-  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (HSub.hSub.{0, 0, 0} ENat ENat ENat (instHSub.{0} ENat instENatSub) m n)) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.instSubENNReal) (ENat.toENNReal m) (ENat.toENNReal n))
+  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (HSub.hSub.{0, 0, 0} ENat ENat ENat (instHSub.{0} ENat instENatSub) m n)) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.instSub) (ENat.toENNReal m) (ENat.toENNReal n))
 Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_sub ENat.toENNReal_subₓ'. -/
 @[simp]
 theorem toENNReal_sub (m n : ℕ∞) : ↑(m - n) = (m - n : ℝ≥0∞) :=

ee05e9ce

bump to nightly-2023-03-02-03

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

db7421c3

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 
 ! This file was ported from Lean 3 source module data.real.enat_ennreal
-! leanprover-community/mathlib commit 53b216bcc1146df1c4a0a86877890ea9f1f01589
+! leanprover-community/mathlib commit ee05e9ce1322178f0c12004eb93c00d2c8c00ed2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Data.Real.Ennreal
 /-!
 # Coercion from `ℕ∞` to `ℝ≥0∞`
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we define a coercion from `ℕ∞` to `ℝ≥0∞` and prove some basic lemmas about this map.
 -/

53b216bc

bump to nightly-2023-02-28-22

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

1fb1623f

Diff

@@ -26,101 +26,205 @@ namespace ENat
 
 variable {m n : ℕ∞}
 
-instance hasCoeEnnreal : CoeTC ℕ∞ ℝ≥0∞ :=
+/- warning: enat.has_coe_ennreal -> ENat.hasCoeENNReal is a dubious translation:
+lean 3 declaration is
+  CoeTCₓ.{1, 1} ENat ENNReal
+but is expected to have type
+  CoeTC.{1, 1} ENat ENNReal
+Case conversion may be inaccurate. Consider using '#align enat.has_coe_ennreal ENat.hasCoeENNRealₓ'. -/
+instance hasCoeENNReal : CoeTC ℕ∞ ℝ≥0∞ :=
   ⟨WithTop.map coe⟩
-#align enat.has_coe_ennreal ENat.hasCoeEnnreal
+#align enat.has_coe_ennreal ENat.hasCoeENNReal
 
+#print ENat.map_coe_nnreal /-
 @[simp]
-theorem map_coe_nNReal : WithTop.map (coe : ℕ → ℝ≥0) = (coe : ℕ∞ → ℝ≥0∞) :=
+theorem map_coe_nnreal : WithTop.map (coe : ℕ → ℝ≥0) = (coe : ℕ∞ → ℝ≥0∞) :=
   rfl
-#align enat.map_coe_nnreal ENat.map_coe_nNReal
+#align enat.map_coe_nnreal ENat.map_coe_nnreal
+-/
 
+/- warning: enat.to_ennreal_order_embedding -> ENat.toENNRealOrderEmbedding is a dubious translation:
+lean 3 declaration is
+  OrderEmbedding.{0, 0} ENat ENNReal (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)))))) (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))))
+but is expected to have type
+  OrderEmbedding.{0, 0} ENat ENNReal (Preorder.toLE.{0} ENat (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring))))) (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))))
+Case conversion may be inaccurate. Consider using '#align enat.to_ennreal_order_embedding ENat.toENNRealOrderEmbeddingₓ'. -/
 /-- Coercion `ℕ∞ → ℝ≥0∞` as an `order_embedding`. -/
 @[simps (config := { fullyApplied := false })]
-def toEnnrealOrderEmbedding : ℕ∞ ↪o ℝ≥0∞ :=
+def toENNRealOrderEmbedding : ℕ∞ ↪o ℝ≥0∞ :=
   Nat.castOrderEmbedding.withTop_map
-#align enat.to_ennreal_order_embedding ENat.toEnnrealOrderEmbedding
-
+#align enat.to_ennreal_order_embedding ENat.toENNRealOrderEmbedding
+
+/- warning: enat.to_ennreal_ring_hom -> ENat.toENNRealRingHom is a dubious translation:
+lean 3 declaration is
+  RingHom.{0, 0} ENat ENNReal (Semiring.toNonAssocSemiring.{0} ENat (OrderedSemiring.toSemiring.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring)))) (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))
+but is expected to have type
+  RingHom.{0, 0} ENat ENNReal (Semiring.toNonAssocSemiring.{0} ENat (OrderedSemiring.toSemiring.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring)))) (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))))
+Case conversion may be inaccurate. Consider using '#align enat.to_ennreal_ring_hom ENat.toENNRealRingHomₓ'. -/
 /-- Coercion `ℕ∞ → ℝ≥0∞` as a ring homomorphism. -/
 @[simps (config := { fullyApplied := false })]
-def toEnnrealRingHom : ℕ∞ →+* ℝ≥0∞ :=
+def toENNRealRingHom : ℕ∞ →+* ℝ≥0∞ :=
   (Nat.castRingHom ℝ≥0).withTop_map Nat.cast_injective
-#align enat.to_ennreal_ring_hom ENat.toEnnrealRingHom
-
+#align enat.to_ennreal_ring_hom ENat.toENNRealRingHom
+
+/- warning: enat.coe_ennreal_top -> ENat.toENNReal_top is a dubious translation:
+lean 3 declaration is
+  Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (Top.top.{0} ENat ENat.hasTop)) (Top.top.{0} ENNReal (CompleteLattice.toHasTop.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))
+but is expected to have type
+  Eq.{1} ENNReal (ENat.toENNReal (Top.top.{0} ENat instENatTop)) (Top.top.{0} ENNReal (CompleteLattice.toTop.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_top ENat.toENNReal_topₓ'. -/
 @[simp, norm_cast]
-theorem coe_eNNReal_top : ((⊤ : ℕ∞) : ℝ≥0∞) = ⊤ :=
+theorem toENNReal_top : ((⊤ : ℕ∞) : ℝ≥0∞) = ⊤ :=
   rfl
-#align enat.coe_ennreal_top ENat.coe_eNNReal_top
+#align enat.coe_ennreal_top ENat.toENNReal_top
 
+#print ENat.toENNReal_coe /-
 @[simp, norm_cast]
-theorem coe_eNNReal_coe (n : ℕ) : ((n : ℕ∞) : ℝ≥0∞) = n :=
+theorem toENNReal_coe (n : ℕ) : ((n : ℕ∞) : ℝ≥0∞) = n :=
   rfl
-#align enat.coe_ennreal_coe ENat.coe_eNNReal_coe
+#align enat.coe_ennreal_coe ENat.toENNReal_coe
+-/
 
+/- warning: enat.coe_ennreal_le -> ENat.toENNReal_le is a dubious translation:
+lean 3 declaration is
+  forall {m : ENat} {n : ENat}, Iff (LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n)) (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)))))) m n)
+but is expected to have type
+  forall {m : ENat} {n : ENat}, Iff (LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENat.toENNReal m) (ENat.toENNReal n)) (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))))) m n)
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_le ENat.toENNReal_leₓ'. -/
 @[simp, norm_cast]
-theorem coe_eNNReal_le : (m : ℝ≥0∞) ≤ n ↔ m ≤ n :=
-  toEnnrealOrderEmbedding.le_iff_le
-#align enat.coe_ennreal_le ENat.coe_eNNReal_le
-
+theorem toENNReal_le : (m : ℝ≥0∞) ≤ n ↔ m ≤ n :=
+  toENNRealOrderEmbedding.le_iff_le
+#align enat.coe_ennreal_le ENat.toENNReal_le
+
+/- warning: enat.coe_ennreal_lt -> ENat.toENNReal_lt is a dubious translation:
+lean 3 declaration is
+  forall {m : ENat} {n : ENat}, Iff (LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n)) (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)))))) m n)
+but is expected to have type
+  forall {m : ENat} {n : ENat}, Iff (LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENat.toENNReal m) (ENat.toENNReal n)) (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))))) m n)
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_lt ENat.toENNReal_ltₓ'. -/
 @[simp, norm_cast]
-theorem coe_eNNReal_lt : (m : ℝ≥0∞) < n ↔ m < n :=
-  toEnnrealOrderEmbedding.lt_iff_lt
-#align enat.coe_ennreal_lt ENat.coe_eNNReal_lt
-
+theorem toENNReal_lt : (m : ℝ≥0∞) < n ↔ m < n :=
+  toENNRealOrderEmbedding.lt_iff_lt
+#align enat.coe_ennreal_lt ENat.toENNReal_lt
+
+/- warning: enat.coe_ennreal_mono -> ENat.toENNReal_mono is a dubious translation:
+lean 3 declaration is
+  Monotone.{0, 0} ENat ENNReal (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring))))) (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)))
+but is expected to have type
+  Monotone.{0, 0} ENat ENNReal (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring)))) (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))) ENat.toENNReal
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_mono ENat.toENNReal_monoₓ'. -/
 @[mono]
-theorem coe_eNNReal_mono : Monotone (coe : ℕ∞ → ℝ≥0∞) :=
-  toEnnrealOrderEmbedding.Monotone
-#align enat.coe_ennreal_mono ENat.coe_eNNReal_mono
-
+theorem toENNReal_mono : Monotone (coe : ℕ∞ → ℝ≥0∞) :=
+  toENNRealOrderEmbedding.Monotone
+#align enat.coe_ennreal_mono ENat.toENNReal_mono
+
+/- warning: enat.coe_ennreal_strict_mono -> ENat.toENNReal_strictMono is a dubious translation:
+lean 3 declaration is
+  StrictMono.{0, 0} ENat ENNReal (PartialOrder.toPreorder.{0} ENat (OrderedAddCommMonoid.toPartialOrder.{0} ENat (OrderedSemiring.toOrderedAddCommMonoid.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat ENat.canonicallyOrderedCommSemiring))))) (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)))
+but is expected to have type
+  StrictMono.{0, 0} ENat ENNReal (PartialOrder.toPreorder.{0} ENat (OrderedSemiring.toPartialOrder.{0} ENat (OrderedCommSemiring.toOrderedSemiring.{0} ENat (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENat instENatCanonicallyOrderedCommSemiring)))) (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal)))) ENat.toENNReal
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_strict_mono ENat.toENNReal_strictMonoₓ'. -/
 @[mono]
-theorem coe_eNNReal_strictMono : StrictMono (coe : ℕ∞ → ℝ≥0∞) :=
-  toEnnrealOrderEmbedding.StrictMono
-#align enat.coe_ennreal_strict_mono ENat.coe_eNNReal_strictMono
-
+theorem toENNReal_strictMono : StrictMono (coe : ℕ∞ → ℝ≥0∞) :=
+  toENNRealOrderEmbedding.StrictMono
+#align enat.coe_ennreal_strict_mono ENat.toENNReal_strictMono
+
+/- warning: enat.coe_ennreal_zero -> ENat.toENNReal_zero is a dubious translation:
+lean 3 declaration is
+  Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (OfNat.ofNat.{0} ENat 0 (OfNat.mk.{0} ENat 0 (Zero.zero.{0} ENat ENat.hasZero)))) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))
+but is expected to have type
+  Eq.{1} ENNReal (ENat.toENNReal (OfNat.ofNat.{0} ENat 0 (Zero.toOfNat0.{0} ENat instENatZero))) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_zero ENat.toENNReal_zeroₓ'. -/
 @[simp, norm_cast]
-theorem coe_eNNReal_zero : ((0 : ℕ∞) : ℝ≥0∞) = 0 :=
-  map_zero toEnnrealRingHom
-#align enat.coe_ennreal_zero ENat.coe_eNNReal_zero
-
+theorem toENNReal_zero : ((0 : ℕ∞) : ℝ≥0∞) = 0 :=
+  map_zero toENNRealRingHom
+#align enat.coe_ennreal_zero ENat.toENNReal_zero
+
+/- warning: enat.coe_ennreal_add -> ENat.toENNReal_add is a dubious translation:
+lean 3 declaration is
+  forall (m : ENat) (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (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)))))))) m n)) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
+but is expected to have type
+  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (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)))))))) m n)) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))))) (ENat.toENNReal m) (ENat.toENNReal n))
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_add ENat.toENNReal_addₓ'. -/
 @[simp]
-theorem coe_eNNReal_add (m n : ℕ∞) : ↑(m + n) = (m + n : ℝ≥0∞) :=
-  map_add toEnnrealRingHom m n
-#align enat.coe_ennreal_add ENat.coe_eNNReal_add
+theorem toENNReal_add (m n : ℕ∞) : ↑(m + n) = (m + n : ℝ≥0∞) :=
+  map_add toENNRealRingHom m n
+#align enat.coe_ennreal_add ENat.toENNReal_add
 
+#print ENat.toENNReal_one /-
 @[simp]
-theorem coe_eNNReal_one : ((1 : ℕ∞) : ℝ≥0∞) = 1 :=
-  map_one toEnnrealRingHom
-#align enat.coe_ennreal_one ENat.coe_eNNReal_one
+theorem toENNReal_one : ((1 : ℕ∞) : ℝ≥0∞) = 1 :=
+  map_one toENNRealRingHom
+#align enat.coe_ennreal_one ENat.toENNReal_one
+-/
 
+/- warning: enat.coe_ennreal_bit0 clashes with [anonymous] -> [anonymous]
+warning: enat.coe_ennreal_bit0 -> [anonymous] is a dubious translation:
+lean 3 declaration is
+  forall (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (bit0.{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))))))) n)) (bit0.{0} ENNReal (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
+but is expected to have type
+  forall {n : Type.{u}} {β : Type.{v}}, (Nat -> n -> β) -> Nat -> (List.{u} n) -> (List.{v} β)
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_bit0 [anonymous]ₓ'. -/
 @[simp]
-theorem coe_eNNReal_bit0 (n : ℕ∞) : ↑(bit0 n) = bit0 (n : ℝ≥0∞) :=
-  coe_eNNReal_add n n
-#align enat.coe_ennreal_bit0 ENat.coe_eNNReal_bit0
-
+theorem [anonymous] (n : ℕ∞) : ↑(bit0 n) = bit0 (n : ℝ≥0∞) :=
+  toENNReal_add n n
+#align enat.coe_ennreal_bit0 [anonymous]
+
+/- warning: enat.coe_ennreal_bit1 clashes with [anonymous] -> [anonymous]
+warning: enat.coe_ennreal_bit1 -> [anonymous] is a dubious translation:
+lean 3 declaration is
+  forall (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (bit1.{0} ENat (AddMonoidWithOne.toOne.{0} ENat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENat ENat.addCommMonoidWithOne)) (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))))))) n)) (bit1.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne)) (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
+but is expected to have type
+  forall {n : Type.{u}} {β : Type.{v}}, (Nat -> n -> β) -> Nat -> (List.{u} n) -> (List.{v} β)
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_bit1 [anonymous]ₓ'. -/
 @[simp]
-theorem coe_eNNReal_bit1 (n : ℕ∞) : ↑(bit1 n) = bit1 (n : ℝ≥0∞) :=
-  map_bit1 toEnnrealRingHom n
-#align enat.coe_ennreal_bit1 ENat.coe_eNNReal_bit1
-
+theorem [anonymous] (n : ℕ∞) : ↑(bit1 n) = bit1 (n : ℝ≥0∞) :=
+  map_bit1 toENNRealRingHom n
+#align enat.coe_ennreal_bit1 [anonymous]
+
+/- warning: enat.coe_ennreal_mul -> ENat.toENNReal_mul is a dubious translation:
+lean 3 declaration is
+  forall (m : ENat) (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (HMul.hMul.{0, 0, 0} ENat ENat ENat (instHMul.{0} ENat (Distrib.toHasMul.{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)))))))) m n)) (HMul.hMul.{0, 0, 0} ENNReal ENNReal ENNReal (instHMul.{0} ENNReal (Distrib.toHasMul.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
+but is expected to have type
+  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (HMul.hMul.{0, 0, 0} ENat ENat ENat (instHMul.{0} ENat (CanonicallyOrderedCommSemiring.toMul.{0} ENat instENatCanonicallyOrderedCommSemiring)) m n)) (HMul.hMul.{0, 0, 0} ENNReal ENNReal ENNReal (instHMul.{0} ENNReal (CanonicallyOrderedCommSemiring.toMul.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)) (ENat.toENNReal m) (ENat.toENNReal n))
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_mul ENat.toENNReal_mulₓ'. -/
 @[simp]
-theorem coe_eNNReal_mul (m n : ℕ∞) : ↑(m * n) = (m * n : ℝ≥0∞) :=
-  map_mul toEnnrealRingHom m n
-#align enat.coe_ennreal_mul ENat.coe_eNNReal_mul
-
+theorem toENNReal_mul (m n : ℕ∞) : ↑(m * n) = (m * n : ℝ≥0∞) :=
+  map_mul toENNRealRingHom m n
+#align enat.coe_ennreal_mul ENat.toENNReal_mul
+
+/- warning: enat.coe_ennreal_min -> ENat.toENNReal_min is a dubious translation:
+lean 3 declaration is
+  forall (m : ENat) (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (LinearOrder.min.{0} ENat ENat.linearOrder m n)) (LinearOrder.min.{0} ENNReal (ConditionallyCompleteLinearOrder.toLinearOrder.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.completeLinearOrder))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
+but is expected to have type
+  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (Min.min.{0} ENat (CanonicallyLinearOrderedAddMonoid.toMin.{0} ENat instENatCanonicallyLinearOrderedAddMonoid) m n)) (Min.min.{0} ENNReal (CanonicallyLinearOrderedAddMonoid.toMin.{0} ENNReal ENNReal.instCanonicallyLinearOrderedAddMonoidENNReal) (ENat.toENNReal m) (ENat.toENNReal n))
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_min ENat.toENNReal_minₓ'. -/
 @[simp]
-theorem coe_eNNReal_min (m n : ℕ∞) : ↑(min m n) = (min m n : ℝ≥0∞) :=
-  coe_eNNReal_mono.map_min
-#align enat.coe_ennreal_min ENat.coe_eNNReal_min
-
+theorem toENNReal_min (m n : ℕ∞) : ↑(min m n) = (min m n : ℝ≥0∞) :=
+  toENNReal_mono.map_min
+#align enat.coe_ennreal_min ENat.toENNReal_min
+
+/- warning: enat.coe_ennreal_max -> ENat.toENNReal_max is a dubious translation:
+lean 3 declaration is
+  forall (m : ENat) (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (LinearOrder.max.{0} ENat ENat.linearOrder m n)) (LinearOrder.max.{0} ENNReal (ConditionallyCompleteLinearOrder.toLinearOrder.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.completeLinearOrder))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
+but is expected to have type
+  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (Max.max.{0} ENat (CanonicallyLinearOrderedAddMonoid.toMax.{0} ENat instENatCanonicallyLinearOrderedAddMonoid) m n)) (Max.max.{0} ENNReal (CanonicallyLinearOrderedAddMonoid.toMax.{0} ENNReal ENNReal.instCanonicallyLinearOrderedAddMonoidENNReal) (ENat.toENNReal m) (ENat.toENNReal n))
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_max ENat.toENNReal_maxₓ'. -/
 @[simp]
-theorem coe_eNNReal_max (m n : ℕ∞) : ↑(max m n) = (max m n : ℝ≥0∞) :=
-  coe_eNNReal_mono.map_max
-#align enat.coe_ennreal_max ENat.coe_eNNReal_max
-
+theorem toENNReal_max (m n : ℕ∞) : ↑(max m n) = (max m n : ℝ≥0∞) :=
+  toENNReal_mono.map_max
+#align enat.coe_ennreal_max ENat.toENNReal_max
+
+/- warning: enat.coe_ennreal_sub -> ENat.toENNReal_sub is a dubious translation:
+lean 3 declaration is
+  forall (m : ENat) (n : ENat), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) (HSub.hSub.{0, 0, 0} ENat ENat ENat (instHSub.{0} ENat ENat.hasSub) m n)) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.hasSub) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) m) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) ENat ENNReal (HasLiftT.mk.{1, 1} ENat ENNReal (CoeTCₓ.coe.{1, 1} ENat ENNReal ENat.hasCoeENNReal)) n))
+but is expected to have type
+  forall (m : ENat) (n : ENat), Eq.{1} ENNReal (ENat.toENNReal (HSub.hSub.{0, 0, 0} ENat ENat ENat (instHSub.{0} ENat instENatSub) m n)) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.instSubENNReal) (ENat.toENNReal m) (ENat.toENNReal n))
+Case conversion may be inaccurate. Consider using '#align enat.coe_ennreal_sub ENat.toENNReal_subₓ'. -/
 @[simp]
-theorem coe_eNNReal_sub (m n : ℕ∞) : ↑(m - n) = (m - n : ℝ≥0∞) :=
+theorem toENNReal_sub (m n : ℕ∞) : ↑(m - n) = (m - n : ℝ≥0∞) :=
   WithTop.map_sub Nat.cast_tsub Nat.cast_zero m n
-#align enat.coe_ennreal_sub ENat.coe_eNNReal_sub
+#align enat.coe_ennreal_sub ENat.toENNReal_sub
 
 end ENat

53b216bc

bump to nightly-2023-02-27-10

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

49ff026a

Diff

@@ -18,7 +18,7 @@ In this file we define a coercion from `ℕ∞` to `ℝ≥0∞` and prove some b
 -/
 
 
-open Classical NNReal Ennreal
+open Classical NNReal ENNReal
 
 noncomputable section
 
@@ -48,79 +48,79 @@ def toEnnrealRingHom : ℕ∞ →+* ℝ≥0∞ :=
 #align enat.to_ennreal_ring_hom ENat.toEnnrealRingHom
 
 @[simp, norm_cast]
-theorem coe_ennreal_top : ((⊤ : ℕ∞) : ℝ≥0∞) = ⊤ :=
+theorem coe_eNNReal_top : ((⊤ : ℕ∞) : ℝ≥0∞) = ⊤ :=
   rfl
-#align enat.coe_ennreal_top ENat.coe_ennreal_top
+#align enat.coe_ennreal_top ENat.coe_eNNReal_top
 
 @[simp, norm_cast]
-theorem coe_ennreal_coe (n : ℕ) : ((n : ℕ∞) : ℝ≥0∞) = n :=
+theorem coe_eNNReal_coe (n : ℕ) : ((n : ℕ∞) : ℝ≥0∞) = n :=
   rfl
-#align enat.coe_ennreal_coe ENat.coe_ennreal_coe
+#align enat.coe_ennreal_coe ENat.coe_eNNReal_coe
 
 @[simp, norm_cast]
-theorem coe_ennreal_le : (m : ℝ≥0∞) ≤ n ↔ m ≤ n :=
+theorem coe_eNNReal_le : (m : ℝ≥0∞) ≤ n ↔ m ≤ n :=
   toEnnrealOrderEmbedding.le_iff_le
-#align enat.coe_ennreal_le ENat.coe_ennreal_le
+#align enat.coe_ennreal_le ENat.coe_eNNReal_le
 
 @[simp, norm_cast]
-theorem coe_ennreal_lt : (m : ℝ≥0∞) < n ↔ m < n :=
+theorem coe_eNNReal_lt : (m : ℝ≥0∞) < n ↔ m < n :=
   toEnnrealOrderEmbedding.lt_iff_lt
-#align enat.coe_ennreal_lt ENat.coe_ennreal_lt
+#align enat.coe_ennreal_lt ENat.coe_eNNReal_lt
 
 @[mono]
-theorem coe_ennreal_mono : Monotone (coe : ℕ∞ → ℝ≥0∞) :=
+theorem coe_eNNReal_mono : Monotone (coe : ℕ∞ → ℝ≥0∞) :=
   toEnnrealOrderEmbedding.Monotone
-#align enat.coe_ennreal_mono ENat.coe_ennreal_mono
+#align enat.coe_ennreal_mono ENat.coe_eNNReal_mono
 
 @[mono]
-theorem coe_ennreal_strictMono : StrictMono (coe : ℕ∞ → ℝ≥0∞) :=
+theorem coe_eNNReal_strictMono : StrictMono (coe : ℕ∞ → ℝ≥0∞) :=
   toEnnrealOrderEmbedding.StrictMono
-#align enat.coe_ennreal_strict_mono ENat.coe_ennreal_strictMono
+#align enat.coe_ennreal_strict_mono ENat.coe_eNNReal_strictMono
 
 @[simp, norm_cast]
-theorem coe_ennreal_zero : ((0 : ℕ∞) : ℝ≥0∞) = 0 :=
+theorem coe_eNNReal_zero : ((0 : ℕ∞) : ℝ≥0∞) = 0 :=
   map_zero toEnnrealRingHom
-#align enat.coe_ennreal_zero ENat.coe_ennreal_zero
+#align enat.coe_ennreal_zero ENat.coe_eNNReal_zero
 
 @[simp]
-theorem coe_ennreal_add (m n : ℕ∞) : ↑(m + n) = (m + n : ℝ≥0∞) :=
+theorem coe_eNNReal_add (m n : ℕ∞) : ↑(m + n) = (m + n : ℝ≥0∞) :=
   map_add toEnnrealRingHom m n
-#align enat.coe_ennreal_add ENat.coe_ennreal_add
+#align enat.coe_ennreal_add ENat.coe_eNNReal_add
 
 @[simp]
-theorem coe_ennreal_one : ((1 : ℕ∞) : ℝ≥0∞) = 1 :=
+theorem coe_eNNReal_one : ((1 : ℕ∞) : ℝ≥0∞) = 1 :=
   map_one toEnnrealRingHom
-#align enat.coe_ennreal_one ENat.coe_ennreal_one
+#align enat.coe_ennreal_one ENat.coe_eNNReal_one
 
 @[simp]
-theorem coe_ennreal_bit0 (n : ℕ∞) : ↑(bit0 n) = bit0 (n : ℝ≥0∞) :=
-  coe_ennreal_add n n
-#align enat.coe_ennreal_bit0 ENat.coe_ennreal_bit0
+theorem coe_eNNReal_bit0 (n : ℕ∞) : ↑(bit0 n) = bit0 (n : ℝ≥0∞) :=
+  coe_eNNReal_add n n
+#align enat.coe_ennreal_bit0 ENat.coe_eNNReal_bit0
 
 @[simp]
-theorem coe_ennreal_bit1 (n : ℕ∞) : ↑(bit1 n) = bit1 (n : ℝ≥0∞) :=
+theorem coe_eNNReal_bit1 (n : ℕ∞) : ↑(bit1 n) = bit1 (n : ℝ≥0∞) :=
   map_bit1 toEnnrealRingHom n
-#align enat.coe_ennreal_bit1 ENat.coe_ennreal_bit1
+#align enat.coe_ennreal_bit1 ENat.coe_eNNReal_bit1
 
 @[simp]
-theorem coe_ennreal_mul (m n : ℕ∞) : ↑(m * n) = (m * n : ℝ≥0∞) :=
+theorem coe_eNNReal_mul (m n : ℕ∞) : ↑(m * n) = (m * n : ℝ≥0∞) :=
   map_mul toEnnrealRingHom m n
-#align enat.coe_ennreal_mul ENat.coe_ennreal_mul
+#align enat.coe_ennreal_mul ENat.coe_eNNReal_mul
 
 @[simp]
-theorem coe_ennreal_min (m n : ℕ∞) : ↑(min m n) = (min m n : ℝ≥0∞) :=
-  coe_ennreal_mono.map_min
-#align enat.coe_ennreal_min ENat.coe_ennreal_min
+theorem coe_eNNReal_min (m n : ℕ∞) : ↑(min m n) = (min m n : ℝ≥0∞) :=
+  coe_eNNReal_mono.map_min
+#align enat.coe_ennreal_min ENat.coe_eNNReal_min
 
 @[simp]
-theorem coe_ennreal_max (m n : ℕ∞) : ↑(max m n) = (max m n : ℝ≥0∞) :=
-  coe_ennreal_mono.map_max
-#align enat.coe_ennreal_max ENat.coe_ennreal_max
+theorem coe_eNNReal_max (m n : ℕ∞) : ↑(max m n) = (max m n : ℝ≥0∞) :=
+  coe_eNNReal_mono.map_max
+#align enat.coe_ennreal_max ENat.coe_eNNReal_max
 
 @[simp]
-theorem coe_ennreal_sub (m n : ℕ∞) : ↑(m - n) = (m - n : ℝ≥0∞) :=
+theorem coe_eNNReal_sub (m n : ℕ∞) : ↑(m - n) = (m - n : ℝ≥0∞) :=
   WithTop.map_sub Nat.cast_tsub Nat.cast_zero m n
-#align enat.coe_ennreal_sub ENat.coe_ennreal_sub
+#align enat.coe_ennreal_sub ENat.coe_eNNReal_sub
 
 end ENat

53b216bc

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

53b216bc

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

@@ -15,7 +15,8 @@ In this file we define a coercion from `ℕ∞` to `ℝ≥0∞` and prove some b
 -/
 
 
-open Classical NNReal ENNReal
+open scoped Classical
+open NNReal ENNReal
 
 noncomputable section

53b216bc

chore(Data/Real/ENNReal): move to Data/ENNReal/Basic (#9823)

In preparation for splitting that file. Location suggested by @j-loreaux on zulip.

07c91e91

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
 import Mathlib.Data.ENat.Basic
-import Mathlib.Data.Real.ENNReal
+import Mathlib.Data.ENNReal.Basic
 
 #align_import data.real.enat_ennreal from "leanprover-community/mathlib"@"53b216bcc1146df1c4a0a86877890ea9f1f01589"

53b216bc

fix: add missing no_index around OfNat.ofNat (#8317)

Co-authored-by: timotree3 <timorcb@gmail.com>

070be719

Diff

@@ -56,8 +56,10 @@ theorem toENNReal_coe (n : ℕ) : ((n : ℕ∞) : ℝ≥0∞) = n :=
   rfl
 #align enat.coe_ennreal_coe ENat.toENNReal_coe
 
+-- See note [no_index around OfNat.ofNat]
 @[simp, norm_cast]
-theorem toENNReal_ofNat (n : ℕ) [n.AtLeastTwo] : ((OfNat.ofNat n : ℕ∞) : ℝ≥0∞) = OfNat.ofNat n :=
+theorem toENNReal_ofNat (n : ℕ) [n.AtLeastTwo] :
+    ((no_index (OfNat.ofNat n : ℕ∞)) : ℝ≥0∞) = OfNat.ofNat n :=
   rfl
 
 @[simp, norm_cast]

53b216bc

style: shorten simps configurations (#8296)

Use .asFn and .lemmasOnly as simps configuration options.

For reference, these are defined here:

https://github.com/leanprover-community/mathlib4/blob/4055c8b471380825f07416b12cb0cf266da44d84/Mathlib/Tactic/Simps/Basic.lean#L843-L851

e0637173

Diff

@@ -35,13 +35,13 @@ theorem map_coe_nnreal : WithTop.map ((↑) : ℕ → ℝ≥0) = ((↑) : ℕ∞
 #align enat.map_coe_nnreal ENat.map_coe_nnreal
 
 /-- Coercion `ℕ∞ → ℝ≥0∞` as an `OrderEmbedding`. -/
-@[simps! (config := { fullyApplied := false })]
+@[simps! (config := .asFn)]
 def toENNRealOrderEmbedding : ℕ∞ ↪o ℝ≥0∞ :=
   Nat.castOrderEmbedding.withTopMap
 #align enat.to_ennreal_order_embedding ENat.toENNRealOrderEmbedding
 
 /-- Coercion `ℕ∞ → ℝ≥0∞` as a ring homomorphism. -/
-@[simps! (config := { fullyApplied := false })]
+@[simps! (config := .asFn)]
 def toENNRealRingHom : ℕ∞ →+* ℝ≥0∞ :=
   .withTopMap (Nat.castRingHom ℝ≥0) Nat.cast_injective
 #align enat.to_ennreal_ring_hom ENat.toENNRealRingHom

53b216bc

chore: further refactors of prerequisites of norm_num (#7097)

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

6de53297

Diff

@@ -119,4 +119,3 @@ theorem toENNReal_sub (m n : ℕ∞) : ↑(m - n) = (m - n : ℝ≥0∞) :=
 #align enat.coe_ennreal_sub ENat.toENNReal_sub
 
 end ENat
-

53b216bc

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,15 +2,12 @@
 Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module data.real.enat_ennreal
-! leanprover-community/mathlib commit 53b216bcc1146df1c4a0a86877890ea9f1f01589
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.ENat.Basic
 import Mathlib.Data.Real.ENNReal
 
+#align_import data.real.enat_ennreal from "leanprover-community/mathlib"@"53b216bcc1146df1c4a0a86877890ea9f1f01589"
+
 /-!
 # Coercion from `ℕ∞` to `ℝ≥0∞`

53b216bc

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

@@ -37,7 +37,7 @@ theorem map_coe_nnreal : WithTop.map ((↑) : ℕ → ℝ≥0) = ((↑) : ℕ∞
   rfl
 #align enat.map_coe_nnreal ENat.map_coe_nnreal
 
-/-- Coercion `ℕ∞ → ℝ≥0∞` as an `order_embedding`. -/
+/-- Coercion `ℕ∞ → ℝ≥0∞` as an `OrderEmbedding`. -/
 @[simps! (config := { fullyApplied := false })]
 def toENNRealOrderEmbedding : ℕ∞ ↪o ℝ≥0∞ :=
   Nat.castOrderEmbedding.withTopMap

53b216bc

feat: port Data.Real.ENatENNReal (#2529)

f503fe60

`data.real.enat_ennreal` ⟷ `Mathlib.Data.Real.ENatENNReal`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 9 + 379

data.real.enat_ennreal ⟷ Mathlib.Data.Real.ENatENNReal

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 9 + 379

`data.real.enat_ennreal` ⟷ `Mathlib.Data.Real.ENatENNReal`