topology.instances.rat | 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

560891c4

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

f4758115

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -131,7 +131,7 @@ theorem uniformContinuous_add : UniformContinuous fun p : ℚ × ℚ => p.1 + p.
 #print Rat.uniformContinuous_neg /-
 theorem uniformContinuous_neg : UniformContinuous (@Neg.neg ℚ _) :=
   Metric.uniformContinuous_iff.2 fun ε ε0 =>
-    ⟨_, ε0, fun a b h => by rw [dist_comm] at h  <;> simpa [Rat.dist_eq] using h⟩
+    ⟨_, ε0, fun a b h => by rw [dist_comm] at h <;> simpa [Rat.dist_eq] using h⟩
 #align rat.uniform_continuous_neg Rat.uniformContinuous_neg
 -/

f4758115

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,11 +3,11 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro
 -/
-import Mathbin.Topology.MetricSpace.Basic
-import Mathbin.Topology.Algebra.Order.Archimedean
-import Mathbin.Topology.Instances.Int
-import Mathbin.Topology.Instances.Nat
-import Mathbin.Topology.Instances.Real
+import Topology.MetricSpace.Basic
+import Topology.Algebra.Order.Archimedean
+import Topology.Instances.Int
+import Topology.Instances.Nat
+import Topology.Instances.Real
 
 #align_import topology.instances.rat from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"

f4758115

bump to nightly-2023-08-17-09

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

60285dcc

Diff

@@ -160,7 +160,7 @@ theorem continuous_mul : Continuous fun p : ℚ × ℚ => p.1 * p.2 :=
 -/
 
 instance : TopologicalRing ℚ :=
-  { Rat.topologicalAddGroup with continuous_mul := Rat.continuous_mul }
+  { Rat.topologicalAddGroup with continuous_hMul := Rat.continuous_mul }
 
 #print Rat.totallyBounded_Icc /-
 theorem totallyBounded_Icc (a b : ℚ) : TotallyBounded (Icc a b) := by

f4758115

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,11 +2,6 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro
-
-! This file was ported from Lean 3 source module topology.instances.rat
-! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.MetricSpace.Basic
 import Mathbin.Topology.Algebra.Order.Archimedean
@@ -14,6 +9,8 @@ import Mathbin.Topology.Instances.Int
 import Mathbin.Topology.Instances.Nat
 import Mathbin.Topology.Instances.Real
 
+#align_import topology.instances.rat from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
+
 /-!
 # Topology on the ratonal numbers

f4758115

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -32,68 +32,95 @@ namespace Rat
 instance : MetricSpace ℚ :=
   MetricSpace.induced coe Rat.cast_injective Real.metricSpace
 
+#print Rat.dist_eq /-
 theorem dist_eq (x y : ℚ) : dist x y = |x - y| :=
   rfl
 #align rat.dist_eq Rat.dist_eq
+-/
 
+#print Rat.dist_cast /-
 @[norm_cast, simp]
 theorem dist_cast (x y : ℚ) : dist (x : ℝ) y = dist x y :=
   rfl
 #align rat.dist_cast Rat.dist_cast
+-/
 
+#print Rat.uniformContinuous_coe_real /-
 theorem uniformContinuous_coe_real : UniformContinuous (coe : ℚ → ℝ) :=
   uniformContinuous_comap
 #align rat.uniform_continuous_coe_real Rat.uniformContinuous_coe_real
+-/
 
+#print Rat.uniformEmbedding_coe_real /-
 theorem uniformEmbedding_coe_real : UniformEmbedding (coe : ℚ → ℝ) :=
   uniformEmbedding_comap Rat.cast_injective
 #align rat.uniform_embedding_coe_real Rat.uniformEmbedding_coe_real
+-/
 
+#print Rat.denseEmbedding_coe_real /-
 theorem denseEmbedding_coe_real : DenseEmbedding (coe : ℚ → ℝ) :=
   uniformEmbedding_coe_real.DenseEmbedding Rat.denseRange_cast
 #align rat.dense_embedding_coe_real Rat.denseEmbedding_coe_real
+-/
 
+#print Rat.embedding_coe_real /-
 theorem embedding_coe_real : Embedding (coe : ℚ → ℝ) :=
   denseEmbedding_coe_real.toEmbedding
 #align rat.embedding_coe_real Rat.embedding_coe_real
+-/
 
+#print Rat.continuous_coe_real /-
 theorem continuous_coe_real : Continuous (coe : ℚ → ℝ) :=
   uniformContinuous_coe_real.Continuous
 #align rat.continuous_coe_real Rat.continuous_coe_real
+-/
 
 end Rat
 
+#print Nat.dist_cast_rat /-
 @[norm_cast, simp]
 theorem Nat.dist_cast_rat (x y : ℕ) : dist (x : ℚ) y = dist x y := by
   rw [← Nat.dist_cast_real, ← Rat.dist_cast] <;> congr 1 <;> norm_cast
 #align nat.dist_cast_rat Nat.dist_cast_rat
+-/
 
+#print Nat.uniformEmbedding_coe_rat /-
 theorem Nat.uniformEmbedding_coe_rat : UniformEmbedding (coe : ℕ → ℚ) :=
   uniformEmbedding_bot_of_pairwise_le_dist zero_lt_one <| by simpa using Nat.pairwise_one_le_dist
 #align nat.uniform_embedding_coe_rat Nat.uniformEmbedding_coe_rat
+-/
 
+#print Nat.closedEmbedding_coe_rat /-
 theorem Nat.closedEmbedding_coe_rat : ClosedEmbedding (coe : ℕ → ℚ) :=
   closedEmbedding_of_pairwise_le_dist zero_lt_one <| by simpa using Nat.pairwise_one_le_dist
 #align nat.closed_embedding_coe_rat Nat.closedEmbedding_coe_rat
+-/
 
+#print Int.dist_cast_rat /-
 @[norm_cast, simp]
 theorem Int.dist_cast_rat (x y : ℤ) : dist (x : ℚ) y = dist x y := by
   rw [← Int.dist_cast_real, ← Rat.dist_cast] <;> congr 1 <;> norm_cast
 #align int.dist_cast_rat Int.dist_cast_rat
+-/
 
+#print Int.uniformEmbedding_coe_rat /-
 theorem Int.uniformEmbedding_coe_rat : UniformEmbedding (coe : ℤ → ℚ) :=
   uniformEmbedding_bot_of_pairwise_le_dist zero_lt_one <| by simpa using Int.pairwise_one_le_dist
 #align int.uniform_embedding_coe_rat Int.uniformEmbedding_coe_rat
+-/
 
+#print Int.closedEmbedding_coe_rat /-
 theorem Int.closedEmbedding_coe_rat : ClosedEmbedding (coe : ℤ → ℚ) :=
   closedEmbedding_of_pairwise_le_dist zero_lt_one <| by simpa using Int.pairwise_one_le_dist
 #align int.closed_embedding_coe_rat Int.closedEmbedding_coe_rat
+-/
 
 namespace Rat
 
 instance : NoncompactSpace ℚ :=
   Int.closedEmbedding_coe_rat.NoncompactSpace
 
+#print Rat.uniformContinuous_add /-
 -- TODO(Mario): Find a way to use rat_add_continuous_lemma
 theorem uniformContinuous_add : UniformContinuous fun p : ℚ × ℚ => p.1 + p.2 :=
   Rat.uniformEmbedding_coe_real.to_uniformInducing.uniformContinuous_iff.2 <| by
@@ -102,11 +129,14 @@ theorem uniformContinuous_add : UniformContinuous fun p : ℚ × ℚ => p.1 + p.
         real.uniform_continuous_add.comp
           (rat.uniform_continuous_coe_real.prod_map Rat.uniformContinuous_coe_real)
 #align rat.uniform_continuous_add Rat.uniformContinuous_add
+-/
 
+#print Rat.uniformContinuous_neg /-
 theorem uniformContinuous_neg : UniformContinuous (@Neg.neg ℚ _) :=
   Metric.uniformContinuous_iff.2 fun ε ε0 =>
     ⟨_, ε0, fun a b h => by rw [dist_comm] at h  <;> simpa [Rat.dist_eq] using h⟩
 #align rat.uniform_continuous_neg Rat.uniformContinuous_neg
+-/
 
 instance : UniformAddGroup ℚ :=
   UniformAddGroup.mk' Rat.uniformContinuous_add Rat.uniformContinuous_neg
@@ -116,25 +146,31 @@ instance : TopologicalAddGroup ℚ := by infer_instance
 instance : OrderTopology ℚ :=
   induced_orderTopology _ (fun x y => Rat.cast_lt) (@exists_rat_btwn _ _ _)
 
+#print Rat.uniformContinuous_abs /-
 theorem uniformContinuous_abs : UniformContinuous (abs : ℚ → ℚ) :=
   Metric.uniformContinuous_iff.2 fun ε ε0 =>
     ⟨ε, ε0, fun a b h =>
       lt_of_le_of_lt (by simpa [Rat.dist_eq] using abs_abs_sub_abs_le_abs_sub _ _) h⟩
 #align rat.uniform_continuous_abs Rat.uniformContinuous_abs
+-/
 
+#print Rat.continuous_mul /-
 theorem continuous_mul : Continuous fun p : ℚ × ℚ => p.1 * p.2 :=
   Rat.embedding_coe_real.continuous_iff.2 <| by
     simp [(· ∘ ·)] <;>
       exact real.continuous_mul.comp (rat.continuous_coe_real.prod_map Rat.continuous_coe_real)
 #align rat.continuous_mul Rat.continuous_mul
+-/
 
 instance : TopologicalRing ℚ :=
   { Rat.topologicalAddGroup with continuous_mul := Rat.continuous_mul }
 
+#print Rat.totallyBounded_Icc /-
 theorem totallyBounded_Icc (a b : ℚ) : TotallyBounded (Icc a b) := by
   simpa only [preimage_cast_Icc] using
     totallyBounded_preimage Rat.uniformEmbedding_coe_real (totallyBounded_Icc a b)
 #align rat.totally_bounded_Icc Rat.totallyBounded_Icc
+-/
 
 end Rat

f4758115

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -105,7 +105,7 @@ theorem uniformContinuous_add : UniformContinuous fun p : ℚ × ℚ => p.1 + p.
 
 theorem uniformContinuous_neg : UniformContinuous (@Neg.neg ℚ _) :=
   Metric.uniformContinuous_iff.2 fun ε ε0 =>
-    ⟨_, ε0, fun a b h => by rw [dist_comm] at h <;> simpa [Rat.dist_eq] using h⟩
+    ⟨_, ε0, fun a b h => by rw [dist_comm] at h  <;> simpa [Rat.dist_eq] using h⟩
 #align rat.uniform_continuous_neg Rat.uniformContinuous_neg
 
 instance : UniformAddGroup ℚ :=

f4758115

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -32,137 +32,59 @@ namespace Rat
 instance : MetricSpace ℚ :=
   MetricSpace.induced coe Rat.cast_injective Real.metricSpace
 
-/- warning: rat.dist_eq -> Rat.dist_eq is a dubious translation:
-lean 3 declaration is
-  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) x y) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) y)))
-but is expected to have type
-  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) x y) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Rat.cast.{0} Real Real.ratCast x) (Rat.cast.{0} Real Real.ratCast y)))
-Case conversion may be inaccurate. Consider using '#align rat.dist_eq Rat.dist_eqₓ'. -/
 theorem dist_eq (x y : ℚ) : dist x y = |x - y| :=
   rfl
 #align rat.dist_eq Rat.dist_eq
 
-/- warning: rat.dist_cast -> Rat.dist_cast is a dubious translation:
-lean 3 declaration is
-  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Real (PseudoMetricSpace.toHasDist.{0} Real Real.pseudoMetricSpace) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) y)) (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) x y)
-but is expected to have type
-  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Real (PseudoMetricSpace.toDist.{0} Real Real.pseudoMetricSpace) (Rat.cast.{0} Real Real.ratCast x) (Rat.cast.{0} Real Real.ratCast y)) (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) x y)
-Case conversion may be inaccurate. Consider using '#align rat.dist_cast Rat.dist_castₓ'. -/
 @[norm_cast, simp]
 theorem dist_cast (x y : ℚ) : dist (x : ℝ) y = dist x y :=
   rfl
 #align rat.dist_cast Rat.dist_cast
 
-/- warning: rat.uniform_continuous_coe_real -> Rat.uniformContinuous_coe_real is a dubious translation:
-lean 3 declaration is
-  UniformContinuous.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
-but is expected to have type
-  UniformContinuous.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (Rat.cast.{0} Real Real.ratCast)
-Case conversion may be inaccurate. Consider using '#align rat.uniform_continuous_coe_real Rat.uniformContinuous_coe_realₓ'. -/
 theorem uniformContinuous_coe_real : UniformContinuous (coe : ℚ → ℝ) :=
   uniformContinuous_comap
 #align rat.uniform_continuous_coe_real Rat.uniformContinuous_coe_real
 
-/- warning: rat.uniform_embedding_coe_real -> Rat.uniformEmbedding_coe_real is a dubious translation:
-lean 3 declaration is
-  UniformEmbedding.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
-but is expected to have type
-  UniformEmbedding.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (Rat.cast.{0} Real Real.ratCast)
-Case conversion may be inaccurate. Consider using '#align rat.uniform_embedding_coe_real Rat.uniformEmbedding_coe_realₓ'. -/
 theorem uniformEmbedding_coe_real : UniformEmbedding (coe : ℚ → ℝ) :=
   uniformEmbedding_comap Rat.cast_injective
 #align rat.uniform_embedding_coe_real Rat.uniformEmbedding_coe_real
 
-/- warning: rat.dense_embedding_coe_real -> Rat.denseEmbedding_coe_real is a dubious translation:
-lean 3 declaration is
-  DenseEmbedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
-but is expected to have type
-  DenseEmbedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (Rat.cast.{0} Real Real.ratCast)
-Case conversion may be inaccurate. Consider using '#align rat.dense_embedding_coe_real Rat.denseEmbedding_coe_realₓ'. -/
 theorem denseEmbedding_coe_real : DenseEmbedding (coe : ℚ → ℝ) :=
   uniformEmbedding_coe_real.DenseEmbedding Rat.denseRange_cast
 #align rat.dense_embedding_coe_real Rat.denseEmbedding_coe_real
 
-/- warning: rat.embedding_coe_real -> Rat.embedding_coe_real is a dubious translation:
-lean 3 declaration is
-  Embedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
-but is expected to have type
-  Embedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (Rat.cast.{0} Real Real.ratCast)
-Case conversion may be inaccurate. Consider using '#align rat.embedding_coe_real Rat.embedding_coe_realₓ'. -/
 theorem embedding_coe_real : Embedding (coe : ℚ → ℝ) :=
   denseEmbedding_coe_real.toEmbedding
 #align rat.embedding_coe_real Rat.embedding_coe_real
 
-/- warning: rat.continuous_coe_real -> Rat.continuous_coe_real is a dubious translation:
-lean 3 declaration is
-  Continuous.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
-but is expected to have type
-  Continuous.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (Rat.cast.{0} Real Real.ratCast)
-Case conversion may be inaccurate. Consider using '#align rat.continuous_coe_real Rat.continuous_coe_realₓ'. -/
 theorem continuous_coe_real : Continuous (coe : ℚ → ℝ) :=
   uniformContinuous_coe_real.Continuous
 #align rat.continuous_coe_real Rat.continuous_coe_real
 
 end Rat
 
-/- warning: nat.dist_cast_rat -> Nat.dist_cast_rat is a dubious translation:
-lean 3 declaration is
-  forall (x : Nat) (y : Nat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))) y)) (Dist.dist.{0} Nat Nat.hasDist x y)
-but is expected to have type
-  forall (x : Nat) (y : Nat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Nat.cast.{0} Rat (Semiring.toNatCast.{0} Rat Rat.semiring) x) (Nat.cast.{0} Rat (Semiring.toNatCast.{0} Rat Rat.semiring) y)) (Dist.dist.{0} Nat Nat.instDistNat x y)
-Case conversion may be inaccurate. Consider using '#align nat.dist_cast_rat Nat.dist_cast_ratₓ'. -/
 @[norm_cast, simp]
 theorem Nat.dist_cast_rat (x y : ℕ) : dist (x : ℚ) y = dist x y := by
   rw [← Nat.dist_cast_real, ← Rat.dist_cast] <;> congr 1 <;> norm_cast
 #align nat.dist_cast_rat Nat.dist_cast_rat
 
-/- warning: nat.uniform_embedding_coe_rat -> Nat.uniformEmbedding_coe_rat is a dubious translation:
-lean 3 declaration is
-  UniformEmbedding.{0, 0} Nat Rat Nat.uniformSpace (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))))
-but is expected to have type
-  UniformEmbedding.{0, 0} Nat Rat instUniformSpaceNat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Nat.cast.{0} Rat (Semiring.toNatCast.{0} Rat Rat.semiring))
-Case conversion may be inaccurate. Consider using '#align nat.uniform_embedding_coe_rat Nat.uniformEmbedding_coe_ratₓ'. -/
 theorem Nat.uniformEmbedding_coe_rat : UniformEmbedding (coe : ℕ → ℚ) :=
   uniformEmbedding_bot_of_pairwise_le_dist zero_lt_one <| by simpa using Nat.pairwise_one_le_dist
 #align nat.uniform_embedding_coe_rat Nat.uniformEmbedding_coe_rat
 
-/- warning: nat.closed_embedding_coe_rat -> Nat.closedEmbedding_coe_rat is a dubious translation:
-lean 3 declaration is
-  ClosedEmbedding.{0, 0} Nat Rat Nat.topologicalSpace (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))))
-but is expected to have type
-  ClosedEmbedding.{0, 0} Nat Rat instTopologicalSpaceNat (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (Nat.cast.{0} Rat (Semiring.toNatCast.{0} Rat Rat.semiring))
-Case conversion may be inaccurate. Consider using '#align nat.closed_embedding_coe_rat Nat.closedEmbedding_coe_ratₓ'. -/
 theorem Nat.closedEmbedding_coe_rat : ClosedEmbedding (coe : ℕ → ℚ) :=
   closedEmbedding_of_pairwise_le_dist zero_lt_one <| by simpa using Nat.pairwise_one_le_dist
 #align nat.closed_embedding_coe_rat Nat.closedEmbedding_coe_rat
 
-/- warning: int.dist_cast_rat -> Int.dist_cast_rat is a dubious translation:
-lean 3 declaration is
-  forall (x : Int) (y : Int), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Rat (HasLiftT.mk.{1, 1} Int Rat (CoeTCₓ.coe.{1, 1} Int Rat (Int.castCoe.{0} Rat Rat.hasIntCast))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Rat (HasLiftT.mk.{1, 1} Int Rat (CoeTCₓ.coe.{1, 1} Int Rat (Int.castCoe.{0} Rat Rat.hasIntCast))) y)) (Dist.dist.{0} Int Int.hasDist x y)
-but is expected to have type
-  forall (x : Int) (y : Int), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Int.cast.{0} Rat Rat.instIntCastRat x) (Int.cast.{0} Rat Rat.instIntCastRat y)) (Dist.dist.{0} Int Int.instDistInt x y)
-Case conversion may be inaccurate. Consider using '#align int.dist_cast_rat Int.dist_cast_ratₓ'. -/
 @[norm_cast, simp]
 theorem Int.dist_cast_rat (x y : ℤ) : dist (x : ℚ) y = dist x y := by
   rw [← Int.dist_cast_real, ← Rat.dist_cast] <;> congr 1 <;> norm_cast
 #align int.dist_cast_rat Int.dist_cast_rat
 
-/- warning: int.uniform_embedding_coe_rat -> Int.uniformEmbedding_coe_rat is a dubious translation:
-lean 3 declaration is
-  UniformEmbedding.{0, 0} Int Rat Int.uniformSpace (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Rat (HasLiftT.mk.{1, 1} Int Rat (CoeTCₓ.coe.{1, 1} Int Rat (Int.castCoe.{0} Rat Rat.hasIntCast))))
-but is expected to have type
-  UniformEmbedding.{0, 0} Int Rat instUniformSpaceInt (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Int.cast.{0} Rat Rat.instIntCastRat)
-Case conversion may be inaccurate. Consider using '#align int.uniform_embedding_coe_rat Int.uniformEmbedding_coe_ratₓ'. -/
 theorem Int.uniformEmbedding_coe_rat : UniformEmbedding (coe : ℤ → ℚ) :=
   uniformEmbedding_bot_of_pairwise_le_dist zero_lt_one <| by simpa using Int.pairwise_one_le_dist
 #align int.uniform_embedding_coe_rat Int.uniformEmbedding_coe_rat
 
-/- warning: int.closed_embedding_coe_rat -> Int.closedEmbedding_coe_rat is a dubious translation:
-lean 3 declaration is
-  ClosedEmbedding.{0, 0} Int Rat Int.topologicalSpace (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Rat (HasLiftT.mk.{1, 1} Int Rat (CoeTCₓ.coe.{1, 1} Int Rat (Int.castCoe.{0} Rat Rat.hasIntCast))))
-but is expected to have type
-  ClosedEmbedding.{0, 0} Int Rat instTopologicalSpaceInt (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (Int.cast.{0} Rat Rat.instIntCastRat)
-Case conversion may be inaccurate. Consider using '#align int.closed_embedding_coe_rat Int.closedEmbedding_coe_ratₓ'. -/
 theorem Int.closedEmbedding_coe_rat : ClosedEmbedding (coe : ℤ → ℚ) :=
   closedEmbedding_of_pairwise_le_dist zero_lt_one <| by simpa using Int.pairwise_one_le_dist
 #align int.closed_embedding_coe_rat Int.closedEmbedding_coe_rat
@@ -172,12 +94,6 @@ namespace Rat
 instance : NoncompactSpace ℚ :=
   Int.closedEmbedding_coe_rat.NoncompactSpace
 
-/- warning: rat.uniform_continuous_add -> Rat.uniformContinuous_add is a dubious translation:
-lean 3 declaration is
-  UniformContinuous.{0, 0} (Prod.{0, 0} Rat Rat) Rat (Prod.uniformSpace.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (fun (p : Prod.{0, 0} Rat Rat) => HAdd.hAdd.{0, 0, 0} Rat Rat Rat (instHAdd.{0} Rat Rat.hasAdd) (Prod.fst.{0, 0} Rat Rat p) (Prod.snd.{0, 0} Rat Rat p))
-but is expected to have type
-  UniformContinuous.{0, 0} (Prod.{0, 0} Rat Rat) Rat (instUniformSpaceProd.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (fun (p : Prod.{0, 0} Rat Rat) => HAdd.hAdd.{0, 0, 0} Rat Rat Rat (instHAdd.{0} Rat Rat.instAddRat) (Prod.fst.{0, 0} Rat Rat p) (Prod.snd.{0, 0} Rat Rat p))
-Case conversion may be inaccurate. Consider using '#align rat.uniform_continuous_add Rat.uniformContinuous_addₓ'. -/
 -- TODO(Mario): Find a way to use rat_add_continuous_lemma
 theorem uniformContinuous_add : UniformContinuous fun p : ℚ × ℚ => p.1 + p.2 :=
   Rat.uniformEmbedding_coe_real.to_uniformInducing.uniformContinuous_iff.2 <| by
@@ -187,12 +103,6 @@ theorem uniformContinuous_add : UniformContinuous fun p : ℚ × ℚ => p.1 + p.
           (rat.uniform_continuous_coe_real.prod_map Rat.uniformContinuous_coe_real)
 #align rat.uniform_continuous_add Rat.uniformContinuous_add
 
-/- warning: rat.uniform_continuous_neg -> Rat.uniformContinuous_neg is a dubious translation:
-lean 3 declaration is
-  UniformContinuous.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (Neg.neg.{0} Rat Rat.hasNeg)
-but is expected to have type
-  UniformContinuous.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Neg.neg.{0} Rat Rat.instNegRat)
-Case conversion may be inaccurate. Consider using '#align rat.uniform_continuous_neg Rat.uniformContinuous_negₓ'. -/
 theorem uniformContinuous_neg : UniformContinuous (@Neg.neg ℚ _) :=
   Metric.uniformContinuous_iff.2 fun ε ε0 =>
     ⟨_, ε0, fun a b h => by rw [dist_comm] at h <;> simpa [Rat.dist_eq] using h⟩
@@ -206,24 +116,12 @@ instance : TopologicalAddGroup ℚ := by infer_instance
 instance : OrderTopology ℚ :=
   induced_orderTopology _ (fun x y => Rat.cast_lt) (@exists_rat_btwn _ _ _)
 
-/- warning: rat.uniform_continuous_abs -> Rat.uniformContinuous_abs is a dubious translation:
-lean 3 declaration is
-  UniformContinuous.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (Abs.abs.{0} Rat (Neg.toHasAbs.{0} Rat Rat.hasNeg Rat.hasSup))
-but is expected to have type
-  UniformContinuous.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Abs.abs.{0} Rat (Neg.toHasAbs.{0} Rat Rat.instNegRat Rat.instSupRat))
-Case conversion may be inaccurate. Consider using '#align rat.uniform_continuous_abs Rat.uniformContinuous_absₓ'. -/
 theorem uniformContinuous_abs : UniformContinuous (abs : ℚ → ℚ) :=
   Metric.uniformContinuous_iff.2 fun ε ε0 =>
     ⟨ε, ε0, fun a b h =>
       lt_of_le_of_lt (by simpa [Rat.dist_eq] using abs_abs_sub_abs_le_abs_sub _ _) h⟩
 #align rat.uniform_continuous_abs Rat.uniformContinuous_abs
 
-/- warning: rat.continuous_mul -> Rat.continuous_mul is a dubious translation:
-lean 3 declaration is
-  Continuous.{0, 0} (Prod.{0, 0} Rat Rat) Rat (Prod.topologicalSpace.{0, 0} Rat Rat (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)))) (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (fun (p : Prod.{0, 0} Rat Rat) => HMul.hMul.{0, 0, 0} Rat Rat Rat (instHMul.{0} Rat Rat.hasMul) (Prod.fst.{0, 0} Rat Rat p) (Prod.snd.{0, 0} Rat Rat p))
-but is expected to have type
-  Continuous.{0, 0} (Prod.{0, 0} Rat Rat) Rat (instTopologicalSpaceProd.{0, 0} Rat Rat (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)))) (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (fun (p : Prod.{0, 0} Rat Rat) => HMul.hMul.{0, 0, 0} Rat Rat Rat (instHMul.{0} Rat Rat.instMulRat) (Prod.fst.{0, 0} Rat Rat p) (Prod.snd.{0, 0} Rat Rat p))
-Case conversion may be inaccurate. Consider using '#align rat.continuous_mul Rat.continuous_mulₓ'. -/
 theorem continuous_mul : Continuous fun p : ℚ × ℚ => p.1 * p.2 :=
   Rat.embedding_coe_real.continuous_iff.2 <| by
     simp [(· ∘ ·)] <;>
@@ -233,12 +131,6 @@ theorem continuous_mul : Continuous fun p : ℚ × ℚ => p.1 * p.2 :=
 instance : TopologicalRing ℚ :=
   { Rat.topologicalAddGroup with continuous_mul := Rat.continuous_mul }
 
-/- warning: rat.totally_bounded_Icc -> Rat.totallyBounded_Icc is a dubious translation:
-lean 3 declaration is
-  forall (a : Rat) (b : Rat), TotallyBounded.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (Set.Icc.{0} Rat Rat.preorder a b)
-but is expected to have type
-  forall (a : Rat) (b : Rat), TotallyBounded.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Set.Icc.{0} Rat Rat.instPreorderRat a b)
-Case conversion may be inaccurate. Consider using '#align rat.totally_bounded_Icc Rat.totallyBounded_Iccₓ'. -/
 theorem totallyBounded_Icc (a b : ℚ) : TotallyBounded (Icc a b) := by
   simpa only [preimage_cast_Icc] using
     totallyBounded_preimage Rat.uniformEmbedding_coe_real (totallyBounded_Icc a b)

f4758115

bump to nightly-2023-05-08-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/08e1d8d4d989df3a6df86f385e9053ec8a372cc1

63e712c6

Diff

@@ -109,7 +109,7 @@ end Rat
 lean 3 declaration is
   forall (x : Nat) (y : Nat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))) y)) (Dist.dist.{0} Nat Nat.hasDist x y)
 but is expected to have type
-  forall (x : Nat) (y : Nat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))) x) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))) y)) (Dist.dist.{0} Nat Nat.instDistNat x y)
+  forall (x : Nat) (y : Nat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Nat.cast.{0} Rat (Semiring.toNatCast.{0} Rat Rat.semiring) x) (Nat.cast.{0} Rat (Semiring.toNatCast.{0} Rat Rat.semiring) y)) (Dist.dist.{0} Nat Nat.instDistNat x y)
 Case conversion may be inaccurate. Consider using '#align nat.dist_cast_rat Nat.dist_cast_ratₓ'. -/
 @[norm_cast, simp]
 theorem Nat.dist_cast_rat (x y : ℕ) : dist (x : ℚ) y = dist x y := by
@@ -120,7 +120,7 @@ theorem Nat.dist_cast_rat (x y : ℕ) : dist (x : ℚ) y = dist x y := by
 lean 3 declaration is
   UniformEmbedding.{0, 0} Nat Rat Nat.uniformSpace (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))))
 but is expected to have type
-  UniformEmbedding.{0, 0} Nat Rat instUniformSpaceNat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))))
+  UniformEmbedding.{0, 0} Nat Rat instUniformSpaceNat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Nat.cast.{0} Rat (Semiring.toNatCast.{0} Rat Rat.semiring))
 Case conversion may be inaccurate. Consider using '#align nat.uniform_embedding_coe_rat Nat.uniformEmbedding_coe_ratₓ'. -/
 theorem Nat.uniformEmbedding_coe_rat : UniformEmbedding (coe : ℕ → ℚ) :=
   uniformEmbedding_bot_of_pairwise_le_dist zero_lt_one <| by simpa using Nat.pairwise_one_le_dist
@@ -130,7 +130,7 @@ theorem Nat.uniformEmbedding_coe_rat : UniformEmbedding (coe : ℕ → ℚ) :=
 lean 3 declaration is
   ClosedEmbedding.{0, 0} Nat Rat Nat.topologicalSpace (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))))
 but is expected to have type
-  ClosedEmbedding.{0, 0} Nat Rat instTopologicalSpaceNat (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))))
+  ClosedEmbedding.{0, 0} Nat Rat instTopologicalSpaceNat (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (Nat.cast.{0} Rat (Semiring.toNatCast.{0} Rat Rat.semiring))
 Case conversion may be inaccurate. Consider using '#align nat.closed_embedding_coe_rat Nat.closedEmbedding_coe_ratₓ'. -/
 theorem Nat.closedEmbedding_coe_rat : ClosedEmbedding (coe : ℕ → ℚ) :=
   closedEmbedding_of_pairwise_le_dist zero_lt_one <| by simpa using Nat.pairwise_one_le_dist

f4758115

bump to nightly-2023-03-27-02

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

0e4ebd8c

Diff

@@ -107,7 +107,7 @@ end Rat
 
 /- warning: nat.dist_cast_rat -> Nat.dist_cast_rat is a dubious translation:
 lean 3 declaration is
-  forall (x : Nat) (y : Nat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (NonAssocRing.toAddGroupWithOne.{0} Rat (Ring.toNonAssocRing.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (NonAssocRing.toAddGroupWithOne.{0} Rat (Ring.toNonAssocRing.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))) y)) (Dist.dist.{0} Nat Nat.hasDist x y)
+  forall (x : Nat) (y : Nat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))) y)) (Dist.dist.{0} Nat Nat.hasDist x y)
 but is expected to have type
   forall (x : Nat) (y : Nat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))) x) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))) y)) (Dist.dist.{0} Nat Nat.instDistNat x y)
 Case conversion may be inaccurate. Consider using '#align nat.dist_cast_rat Nat.dist_cast_ratₓ'. -/
@@ -118,7 +118,7 @@ theorem Nat.dist_cast_rat (x y : ℕ) : dist (x : ℚ) y = dist x y := by
 
 /- warning: nat.uniform_embedding_coe_rat -> Nat.uniformEmbedding_coe_rat is a dubious translation:
 lean 3 declaration is
-  UniformEmbedding.{0, 0} Nat Rat Nat.uniformSpace (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (NonAssocRing.toAddGroupWithOne.{0} Rat (Ring.toNonAssocRing.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))))
+  UniformEmbedding.{0, 0} Nat Rat Nat.uniformSpace (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))))
 but is expected to have type
   UniformEmbedding.{0, 0} Nat Rat instUniformSpaceNat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))))
 Case conversion may be inaccurate. Consider using '#align nat.uniform_embedding_coe_rat Nat.uniformEmbedding_coe_ratₓ'. -/
@@ -128,7 +128,7 @@ theorem Nat.uniformEmbedding_coe_rat : UniformEmbedding (coe : ℕ → ℚ) :=
 
 /- warning: nat.closed_embedding_coe_rat -> Nat.closedEmbedding_coe_rat is a dubious translation:
 lean 3 declaration is
-  ClosedEmbedding.{0, 0} Nat Rat Nat.topologicalSpace (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (NonAssocRing.toAddGroupWithOne.{0} Rat (Ring.toNonAssocRing.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))))
+  ClosedEmbedding.{0, 0} Nat Rat Nat.topologicalSpace (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (AddCommGroupWithOne.toAddGroupWithOne.{0} Rat (Ring.toAddCommGroupWithOne.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))))
 but is expected to have type
   ClosedEmbedding.{0, 0} Nat Rat instTopologicalSpaceNat (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))))
 Case conversion may be inaccurate. Consider using '#align nat.closed_embedding_coe_rat Nat.closedEmbedding_coe_ratₓ'. -/

f4758115

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -36,7 +36,7 @@ instance : MetricSpace ℚ :=
 lean 3 declaration is
   forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) x y) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) y)))
 but is expected to have type
-  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) x y) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (RatCast.ratCast.{0} Real Real.ratCast x) (RatCast.ratCast.{0} Real Real.ratCast y)))
+  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) x y) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Rat.cast.{0} Real Real.ratCast x) (Rat.cast.{0} Real Real.ratCast y)))
 Case conversion may be inaccurate. Consider using '#align rat.dist_eq Rat.dist_eqₓ'. -/
 theorem dist_eq (x y : ℚ) : dist x y = |x - y| :=
   rfl
@@ -46,7 +46,7 @@ theorem dist_eq (x y : ℚ) : dist x y = |x - y| :=
 lean 3 declaration is
   forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Real (PseudoMetricSpace.toHasDist.{0} Real Real.pseudoMetricSpace) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) y)) (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) x y)
 but is expected to have type
-  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Real (PseudoMetricSpace.toDist.{0} Real Real.pseudoMetricSpace) (RatCast.ratCast.{0} Real Real.ratCast x) (RatCast.ratCast.{0} Real Real.ratCast y)) (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) x y)
+  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Real (PseudoMetricSpace.toDist.{0} Real Real.pseudoMetricSpace) (Rat.cast.{0} Real Real.ratCast x) (Rat.cast.{0} Real Real.ratCast y)) (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) x y)
 Case conversion may be inaccurate. Consider using '#align rat.dist_cast Rat.dist_castₓ'. -/
 @[norm_cast, simp]
 theorem dist_cast (x y : ℚ) : dist (x : ℝ) y = dist x y :=
@@ -57,7 +57,7 @@ theorem dist_cast (x y : ℚ) : dist (x : ℝ) y = dist x y :=
 lean 3 declaration is
   UniformContinuous.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
 but is expected to have type
-  UniformContinuous.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (RatCast.ratCast.{0} Real Real.ratCast)
+  UniformContinuous.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (Rat.cast.{0} Real Real.ratCast)
 Case conversion may be inaccurate. Consider using '#align rat.uniform_continuous_coe_real Rat.uniformContinuous_coe_realₓ'. -/
 theorem uniformContinuous_coe_real : UniformContinuous (coe : ℚ → ℝ) :=
   uniformContinuous_comap
@@ -67,7 +67,7 @@ theorem uniformContinuous_coe_real : UniformContinuous (coe : ℚ → ℝ) :=
 lean 3 declaration is
   UniformEmbedding.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
 but is expected to have type
-  UniformEmbedding.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (RatCast.ratCast.{0} Real Real.ratCast)
+  UniformEmbedding.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (Rat.cast.{0} Real Real.ratCast)
 Case conversion may be inaccurate. Consider using '#align rat.uniform_embedding_coe_real Rat.uniformEmbedding_coe_realₓ'. -/
 theorem uniformEmbedding_coe_real : UniformEmbedding (coe : ℚ → ℝ) :=
   uniformEmbedding_comap Rat.cast_injective
@@ -77,7 +77,7 @@ theorem uniformEmbedding_coe_real : UniformEmbedding (coe : ℚ → ℝ) :=
 lean 3 declaration is
   DenseEmbedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
 but is expected to have type
-  DenseEmbedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (RatCast.ratCast.{0} Real Real.ratCast)
+  DenseEmbedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (Rat.cast.{0} Real Real.ratCast)
 Case conversion may be inaccurate. Consider using '#align rat.dense_embedding_coe_real Rat.denseEmbedding_coe_realₓ'. -/
 theorem denseEmbedding_coe_real : DenseEmbedding (coe : ℚ → ℝ) :=
   uniformEmbedding_coe_real.DenseEmbedding Rat.denseRange_cast
@@ -87,7 +87,7 @@ theorem denseEmbedding_coe_real : DenseEmbedding (coe : ℚ → ℝ) :=
 lean 3 declaration is
   Embedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
 but is expected to have type
-  Embedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (RatCast.ratCast.{0} Real Real.ratCast)
+  Embedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (Rat.cast.{0} Real Real.ratCast)
 Case conversion may be inaccurate. Consider using '#align rat.embedding_coe_real Rat.embedding_coe_realₓ'. -/
 theorem embedding_coe_real : Embedding (coe : ℚ → ℝ) :=
   denseEmbedding_coe_real.toEmbedding
@@ -97,7 +97,7 @@ theorem embedding_coe_real : Embedding (coe : ℚ → ℝ) :=
 lean 3 declaration is
   Continuous.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
 but is expected to have type
-  Continuous.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (RatCast.ratCast.{0} Real Real.ratCast)
+  Continuous.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (Rat.cast.{0} Real Real.ratCast)
 Case conversion may be inaccurate. Consider using '#align rat.continuous_coe_real Rat.continuous_coe_realₓ'. -/
 theorem continuous_coe_real : Continuous (coe : ℚ → ℝ) :=
   uniformContinuous_coe_real.Continuous

f4758115

bump to nightly-2023-03-09-03

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

061741a1

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro
 
 ! This file was ported from Lean 3 source module topology.instances.rat
-! leanprover-community/mathlib commit 560891c425c743b1a25d4f8447cce6dd60947c1a
+! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -17,6 +17,9 @@ import Mathbin.Topology.Instances.Real
 /-!
 # Topology on the ratonal numbers
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 The structure of a metric space on `ℚ` is introduced in this file, induced from `ℝ`.
 -/

560891c4

bump to nightly-2023-03-06-12

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

9dd4f257

Diff

@@ -29,59 +29,137 @@ namespace Rat
 instance : MetricSpace ℚ :=
   MetricSpace.induced coe Rat.cast_injective Real.metricSpace
 
+/- warning: rat.dist_eq -> Rat.dist_eq is a dubious translation:
+lean 3 declaration is
+  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) x y) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) y)))
+but is expected to have type
+  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) x y) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (RatCast.ratCast.{0} Real Real.ratCast x) (RatCast.ratCast.{0} Real Real.ratCast y)))
+Case conversion may be inaccurate. Consider using '#align rat.dist_eq Rat.dist_eqₓ'. -/
 theorem dist_eq (x y : ℚ) : dist x y = |x - y| :=
   rfl
 #align rat.dist_eq Rat.dist_eq
 
+/- warning: rat.dist_cast -> Rat.dist_cast is a dubious translation:
+lean 3 declaration is
+  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Real (PseudoMetricSpace.toHasDist.{0} Real Real.pseudoMetricSpace) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) y)) (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) x y)
+but is expected to have type
+  forall (x : Rat) (y : Rat), Eq.{1} Real (Dist.dist.{0} Real (PseudoMetricSpace.toDist.{0} Real Real.pseudoMetricSpace) (RatCast.ratCast.{0} Real Real.ratCast x) (RatCast.ratCast.{0} Real Real.ratCast y)) (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) x y)
+Case conversion may be inaccurate. Consider using '#align rat.dist_cast Rat.dist_castₓ'. -/
 @[norm_cast, simp]
 theorem dist_cast (x y : ℚ) : dist (x : ℝ) y = dist x y :=
   rfl
 #align rat.dist_cast Rat.dist_cast
 
+/- warning: rat.uniform_continuous_coe_real -> Rat.uniformContinuous_coe_real is a dubious translation:
+lean 3 declaration is
+  UniformContinuous.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
+but is expected to have type
+  UniformContinuous.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (RatCast.ratCast.{0} Real Real.ratCast)
+Case conversion may be inaccurate. Consider using '#align rat.uniform_continuous_coe_real Rat.uniformContinuous_coe_realₓ'. -/
 theorem uniformContinuous_coe_real : UniformContinuous (coe : ℚ → ℝ) :=
   uniformContinuous_comap
 #align rat.uniform_continuous_coe_real Rat.uniformContinuous_coe_real
 
+/- warning: rat.uniform_embedding_coe_real -> Rat.uniformEmbedding_coe_real is a dubious translation:
+lean 3 declaration is
+  UniformEmbedding.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
+but is expected to have type
+  UniformEmbedding.{0, 0} Rat Real (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (RatCast.ratCast.{0} Real Real.ratCast)
+Case conversion may be inaccurate. Consider using '#align rat.uniform_embedding_coe_real Rat.uniformEmbedding_coe_realₓ'. -/
 theorem uniformEmbedding_coe_real : UniformEmbedding (coe : ℚ → ℝ) :=
   uniformEmbedding_comap Rat.cast_injective
 #align rat.uniform_embedding_coe_real Rat.uniformEmbedding_coe_real
 
+/- warning: rat.dense_embedding_coe_real -> Rat.denseEmbedding_coe_real is a dubious translation:
+lean 3 declaration is
+  DenseEmbedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
+but is expected to have type
+  DenseEmbedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (RatCast.ratCast.{0} Real Real.ratCast)
+Case conversion may be inaccurate. Consider using '#align rat.dense_embedding_coe_real Rat.denseEmbedding_coe_realₓ'. -/
 theorem denseEmbedding_coe_real : DenseEmbedding (coe : ℚ → ℝ) :=
   uniformEmbedding_coe_real.DenseEmbedding Rat.denseRange_cast
 #align rat.dense_embedding_coe_real Rat.denseEmbedding_coe_real
 
+/- warning: rat.embedding_coe_real -> Rat.embedding_coe_real is a dubious translation:
+lean 3 declaration is
+  Embedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
+but is expected to have type
+  Embedding.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (RatCast.ratCast.{0} Real Real.ratCast)
+Case conversion may be inaccurate. Consider using '#align rat.embedding_coe_real Rat.embedding_coe_realₓ'. -/
 theorem embedding_coe_real : Embedding (coe : ℚ → ℝ) :=
   denseEmbedding_coe_real.toEmbedding
 #align rat.embedding_coe_real Rat.embedding_coe_real
 
+/- warning: rat.continuous_coe_real -> Rat.continuous_coe_real is a dubious translation:
+lean 3 declaration is
+  Continuous.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))))
+but is expected to have type
+  Continuous.{0, 0} Rat Real (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (RatCast.ratCast.{0} Real Real.ratCast)
+Case conversion may be inaccurate. Consider using '#align rat.continuous_coe_real Rat.continuous_coe_realₓ'. -/
 theorem continuous_coe_real : Continuous (coe : ℚ → ℝ) :=
   uniformContinuous_coe_real.Continuous
 #align rat.continuous_coe_real Rat.continuous_coe_real
 
 end Rat
 
+/- warning: nat.dist_cast_rat -> Nat.dist_cast_rat is a dubious translation:
+lean 3 declaration is
+  forall (x : Nat) (y : Nat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (NonAssocRing.toAddGroupWithOne.{0} Rat (Ring.toNonAssocRing.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (NonAssocRing.toAddGroupWithOne.{0} Rat (Ring.toNonAssocRing.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))) y)) (Dist.dist.{0} Nat Nat.hasDist x y)
+but is expected to have type
+  forall (x : Nat) (y : Nat), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))) x) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))) y)) (Dist.dist.{0} Nat Nat.instDistNat x y)
+Case conversion may be inaccurate. Consider using '#align nat.dist_cast_rat Nat.dist_cast_ratₓ'. -/
 @[norm_cast, simp]
 theorem Nat.dist_cast_rat (x y : ℕ) : dist (x : ℚ) y = dist x y := by
   rw [← Nat.dist_cast_real, ← Rat.dist_cast] <;> congr 1 <;> norm_cast
 #align nat.dist_cast_rat Nat.dist_cast_rat
 
+/- warning: nat.uniform_embedding_coe_rat -> Nat.uniformEmbedding_coe_rat is a dubious translation:
+lean 3 declaration is
+  UniformEmbedding.{0, 0} Nat Rat Nat.uniformSpace (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (NonAssocRing.toAddGroupWithOne.{0} Rat (Ring.toNonAssocRing.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))))
+but is expected to have type
+  UniformEmbedding.{0, 0} Nat Rat instUniformSpaceNat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))))
+Case conversion may be inaccurate. Consider using '#align nat.uniform_embedding_coe_rat Nat.uniformEmbedding_coe_ratₓ'. -/
 theorem Nat.uniformEmbedding_coe_rat : UniformEmbedding (coe : ℕ → ℚ) :=
   uniformEmbedding_bot_of_pairwise_le_dist zero_lt_one <| by simpa using Nat.pairwise_one_le_dist
 #align nat.uniform_embedding_coe_rat Nat.uniformEmbedding_coe_rat
 
+/- warning: nat.closed_embedding_coe_rat -> Nat.closedEmbedding_coe_rat is a dubious translation:
+lean 3 declaration is
+  ClosedEmbedding.{0, 0} Nat Rat Nat.topologicalSpace (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Rat (HasLiftT.mk.{1, 1} Nat Rat (CoeTCₓ.coe.{1, 1} Nat Rat (Nat.castCoe.{0} Rat (AddMonoidWithOne.toNatCast.{0} Rat (AddGroupWithOne.toAddMonoidWithOne.{0} Rat (NonAssocRing.toAddGroupWithOne.{0} Rat (Ring.toNonAssocRing.{0} Rat (StrictOrderedRing.toRing.{0} Rat (LinearOrderedRing.toStrictOrderedRing.{0} Rat Rat.linearOrderedRing))))))))))
+but is expected to have type
+  ClosedEmbedding.{0, 0} Nat Rat instTopologicalSpaceNat (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (Nat.cast.{0} Rat (NonAssocRing.toNatCast.{0} Rat (Ring.toNonAssocRing.{0} Rat (DivisionRing.toRing.{0} Rat Rat.divisionRing))))
+Case conversion may be inaccurate. Consider using '#align nat.closed_embedding_coe_rat Nat.closedEmbedding_coe_ratₓ'. -/
 theorem Nat.closedEmbedding_coe_rat : ClosedEmbedding (coe : ℕ → ℚ) :=
   closedEmbedding_of_pairwise_le_dist zero_lt_one <| by simpa using Nat.pairwise_one_le_dist
 #align nat.closed_embedding_coe_rat Nat.closedEmbedding_coe_rat
 
+/- warning: int.dist_cast_rat -> Int.dist_cast_rat is a dubious translation:
+lean 3 declaration is
+  forall (x : Int) (y : Int), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toHasDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Rat (HasLiftT.mk.{1, 1} Int Rat (CoeTCₓ.coe.{1, 1} Int Rat (Int.castCoe.{0} Rat Rat.hasIntCast))) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Rat (HasLiftT.mk.{1, 1} Int Rat (CoeTCₓ.coe.{1, 1} Int Rat (Int.castCoe.{0} Rat Rat.hasIntCast))) y)) (Dist.dist.{0} Int Int.hasDist x y)
+but is expected to have type
+  forall (x : Int) (y : Int), Eq.{1} Real (Dist.dist.{0} Rat (PseudoMetricSpace.toDist.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Int.cast.{0} Rat Rat.instIntCastRat x) (Int.cast.{0} Rat Rat.instIntCastRat y)) (Dist.dist.{0} Int Int.instDistInt x y)
+Case conversion may be inaccurate. Consider using '#align int.dist_cast_rat Int.dist_cast_ratₓ'. -/
 @[norm_cast, simp]
 theorem Int.dist_cast_rat (x y : ℤ) : dist (x : ℚ) y = dist x y := by
   rw [← Int.dist_cast_real, ← Rat.dist_cast] <;> congr 1 <;> norm_cast
 #align int.dist_cast_rat Int.dist_cast_rat
 
+/- warning: int.uniform_embedding_coe_rat -> Int.uniformEmbedding_coe_rat is a dubious translation:
+lean 3 declaration is
+  UniformEmbedding.{0, 0} Int Rat Int.uniformSpace (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Rat (HasLiftT.mk.{1, 1} Int Rat (CoeTCₓ.coe.{1, 1} Int Rat (Int.castCoe.{0} Rat Rat.hasIntCast))))
+but is expected to have type
+  UniformEmbedding.{0, 0} Int Rat instUniformSpaceInt (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Int.cast.{0} Rat Rat.instIntCastRat)
+Case conversion may be inaccurate. Consider using '#align int.uniform_embedding_coe_rat Int.uniformEmbedding_coe_ratₓ'. -/
 theorem Int.uniformEmbedding_coe_rat : UniformEmbedding (coe : ℤ → ℚ) :=
   uniformEmbedding_bot_of_pairwise_le_dist zero_lt_one <| by simpa using Int.pairwise_one_le_dist
 #align int.uniform_embedding_coe_rat Int.uniformEmbedding_coe_rat
 
+/- warning: int.closed_embedding_coe_rat -> Int.closedEmbedding_coe_rat is a dubious translation:
+lean 3 declaration is
+  ClosedEmbedding.{0, 0} Int Rat Int.topologicalSpace (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Rat (HasLiftT.mk.{1, 1} Int Rat (CoeTCₓ.coe.{1, 1} Int Rat (Int.castCoe.{0} Rat Rat.hasIntCast))))
+but is expected to have type
+  ClosedEmbedding.{0, 0} Int Rat instTopologicalSpaceInt (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (Int.cast.{0} Rat Rat.instIntCastRat)
+Case conversion may be inaccurate. Consider using '#align int.closed_embedding_coe_rat Int.closedEmbedding_coe_ratₓ'. -/
 theorem Int.closedEmbedding_coe_rat : ClosedEmbedding (coe : ℤ → ℚ) :=
   closedEmbedding_of_pairwise_le_dist zero_lt_one <| by simpa using Int.pairwise_one_le_dist
 #align int.closed_embedding_coe_rat Int.closedEmbedding_coe_rat
@@ -91,6 +169,12 @@ namespace Rat
 instance : NoncompactSpace ℚ :=
   Int.closedEmbedding_coe_rat.NoncompactSpace
 
+/- warning: rat.uniform_continuous_add -> Rat.uniformContinuous_add is a dubious translation:
+lean 3 declaration is
+  UniformContinuous.{0, 0} (Prod.{0, 0} Rat Rat) Rat (Prod.uniformSpace.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (fun (p : Prod.{0, 0} Rat Rat) => HAdd.hAdd.{0, 0, 0} Rat Rat Rat (instHAdd.{0} Rat Rat.hasAdd) (Prod.fst.{0, 0} Rat Rat p) (Prod.snd.{0, 0} Rat Rat p))
+but is expected to have type
+  UniformContinuous.{0, 0} (Prod.{0, 0} Rat Rat) Rat (instUniformSpaceProd.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (fun (p : Prod.{0, 0} Rat Rat) => HAdd.hAdd.{0, 0, 0} Rat Rat Rat (instHAdd.{0} Rat Rat.instAddRat) (Prod.fst.{0, 0} Rat Rat p) (Prod.snd.{0, 0} Rat Rat p))
+Case conversion may be inaccurate. Consider using '#align rat.uniform_continuous_add Rat.uniformContinuous_addₓ'. -/
 -- TODO(Mario): Find a way to use rat_add_continuous_lemma
 theorem uniformContinuous_add : UniformContinuous fun p : ℚ × ℚ => p.1 + p.2 :=
   Rat.uniformEmbedding_coe_real.to_uniformInducing.uniformContinuous_iff.2 <| by
@@ -100,6 +184,12 @@ theorem uniformContinuous_add : UniformContinuous fun p : ℚ × ℚ => p.1 + p.
           (rat.uniform_continuous_coe_real.prod_map Rat.uniformContinuous_coe_real)
 #align rat.uniform_continuous_add Rat.uniformContinuous_add
 
+/- warning: rat.uniform_continuous_neg -> Rat.uniformContinuous_neg is a dubious translation:
+lean 3 declaration is
+  UniformContinuous.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (Neg.neg.{0} Rat Rat.hasNeg)
+but is expected to have type
+  UniformContinuous.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Neg.neg.{0} Rat Rat.instNegRat)
+Case conversion may be inaccurate. Consider using '#align rat.uniform_continuous_neg Rat.uniformContinuous_negₓ'. -/
 theorem uniformContinuous_neg : UniformContinuous (@Neg.neg ℚ _) :=
   Metric.uniformContinuous_iff.2 fun ε ε0 =>
     ⟨_, ε0, fun a b h => by rw [dist_comm] at h <;> simpa [Rat.dist_eq] using h⟩
@@ -113,12 +203,24 @@ instance : TopologicalAddGroup ℚ := by infer_instance
 instance : OrderTopology ℚ :=
   induced_orderTopology _ (fun x y => Rat.cast_lt) (@exists_rat_btwn _ _ _)
 
+/- warning: rat.uniform_continuous_abs -> Rat.uniformContinuous_abs is a dubious translation:
+lean 3 declaration is
+  UniformContinuous.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (Abs.abs.{0} Rat (Neg.toHasAbs.{0} Rat Rat.hasNeg Rat.hasSup))
+but is expected to have type
+  UniformContinuous.{0, 0} Rat Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Abs.abs.{0} Rat (Neg.toHasAbs.{0} Rat Rat.instNegRat Rat.instSupRat))
+Case conversion may be inaccurate. Consider using '#align rat.uniform_continuous_abs Rat.uniformContinuous_absₓ'. -/
 theorem uniformContinuous_abs : UniformContinuous (abs : ℚ → ℚ) :=
   Metric.uniformContinuous_iff.2 fun ε ε0 =>
     ⟨ε, ε0, fun a b h =>
       lt_of_le_of_lt (by simpa [Rat.dist_eq] using abs_abs_sub_abs_le_abs_sub _ _) h⟩
 #align rat.uniform_continuous_abs Rat.uniformContinuous_abs
 
+/- warning: rat.continuous_mul -> Rat.continuous_mul is a dubious translation:
+lean 3 declaration is
+  Continuous.{0, 0} (Prod.{0, 0} Rat Rat) Rat (Prod.topologicalSpace.{0, 0} Rat Rat (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)))) (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace))) (fun (p : Prod.{0, 0} Rat Rat) => HMul.hMul.{0, 0, 0} Rat Rat Rat (instHMul.{0} Rat Rat.hasMul) (Prod.fst.{0, 0} Rat Rat p) (Prod.snd.{0, 0} Rat Rat p))
+but is expected to have type
+  Continuous.{0, 0} (Prod.{0, 0} Rat Rat) Rat (instTopologicalSpaceProd.{0, 0} Rat Rat (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)))) (UniformSpace.toTopologicalSpace.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat))) (fun (p : Prod.{0, 0} Rat Rat) => HMul.hMul.{0, 0, 0} Rat Rat Rat (instHMul.{0} Rat Rat.instMulRat) (Prod.fst.{0, 0} Rat Rat p) (Prod.snd.{0, 0} Rat Rat p))
+Case conversion may be inaccurate. Consider using '#align rat.continuous_mul Rat.continuous_mulₓ'. -/
 theorem continuous_mul : Continuous fun p : ℚ × ℚ => p.1 * p.2 :=
   Rat.embedding_coe_real.continuous_iff.2 <| by
     simp [(· ∘ ·)] <;>
@@ -128,6 +230,12 @@ theorem continuous_mul : Continuous fun p : ℚ × ℚ => p.1 * p.2 :=
 instance : TopologicalRing ℚ :=
   { Rat.topologicalAddGroup with continuous_mul := Rat.continuous_mul }
 
+/- warning: rat.totally_bounded_Icc -> Rat.totallyBounded_Icc is a dubious translation:
+lean 3 declaration is
+  forall (a : Rat) (b : Rat), TotallyBounded.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.metricSpace)) (Set.Icc.{0} Rat Rat.preorder a b)
+but is expected to have type
+  forall (a : Rat) (b : Rat), TotallyBounded.{0} Rat (PseudoMetricSpace.toUniformSpace.{0} Rat (MetricSpace.toPseudoMetricSpace.{0} Rat Rat.instMetricSpaceRat)) (Set.Icc.{0} Rat Rat.instPreorderRat a b)
+Case conversion may be inaccurate. Consider using '#align rat.totally_bounded_Icc Rat.totallyBounded_Iccₓ'. -/
 theorem totallyBounded_Icc (a b : ℚ) : TotallyBounded (Icc a b) := by
   simpa only [preimage_cast_Icc] using
     totallyBounded_preimage Rat.uniformEmbedding_coe_real (totallyBounded_Icc a b)

560891c4

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

560891c4

chore: split MetricSpace.basic (#7920)

This reduces the main file from 3340 to 2220 lines. The remaining file is somewhat entangled, so splitting is less obvious. Help is welcome, though a follow-up PR is probably better :-)

I've kept copyright and authors as they were originally.

2904132a

Diff

@@ -3,9 +3,7 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro
 -/
-import Mathlib.Topology.MetricSpace.Basic
 import Mathlib.Topology.Algebra.Order.Archimedean
-import Mathlib.Topology.Instances.Int
 import Mathlib.Topology.Instances.Nat
 import Mathlib.Topology.Instances.Real

560891c4

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,11 +2,6 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro
-
-! This file was ported from Lean 3 source module topology.instances.rat
-! leanprover-community/mathlib commit 560891c425c743b1a25d4f8447cce6dd60947c1a
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.MetricSpace.Basic
 import Mathlib.Topology.Algebra.Order.Archimedean
@@ -14,6 +9,8 @@ import Mathlib.Topology.Instances.Int
 import Mathlib.Topology.Instances.Nat
 import Mathlib.Topology.Instances.Real
 
+#align_import topology.instances.rat from "leanprover-community/mathlib"@"560891c425c743b1a25d4f8447cce6dd60947c1a"
+
 /-!
 # Topology on the rational numbers

560891c4

chore: fix many typos (#4967)

These are all doc fixes

6f9e51c3

Diff

@@ -15,7 +15,7 @@ import Mathlib.Topology.Instances.Nat
 import Mathlib.Topology.Instances.Real
 
 /-!
-# Topology on the ratonal numbers
+# Topology on the rational numbers
 
 The structure of a metric space on `ℚ` is introduced in this file, induced from `ℝ`.
 -/

560891c4

feat: port Topology.Instances.Rat (#2643)

b55832c6

`topology.instances.rat` ⟷ `Mathlib.Topology.Instances.Rat`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 511

topology.instances.rat ⟷ Mathlib.Topology.Instances.Rat

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 511

`topology.instances.rat` ⟷ `Mathlib.Topology.Instances.Rat`