topology.algebra.constructions | 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

c10e724b

(last sync)

refactor(topology/algebra/field): drop topological_space_units (#18536)

See Zulip chat

Also generalize TC assumptions in inv_mem_iff.

Diff

@@ -81,6 +81,26 @@ instance : topological_space Mˣ := prod.topological_space.induced (embed_produc
 @[to_additive] lemma embedding_embed_product : embedding (embed_product M) :=
 ⟨inducing_embed_product, embed_product_injective M⟩
 
+@[to_additive] lemma topology_eq_inf :
+  units.topological_space = topological_space.induced (coe : Mˣ → M) ‹_› ⊓
+    topological_space.induced (λ u, ↑u⁻¹ : Mˣ → M) ‹_› :=
+by simp only [inducing_embed_product.1, prod.topological_space, induced_inf,
+  mul_opposite.topological_space, induced_compose]; refl
+
+/-- An auxiliary lemma that can be used to prove that coercion `Mˣ → M` is a topological embedding.
+Use `units.coe_embedding₀`, `units.coe_embedding`, or `to_units_homeomorph` instead. -/
+@[to_additive "An auxiliary lemma that can be used to prove that coercion `add_units M → M` is a
+topological embedding. Use `add_units.coe_embedding` or `to_add_units_homeomorph` instead."]
+lemma embedding_coe_mk {M : Type*} [division_monoid M] [topological_space M]
+  (h : continuous_on has_inv.inv {x : M | is_unit x}) : embedding (coe : Mˣ → M) :=
+begin
+  refine ⟨⟨_⟩, ext⟩,
+  rw [topology_eq_inf, inf_eq_left, ← continuous_iff_le_induced, continuous_iff_continuous_at],
+  intros u s hs,
+  simp only [coe_inv, nhds_induced, filter.mem_map] at hs ⊢,
+  exact ⟨_, mem_inf_principal.1 (h u u.is_unit hs), λ u' hu', hu' u'.is_unit⟩
+end
+
 @[to_additive] lemma continuous_embed_product : continuous (embed_product M) :=
 continuous_induced_dom

d90e4e18

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

c10e724b

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2021 Nicolò Cavalleri. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Nicolò Cavalleri
 -/
-import Mathbin.Topology.Homeomorph
+import Topology.Homeomorph
 
 #align_import topology.algebra.constructions from "leanprover-community/mathlib"@"c10e724be91096453ee3db13862b9fb9a992fef2"

c10e724b

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2021 Nicolò Cavalleri. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Nicolò Cavalleri
-
-! This file was ported from Lean 3 source module topology.algebra.constructions
-! leanprover-community/mathlib commit c10e724be91096453ee3db13862b9fb9a992fef2
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.Homeomorph
 
+#align_import topology.algebra.constructions from "leanprover-community/mathlib"@"c10e724be91096453ee3db13862b9fb9a992fef2"
+
 /-!
 # Topological space structure on the opposite monoid and on the units group

c10e724b

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -119,18 +119,23 @@ variable [TopologicalSpace M] [Monoid M] [TopologicalSpace X]
 instance : TopologicalSpace Mˣ :=
   Prod.topologicalSpace.induced (embedProduct M)
 
+#print Units.inducing_embedProduct /-
 @[to_additive]
 theorem inducing_embedProduct : Inducing (embedProduct M) :=
   ⟨rfl⟩
 #align units.inducing_embed_product Units.inducing_embedProduct
 #align add_units.inducing_embed_product AddUnits.inducing_embedProduct
+-/
 
+#print Units.embedding_embedProduct /-
 @[to_additive]
 theorem embedding_embedProduct : Embedding (embedProduct M) :=
   ⟨inducing_embedProduct, embedProduct_injective M⟩
 #align units.embedding_embed_product Units.embedding_embedProduct
 #align add_units.embedding_embed_product AddUnits.embedding_embedProduct
+-/
 
+#print Units.topology_eq_inf /-
 @[to_additive]
 theorem topology_eq_inf :
     Units.topologicalSpace =
@@ -142,7 +147,9 @@ theorem topology_eq_inf :
     rfl
 #align units.topology_eq_inf Units.topology_eq_inf
 #align add_units.topology_eq_inf AddUnits.topology_eq_inf
+-/
 
+#print Units.embedding_val_mk /-
 /-- An auxiliary lemma that can be used to prove that coercion `Mˣ → M` is a topological embedding.
 Use `units.coe_embedding₀`, `units.coe_embedding`, or `to_units_homeomorph` instead. -/
 @[to_additive
@@ -157,19 +164,25 @@ theorem embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
   exact ⟨_, mem_inf_principal.1 (h u u.is_unit hs), fun u' hu' => hu' u'.IsUnit⟩
 #align units.embedding_coe_mk Units.embedding_val_mk
 #align add_units.embedding_coe_mk AddUnits.embedding_val_mk
+-/
 
+#print Units.continuous_embedProduct /-
 @[to_additive]
 theorem continuous_embedProduct : Continuous (embedProduct M) :=
   continuous_induced_dom
 #align units.continuous_embed_product Units.continuous_embedProduct
 #align add_units.continuous_embed_product AddUnits.continuous_embedProduct
+-/
 
+#print Units.continuous_val /-
 @[to_additive]
 theorem continuous_val : Continuous (coe : Mˣ → M) :=
   (@continuous_embedProduct M _ _).fst
 #align units.continuous_coe Units.continuous_val
 #align add_units.continuous_coe AddUnits.continuous_val
+-/
 
+#print Units.continuous_iff /-
 @[to_additive]
 protected theorem continuous_iff {f : X → Mˣ} :
     Continuous f ↔ Continuous (coe ∘ f : X → M) ∧ Continuous (fun x => ↑(f x)⁻¹ : X → M) := by
@@ -178,12 +191,15 @@ protected theorem continuous_iff {f : X → Mˣ} :
     unop_op]
 #align units.continuous_iff Units.continuous_iff
 #align add_units.continuous_iff AddUnits.continuous_iff
+-/
 
+#print Units.continuous_coe_inv /-
 @[to_additive]
 theorem continuous_coe_inv : Continuous (fun u => ↑u⁻¹ : Mˣ → M) :=
   (Units.continuous_iff.1 continuous_id).2
 #align units.continuous_coe_inv Units.continuous_coe_inv
 #align add_units.continuous_coe_neg AddUnits.continuous_coe_neg
+-/
 
 end Units

c10e724b

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -148,7 +148,7 @@ Use `units.coe_embedding₀`, `units.coe_embedding`, or `to_units_homeomorph` in
 @[to_additive
       "An auxiliary lemma that can be used to prove that coercion `add_units M → M` is a\ntopological embedding. Use `add_units.coe_embedding` or `to_add_units_homeomorph` instead."]
 theorem embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
-    (h : ContinuousOn Inv.inv { x : M | IsUnit x }) : Embedding (coe : Mˣ → M) :=
+    (h : ContinuousOn Inv.inv {x : M | IsUnit x}) : Embedding (coe : Mˣ → M) :=
   by
   refine' ⟨⟨_⟩, ext⟩
   rw [topology_eq_inf, inf_eq_left, ← continuous_iff_le_induced, continuous_iff_continuousAt]

c10e724b

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -153,7 +153,7 @@ theorem embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
   refine' ⟨⟨_⟩, ext⟩
   rw [topology_eq_inf, inf_eq_left, ← continuous_iff_le_induced, continuous_iff_continuousAt]
   intro u s hs
-  simp only [coe_inv, nhds_induced, Filter.mem_map] at hs⊢
+  simp only [coe_inv, nhds_induced, Filter.mem_map] at hs ⊢
   exact ⟨_, mem_inf_principal.1 (h u u.is_unit hs), fun u' hu' => hu' u'.IsUnit⟩
 #align units.embedding_coe_mk Units.embedding_val_mk
 #align add_units.embedding_coe_mk AddUnits.embedding_val_mk

c10e724b

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -30,7 +30,7 @@ variable {M X : Type _}
 
 open Filter
 
-open Topology
+open scoped Topology
 
 namespace MulOpposite

c10e724b

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -119,36 +119,18 @@ variable [TopologicalSpace M] [Monoid M] [TopologicalSpace X]
 instance : TopologicalSpace Mˣ :=
   Prod.topologicalSpace.induced (embedProduct M)
 
-/- warning: units.inducing_embed_product -> Units.inducing_embedProduct is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
-Case conversion may be inaccurate. Consider using '#align units.inducing_embed_product Units.inducing_embedProductₓ'. -/
 @[to_additive]
 theorem inducing_embedProduct : Inducing (embedProduct M) :=
   ⟨rfl⟩
 #align units.inducing_embed_product Units.inducing_embedProduct
 #align add_units.inducing_embed_product AddUnits.inducing_embedProduct
 
-/- warning: units.embedding_embed_product -> Units.embedding_embedProduct is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
-Case conversion may be inaccurate. Consider using '#align units.embedding_embed_product Units.embedding_embedProductₓ'. -/
 @[to_additive]
 theorem embedding_embedProduct : Embedding (embedProduct M) :=
   ⟨inducing_embedProduct, embedProduct_injective M⟩
 #align units.embedding_embed_product Units.embedding_embedProduct
 #align add_units.embedding_embed_product AddUnits.embedding_embedProduct
 
-/- warning: units.topology_eq_inf -> Units.topology_eq_inf is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Eq.{succ u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Inf.inf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (SemilatticeInf.toHasInf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Lattice.toSemilatticeInf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (ConditionallyCompleteLattice.toLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (TopologicalSpace.completeLattice.{u1} (Units.{u1} M _inst_2)))))) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2))))) _inst_1) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M (fun (u : Units.{u1} M _inst_2) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2)))) (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.hasInv.{u1} M _inst_2) u)) _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Eq.{succ u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (Inf.inf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Lattice.toInf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (ConditionallyCompleteLattice.toLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (TopologicalSpace.instCompleteLatticeTopologicalSpace.{u1} (Units.{u1} M _inst_2))))) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M (Units.val.{u1} M _inst_2) _inst_1) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M (fun (u : Units.{u1} M _inst_2) => Units.val.{u1} M _inst_2 (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.instInv.{u1} M _inst_2) u)) _inst_1))
-Case conversion may be inaccurate. Consider using '#align units.topology_eq_inf Units.topology_eq_infₓ'. -/
 @[to_additive]
 theorem topology_eq_inf :
     Units.topologicalSpace =
@@ -161,12 +143,6 @@ theorem topology_eq_inf :
 #align units.topology_eq_inf Units.topology_eq_inf
 #align add_units.topology_eq_inf AddUnits.topology_eq_inf
 
-/- warning: units.embedding_coe_mk -> Units.embedding_val_mk is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_4 : DivisionMonoid.{u1} M] [_inst_5 : TopologicalSpace.{u1} M], (ContinuousOn.{u1, u1} M M _inst_5 _inst_5 (Inv.inv.{u1} M (DivInvMonoid.toHasInv.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) (setOf.{u1} M (fun (x : M) => IsUnit.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4)) x))) -> (Embedding.{u1, u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (Units.topologicalSpace.{u1} M _inst_5 (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) _inst_5 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (coeBase.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (Units.hasCoe.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_4 : DivisionMonoid.{u1} M] [_inst_5 : TopologicalSpace.{u1} M], (ContinuousOn.{u1, u1} M M _inst_5 _inst_5 (Inv.inv.{u1} M (InvOneClass.toInv.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_4)))) (setOf.{u1} M (fun (x : M) => IsUnit.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4)) x))) -> (Embedding.{u1, u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (Units.instTopologicalSpaceUnits.{u1} M _inst_5 (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) _inst_5 (Units.val.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))))
-Case conversion may be inaccurate. Consider using '#align units.embedding_coe_mk Units.embedding_val_mkₓ'. -/
 /-- An auxiliary lemma that can be used to prove that coercion `Mˣ → M` is a topological embedding.
 Use `units.coe_embedding₀`, `units.coe_embedding`, or `to_units_homeomorph` instead. -/
 @[to_additive
@@ -182,36 +158,18 @@ theorem embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
 #align units.embedding_coe_mk Units.embedding_val_mk
 #align add_units.embedding_coe_mk AddUnits.embedding_val_mk
 
-/- warning: units.continuous_embed_product -> Units.continuous_embedProduct is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
-Case conversion may be inaccurate. Consider using '#align units.continuous_embed_product Units.continuous_embedProductₓ'. -/
 @[to_additive]
 theorem continuous_embedProduct : Continuous (embedProduct M) :=
   continuous_induced_dom
 #align units.continuous_embed_product Units.continuous_embedProduct
 #align add_units.continuous_embed_product AddUnits.continuous_embedProduct
 
-/- warning: units.continuous_coe -> Units.continuous_val is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) M (Units.topologicalSpace.{u1} M _inst_1 _inst_2) _inst_1 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2)))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) M (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) _inst_1 (Units.val.{u1} M _inst_2)
-Case conversion may be inaccurate. Consider using '#align units.continuous_coe Units.continuous_valₓ'. -/
 @[to_additive]
 theorem continuous_val : Continuous (coe : Mˣ → M) :=
   (@continuous_embedProduct M _ _).fst
 #align units.continuous_coe Units.continuous_val
 #align add_units.continuous_coe AddUnits.continuous_val
 
-/- warning: units.continuous_iff -> Units.continuous_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M] [_inst_3 : TopologicalSpace.{u2} X] {f : X -> (Units.{u1} M _inst_2)}, Iff (Continuous.{u2, u1} X (Units.{u1} M _inst_2) _inst_3 (Units.topologicalSpace.{u1} M _inst_1 _inst_2) f) (And (Continuous.{u2, u1} X M _inst_3 _inst_1 (Function.comp.{succ u2, succ u1, succ u1} X (Units.{u1} M _inst_2) M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2))))) f)) (Continuous.{u2, u1} X M _inst_3 _inst_1 (fun (x : X) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2)))) (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.hasInv.{u1} M _inst_2) (f x)))))
-but is expected to have type
-  forall {M : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} M] [_inst_2 : Monoid.{u2} M] [_inst_3 : TopologicalSpace.{u1} X] {f : X -> (Units.{u2} M _inst_2)}, Iff (Continuous.{u1, u2} X (Units.{u2} M _inst_2) _inst_3 (Units.instTopologicalSpaceUnits.{u2} M _inst_1 _inst_2) f) (And (Continuous.{u1, u2} X M _inst_3 _inst_1 (Function.comp.{succ u1, succ u2, succ u2} X (Units.{u2} M _inst_2) M (Units.val.{u2} M _inst_2) f)) (Continuous.{u1, u2} X M _inst_3 _inst_1 (fun (x : X) => Units.val.{u2} M _inst_2 (Inv.inv.{u2} (Units.{u2} M _inst_2) (Units.instInv.{u2} M _inst_2) (f x)))))
-Case conversion may be inaccurate. Consider using '#align units.continuous_iff Units.continuous_iffₓ'. -/
 @[to_additive]
 protected theorem continuous_iff {f : X → Mˣ} :
     Continuous f ↔ Continuous (coe ∘ f : X → M) ∧ Continuous (fun x => ↑(f x)⁻¹ : X → M) := by
@@ -221,12 +179,6 @@ protected theorem continuous_iff {f : X → Mˣ} :
 #align units.continuous_iff Units.continuous_iff
 #align add_units.continuous_iff AddUnits.continuous_iff
 
-/- warning: units.continuous_coe_inv -> Units.continuous_coe_inv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) M (Units.topologicalSpace.{u1} M _inst_1 _inst_2) _inst_1 (fun (u : Units.{u1} M _inst_2) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2)))) (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.hasInv.{u1} M _inst_2) u))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) M (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) _inst_1 (fun (u : Units.{u1} M _inst_2) => Units.val.{u1} M _inst_2 (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.instInv.{u1} M _inst_2) u))
-Case conversion may be inaccurate. Consider using '#align units.continuous_coe_inv Units.continuous_coe_invₓ'. -/
 @[to_additive]
 theorem continuous_coe_inv : Continuous (fun u => ↑u⁻¹ : Mˣ → M) :=
   (Units.continuous_iff.1 continuous_id).2

c10e724b

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -123,7 +123,7 @@ instance : TopologicalSpace Mˣ :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.inducing_embed_product Units.inducing_embedProductₓ'. -/
 @[to_additive]
 theorem inducing_embedProduct : Inducing (embedProduct M) :=
@@ -135,7 +135,7 @@ theorem inducing_embedProduct : Inducing (embedProduct M) :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.embedding_embed_product Units.embedding_embedProductₓ'. -/
 @[to_additive]
 theorem embedding_embedProduct : Embedding (embedProduct M) :=
@@ -186,7 +186,7 @@ theorem embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.continuous_embed_product Units.continuous_embedProductₓ'. -/
 @[to_additive]
 theorem continuous_embedProduct : Continuous (embedProduct M) :=

c10e724b

bump to nightly-2023-04-25-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/2651125b48fc5c170ab1111afd0817c903b1fc6c

56c36841

Diff

@@ -147,7 +147,7 @@ theorem embedding_embedProduct : Embedding (embedProduct M) :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Eq.{succ u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Inf.inf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (SemilatticeInf.toHasInf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Lattice.toSemilatticeInf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (ConditionallyCompleteLattice.toLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (TopologicalSpace.completeLattice.{u1} (Units.{u1} M _inst_2)))))) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2))))) _inst_1) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M (fun (u : Units.{u1} M _inst_2) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2)))) (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.hasInv.{u1} M _inst_2) u)) _inst_1))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Eq.{succ u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (Inf.inf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Lattice.toInf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (ConditionallyCompleteLattice.toLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (TopologicalSpace.instCompleteLatticeTopologicalSpace.{u1} (Units.{u1} M _inst_2))))) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M (Units.val.{u1} M _inst_2) _inst_1) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M (fun (u : Units.{u1} M _inst_2) => Units.val.{u1} M _inst_2 (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.instInvUnits.{u1} M _inst_2) u)) _inst_1))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Eq.{succ u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (Inf.inf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Lattice.toInf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (ConditionallyCompleteLattice.toLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (TopologicalSpace.instCompleteLatticeTopologicalSpace.{u1} (Units.{u1} M _inst_2))))) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M (Units.val.{u1} M _inst_2) _inst_1) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M (fun (u : Units.{u1} M _inst_2) => Units.val.{u1} M _inst_2 (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.instInv.{u1} M _inst_2) u)) _inst_1))
 Case conversion may be inaccurate. Consider using '#align units.topology_eq_inf Units.topology_eq_infₓ'. -/
 @[to_additive]
 theorem topology_eq_inf :
@@ -210,7 +210,7 @@ theorem continuous_val : Continuous (coe : Mˣ → M) :=
 lean 3 declaration is
   forall {M : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M] [_inst_3 : TopologicalSpace.{u2} X] {f : X -> (Units.{u1} M _inst_2)}, Iff (Continuous.{u2, u1} X (Units.{u1} M _inst_2) _inst_3 (Units.topologicalSpace.{u1} M _inst_1 _inst_2) f) (And (Continuous.{u2, u1} X M _inst_3 _inst_1 (Function.comp.{succ u2, succ u1, succ u1} X (Units.{u1} M _inst_2) M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2))))) f)) (Continuous.{u2, u1} X M _inst_3 _inst_1 (fun (x : X) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2)))) (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.hasInv.{u1} M _inst_2) (f x)))))
 but is expected to have type
-  forall {M : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} M] [_inst_2 : Monoid.{u2} M] [_inst_3 : TopologicalSpace.{u1} X] {f : X -> (Units.{u2} M _inst_2)}, Iff (Continuous.{u1, u2} X (Units.{u2} M _inst_2) _inst_3 (Units.instTopologicalSpaceUnits.{u2} M _inst_1 _inst_2) f) (And (Continuous.{u1, u2} X M _inst_3 _inst_1 (Function.comp.{succ u1, succ u2, succ u2} X (Units.{u2} M _inst_2) M (Units.val.{u2} M _inst_2) f)) (Continuous.{u1, u2} X M _inst_3 _inst_1 (fun (x : X) => Units.val.{u2} M _inst_2 (Inv.inv.{u2} (Units.{u2} M _inst_2) (Units.instInvUnits.{u2} M _inst_2) (f x)))))
+  forall {M : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} M] [_inst_2 : Monoid.{u2} M] [_inst_3 : TopologicalSpace.{u1} X] {f : X -> (Units.{u2} M _inst_2)}, Iff (Continuous.{u1, u2} X (Units.{u2} M _inst_2) _inst_3 (Units.instTopologicalSpaceUnits.{u2} M _inst_1 _inst_2) f) (And (Continuous.{u1, u2} X M _inst_3 _inst_1 (Function.comp.{succ u1, succ u2, succ u2} X (Units.{u2} M _inst_2) M (Units.val.{u2} M _inst_2) f)) (Continuous.{u1, u2} X M _inst_3 _inst_1 (fun (x : X) => Units.val.{u2} M _inst_2 (Inv.inv.{u2} (Units.{u2} M _inst_2) (Units.instInv.{u2} M _inst_2) (f x)))))
 Case conversion may be inaccurate. Consider using '#align units.continuous_iff Units.continuous_iffₓ'. -/
 @[to_additive]
 protected theorem continuous_iff {f : X → Mˣ} :
@@ -225,7 +225,7 @@ protected theorem continuous_iff {f : X → Mˣ} :
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) M (Units.topologicalSpace.{u1} M _inst_1 _inst_2) _inst_1 (fun (u : Units.{u1} M _inst_2) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2)))) (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.hasInv.{u1} M _inst_2) u))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) M (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) _inst_1 (fun (u : Units.{u1} M _inst_2) => Units.val.{u1} M _inst_2 (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.instInvUnits.{u1} M _inst_2) u))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) M (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) _inst_1 (fun (u : Units.{u1} M _inst_2) => Units.val.{u1} M _inst_2 (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.instInv.{u1} M _inst_2) u))
 Case conversion may be inaccurate. Consider using '#align units.continuous_coe_inv Units.continuous_coe_invₓ'. -/
 @[to_additive]
 theorem continuous_coe_inv : Continuous (fun u => ↑u⁻¹ : Mˣ → M) :=

c10e724b

bump to nightly-2023-03-24-16

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

5b87f9bb

Diff

@@ -123,7 +123,7 @@ instance : TopologicalSpace Mˣ :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.inducing_embed_product Units.inducing_embedProductₓ'. -/
 @[to_additive]
 theorem inducing_embedProduct : Inducing (embedProduct M) :=
@@ -135,7 +135,7 @@ theorem inducing_embedProduct : Inducing (embedProduct M) :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.embedding_embed_product Units.embedding_embedProductₓ'. -/
 @[to_additive]
 theorem embedding_embedProduct : Embedding (embedProduct M) :=
@@ -186,7 +186,7 @@ theorem embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.continuous_embed_product Units.continuous_embedProductₓ'. -/
 @[to_additive]
 theorem continuous_embedProduct : Continuous (embedProduct M) :=

c10e724b

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -123,7 +123,7 @@ instance : TopologicalSpace Mˣ :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.inducing_embed_product Units.inducing_embedProductₓ'. -/
 @[to_additive]
 theorem inducing_embedProduct : Inducing (embedProduct M) :=
@@ -135,7 +135,7 @@ theorem inducing_embedProduct : Inducing (embedProduct M) :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.embedding_embed_product Units.embedding_embedProductₓ'. -/
 @[to_additive]
 theorem embedding_embedProduct : Embedding (embedProduct M) :=
@@ -186,7 +186,7 @@ theorem embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.continuous_embed_product Units.continuous_embedProductₓ'. -/
 @[to_additive]
 theorem continuous_embedProduct : Continuous (embedProduct M) :=

c10e724b

bump to nightly-2023-03-08-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

10f15343

Diff

@@ -123,7 +123,7 @@ instance : TopologicalSpace Mˣ :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Inducing.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.inducing_embed_product Units.inducing_embedProductₓ'. -/
 @[to_additive]
 theorem inducing_embedProduct : Inducing (embedProduct M) :=
@@ -135,7 +135,7 @@ theorem inducing_embedProduct : Inducing (embedProduct M) :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Embedding.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.embedding_embed_product Units.embedding_embedProductₓ'. -/
 @[to_additive]
 theorem embedding_embedProduct : Embedding (embedProduct M) :=
@@ -186,7 +186,7 @@ theorem embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (instTopologicalSpaceProd.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.instTopologicalSpaceMulOpposite.{u1} M _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (fun (_x : Units.{u1} M _inst_2) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_2) => Prod.{u1, u1} M (MulOpposite.{u1} M)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.instMulOneClassUnits.{u1} M _inst_2) (Prod.instMulOneClassProd.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.instMulOneClassMulOpposite.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))))) (Units.embedProduct.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.continuous_embed_product Units.continuous_embedProductₓ'. -/
 @[to_additive]
 theorem continuous_embedProduct : Continuous (embedProduct M) :=

c10e724b

bump to nightly-2023-03-03-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/62e8311c791f02c47451bf14aa2501048e7c2f33

7fe4dd24

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Nicolò Cavalleri
 
 ! This file was ported from Lean 3 source module topology.algebra.constructions
-! leanprover-community/mathlib commit 0ebfdb71919ac6ca5d7fbc61a082fa2519556818
+! leanprover-community/mathlib commit c10e724be91096453ee3db13862b9fb9a992fef2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -143,6 +143,45 @@ theorem embedding_embedProduct : Embedding (embedProduct M) :=
 #align units.embedding_embed_product Units.embedding_embedProduct
 #align add_units.embedding_embed_product AddUnits.embedding_embedProduct
 
+/- warning: units.topology_eq_inf -> Units.topology_eq_inf is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Eq.{succ u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Inf.inf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (SemilatticeInf.toHasInf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Lattice.toSemilatticeInf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (ConditionallyCompleteLattice.toLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (TopologicalSpace.completeLattice.{u1} (Units.{u1} M _inst_2)))))) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2))))) _inst_1) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M (fun (u : Units.{u1} M _inst_2) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_2) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_2) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_2) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_2) M (Units.hasCoe.{u1} M _inst_2)))) (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.hasInv.{u1} M _inst_2) u)) _inst_1))
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Eq.{succ u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Units.instTopologicalSpaceUnits.{u1} M _inst_1 _inst_2) (Inf.inf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (Lattice.toInf.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (ConditionallyCompleteLattice.toLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (TopologicalSpace.{u1} (Units.{u1} M _inst_2)) (TopologicalSpace.instCompleteLatticeTopologicalSpace.{u1} (Units.{u1} M _inst_2))))) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M (Units.val.{u1} M _inst_2) _inst_1) (TopologicalSpace.induced.{u1, u1} (Units.{u1} M _inst_2) M (fun (u : Units.{u1} M _inst_2) => Units.val.{u1} M _inst_2 (Inv.inv.{u1} (Units.{u1} M _inst_2) (Units.instInvUnits.{u1} M _inst_2) u)) _inst_1))
+Case conversion may be inaccurate. Consider using '#align units.topology_eq_inf Units.topology_eq_infₓ'. -/
+@[to_additive]
+theorem topology_eq_inf :
+    Units.topologicalSpace =
+      TopologicalSpace.induced (coe : Mˣ → M) ‹_› ⊓
+        TopologicalSpace.induced (fun u => ↑u⁻¹ : Mˣ → M) ‹_› :=
+  by
+  simp only [inducing_embed_product.1, Prod.topologicalSpace, induced_inf,
+      MulOpposite.topologicalSpace, induced_compose] <;>
+    rfl
+#align units.topology_eq_inf Units.topology_eq_inf
+#align add_units.topology_eq_inf AddUnits.topology_eq_inf
+
+/- warning: units.embedding_coe_mk -> Units.embedding_val_mk is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_4 : DivisionMonoid.{u1} M] [_inst_5 : TopologicalSpace.{u1} M], (ContinuousOn.{u1, u1} M M _inst_5 _inst_5 (Inv.inv.{u1} M (DivInvMonoid.toHasInv.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) (setOf.{u1} M (fun (x : M) => IsUnit.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4)) x))) -> (Embedding.{u1, u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (Units.topologicalSpace.{u1} M _inst_5 (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) _inst_5 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (coeBase.{succ u1, succ u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (Units.hasCoe.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))))))))
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_4 : DivisionMonoid.{u1} M] [_inst_5 : TopologicalSpace.{u1} M], (ContinuousOn.{u1, u1} M M _inst_5 _inst_5 (Inv.inv.{u1} M (InvOneClass.toInv.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M _inst_4)))) (setOf.{u1} M (fun (x : M) => IsUnit.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4)) x))) -> (Embedding.{u1, u1} (Units.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) M (Units.instTopologicalSpaceUnits.{u1} M _inst_5 (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))) _inst_5 (Units.val.{u1} M (DivInvMonoid.toMonoid.{u1} M (DivisionMonoid.toDivInvMonoid.{u1} M _inst_4))))
+Case conversion may be inaccurate. Consider using '#align units.embedding_coe_mk Units.embedding_val_mkₓ'. -/
+/-- An auxiliary lemma that can be used to prove that coercion `Mˣ → M` is a topological embedding.
+Use `units.coe_embedding₀`, `units.coe_embedding`, or `to_units_homeomorph` instead. -/
+@[to_additive
+      "An auxiliary lemma that can be used to prove that coercion `add_units M → M` is a\ntopological embedding. Use `add_units.coe_embedding` or `to_add_units_homeomorph` instead."]
+theorem embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
+    (h : ContinuousOn Inv.inv { x : M | IsUnit x }) : Embedding (coe : Mˣ → M) :=
+  by
+  refine' ⟨⟨_⟩, ext⟩
+  rw [topology_eq_inf, inf_eq_left, ← continuous_iff_le_induced, continuous_iff_continuousAt]
+  intro u s hs
+  simp only [coe_inv, nhds_induced, Filter.mem_map] at hs⊢
+  exact ⟨_, mem_inf_principal.1 (h u u.is_unit hs), fun u' hu' => hu' u'.IsUnit⟩
+#align units.embedding_coe_mk Units.embedding_val_mk
+#align add_units.embedding_coe_mk AddUnits.embedding_val_mk
+
 /- warning: units.continuous_embed_product -> Units.continuous_embedProduct is a dubious translation:
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} M] [_inst_2 : Monoid.{u1} M], Continuous.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.topologicalSpace.{u1} M _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u1} M (MulOpposite.{u1} M) _inst_1 (MulOpposite.topologicalSpace.{u1} M _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) => (Units.{u1} M _inst_2) -> (Prod.{u1, u1} M (MulOpposite.{u1} M))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_2) (Prod.{u1, u1} M (MulOpposite.{u1} M)) (Units.mulOneClass.{u1} M _inst_2) (Prod.mulOneClass.{u1, u1} M (MulOpposite.{u1} M) (Monoid.toMulOneClass.{u1} M _inst_2) (MulOpposite.mulOneClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)))) (Units.embedProduct.{u1} M _inst_2))

0ebfdb71

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

c10e724b

chore(Topology/Algebra): add missing #aligns (#10307)

b4f55ab2

Diff

@@ -53,7 +53,11 @@ def opHomeomorph : M ≃ₜ Mᵐᵒᵖ where
   continuous_toFun := continuous_op
   continuous_invFun := continuous_unop
 #align mul_opposite.op_homeomorph MulOpposite.opHomeomorph
+#align mul_opposite.op_homeomorph_apply MulOpposite.opHomeomorph_apply
+#align mul_opposite.op_homeomorph_symm_apply MulOpposite.opHomeomorph_symm_apply
 #align add_opposite.op_homeomorph AddOpposite.opHomeomorph
+#align add_opposite.op_homeomorph_apply AddOpposite.opHomeomorph_apply
+#align add_opposite.op_homeomorph_symm_apply AddOpposite.opHomeomorph_symm_apply
 
 @[to_additive]
 instance instT2Space [T2Space M] : T2Space Mᵐᵒᵖ :=

c10e724b

feat(Topology/Algebra): add DiscreteTopology Mˣ (#7028)

Add instances for [DiscreteTopology M] : DiscreteTopology Mᵐᵒᵖ and [DiscreteTopology M] : DiscreteTopology Mˣ, as well as additive versions.

527ecc31

Diff

@@ -56,9 +56,13 @@ def opHomeomorph : M ≃ₜ Mᵐᵒᵖ where
 #align add_opposite.op_homeomorph AddOpposite.opHomeomorph
 
 @[to_additive]
-instance [T2Space M] : T2Space Mᵐᵒᵖ :=
+instance instT2Space [T2Space M] : T2Space Mᵐᵒᵖ :=
   opHomeomorph.symm.embedding.t2Space
 
+@[to_additive]
+instance instDiscreteTopology [DiscreteTopology M] : DiscreteTopology Mᵐᵒᵖ :=
+  opHomeomorph.symm.embedding.discreteTopology
+
 @[to_additive (attr := simp)]
 theorem map_op_nhds (x : M) : map (op : M → Mᵐᵒᵖ) (𝓝 x) = 𝓝 (op x) :=
   opHomeomorph.map_nhds_eq x
@@ -109,6 +113,14 @@ theorem embedding_embedProduct : Embedding (embedProduct M) :=
 #align units.embedding_embed_product Units.embedding_embedProduct
 #align add_units.embedding_embed_product AddUnits.embedding_embedProduct
 
+@[to_additive]
+instance instT2Space [T2Space M] : T2Space Mˣ :=
+  embedding_embedProduct.t2Space
+
+@[to_additive]
+instance instDiscreteTopology [DiscreteTopology M] : DiscreteTopology Mˣ :=
+  embedding_embedProduct.discreteTopology
+
 @[to_additive] lemma topology_eq_inf :
     instTopologicalSpaceUnits =
       .induced (val : Mˣ → M) ‹_› ⊓ .induced (fun u ↦ ↑u⁻¹ : Mˣ → M) ‹_› := by

c10e724b

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -20,7 +20,7 @@ topological space, opposite monoid, units
 -/
 
 
-variable {M X : Type _}
+variable {M X : Type*}
 
 open Filter Topology
 
@@ -121,7 +121,7 @@ theorem embedding_embedProduct : Embedding (embedProduct M) :=
 Use `Units.embedding_val₀`, `Units.embedding_val`, or `toUnits_homeomorph` instead. -/
 @[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
 topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
-lemma embedding_val_mk' {M : Type _} [Monoid M] [TopologicalSpace M] {f : M → M}
+lemma embedding_val_mk' {M : Type*} [Monoid M] [TopologicalSpace M] {f : M → M}
     (hc : ContinuousOn f {x : M | IsUnit x}) (hf : ∀ u : Mˣ, f u.1 = ↑u⁻¹) :
     Embedding (val : Mˣ → M) := by
   refine ⟨⟨?_⟩, ext⟩
@@ -135,7 +135,7 @@ lemma embedding_val_mk' {M : Type _} [Monoid M] [TopologicalSpace M] {f : M →
 Use `Units.embedding_val₀`, `Units.embedding_val`, or `toUnits_homeomorph` instead. -/
 @[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
 topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
-lemma embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
+lemma embedding_val_mk {M : Type*} [DivisionMonoid M] [TopologicalSpace M]
     (h : ContinuousOn Inv.inv {x : M | IsUnit x}) : Embedding (val : Mˣ → M) :=
   embedding_val_mk' h fun u ↦ (val_inv_eq_inv_val u).symm
 #align units.embedding_coe_mk Units.embedding_val_mk

c10e724b

chore: ensure all instances referred to directly have explicit names (#6423)

Per https://github.com/leanprover/lean4/issues/2343, we are going to need to change the automatic generation of instance names, as they become too long.

This PR ensures that everywhere in Mathlib that refers to an instance by name, that name is given explicitly, rather than being automatically generated.

There are four exceptions, which are now commented, with links to https://github.com/leanprover/lean4/issues/2343.

This was implemented by running Mathlib against a modified Lean that appended _ᾰ to all automatically generated names, and fixing everything.

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

65a35f78

Diff

@@ -29,7 +29,7 @@ namespace MulOpposite
 /-- Put the same topological space structure on the opposite monoid as on the original space. -/
 @[to_additive "Put the same topological space structure on the opposite monoid as on the original
 space."]
-instance [TopologicalSpace M] : TopologicalSpace Mᵐᵒᵖ :=
+instance instTopologicalSpaceMulOpposite [TopologicalSpace M] : TopologicalSpace Mᵐᵒᵖ :=
   TopologicalSpace.induced (unop : Mᵐᵒᵖ → M) ‹_›
 
 variable [TopologicalSpace M]
@@ -94,7 +94,7 @@ variable [TopologicalSpace M] [Monoid M] [TopologicalSpace X]
 /-- The units of a monoid are equipped with a topology, via the embedding into `M × M`. -/
 @[to_additive "The additive units of a monoid are equipped with a topology, via the embedding into
 `M × M`."]
-instance : TopologicalSpace Mˣ :=
+instance instTopologicalSpaceUnits : TopologicalSpace Mˣ :=
   TopologicalSpace.induced (embedProduct M) inferInstance
 
 @[to_additive]

c10e724b

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,14 +2,11 @@
 Copyright (c) 2021 Nicolò Cavalleri. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Nicolò Cavalleri
-
-! This file was ported from Lean 3 source module topology.algebra.constructions
-! leanprover-community/mathlib commit c10e724be91096453ee3db13862b9fb9a992fef2
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.Homeomorph
 
+#align_import topology.algebra.constructions from "leanprover-community/mathlib"@"c10e724be91096453ee3db13862b9fb9a992fef2"
+
 /-!
 # Topological space structure on the opposite monoid and on the units group

c10e724b

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

@@ -13,7 +13,7 @@ import Mathlib.Topology.Homeomorph
 /-!
 # Topological space structure on the opposite monoid and on the units group
 
-In this file we define `TopologicalSpace` structure on `Mᵐᵒᵖ`, `Mᵃᵒᵖ`, `Mˣ`, and `add_units M`.
+In this file we define `TopologicalSpace` structure on `Mᵐᵒᵖ`, `Mᵃᵒᵖ`, `Mˣ`, and `AddUnits M`.
 This file does not import definitions of a topological monoid and/or a continuous multiplicative
 action, so we postpone the proofs of `HasContinuousMul Mᵐᵒᵖ` etc till we have these definitions.

c10e724b

feat: port Analysis.NormedSpace.Units (#3856)

c01ced8c

Diff

@@ -124,14 +124,23 @@ theorem embedding_embedProduct : Embedding (embedProduct M) :=
 Use `Units.embedding_val₀`, `Units.embedding_val`, or `toUnits_homeomorph` instead. -/
 @[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
 topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
-lemma embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
-    (h : ContinuousOn Inv.inv {x : M | IsUnit x}) : Embedding (val : Mˣ → M) := by
+lemma embedding_val_mk' {M : Type _} [Monoid M] [TopologicalSpace M] {f : M → M}
+    (hc : ContinuousOn f {x : M | IsUnit x}) (hf : ∀ u : Mˣ, f u.1 = ↑u⁻¹) :
+    Embedding (val : Mˣ → M) := by
   refine ⟨⟨?_⟩, ext⟩
   rw [topology_eq_inf, inf_eq_left, ← continuous_iff_le_induced,
     @continuous_iff_continuousAt _ _ (.induced _ _)]
   intros u s hs
-  simp only [val_inv_eq_inv_val, nhds_induced, Filter.mem_map] at hs ⊢
-  exact ⟨_, mem_inf_principal.1 (h u u.isUnit hs), fun u' hu' ↦ hu' u'.isUnit⟩
+  simp only [← hf, nhds_induced, Filter.mem_map] at hs ⊢
+  exact ⟨_, mem_inf_principal.1 (hc u u.isUnit hs), fun u' hu' ↦ hu' u'.isUnit⟩
+
+/-- An auxiliary lemma that can be used to prove that coercion `Mˣ → M` is a topological embedding.
+Use `Units.embedding_val₀`, `Units.embedding_val`, or `toUnits_homeomorph` instead. -/
+@[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
+topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
+lemma embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
+    (h : ContinuousOn Inv.inv {x : M | IsUnit x}) : Embedding (val : Mˣ → M) :=
+  embedding_val_mk' h fun u ↦ (val_inv_eq_inv_val u).symm
 #align units.embedding_coe_mk Units.embedding_val_mk
 #align add_units.embedding_coe_mk AddUnits.embedding_val_mk

c10e724b

Fix: Move more attributes to the attr argument of to_additive (#2558)

e8072f65

Diff

@@ -37,13 +37,13 @@ instance [TopologicalSpace M] : TopologicalSpace Mᵐᵒᵖ :=
 
 variable [TopologicalSpace M]
 
-@[to_additive, continuity]
+@[to_additive (attr := continuity)]
 theorem continuous_unop : Continuous (unop : Mᵐᵒᵖ → M) :=
   continuous_induced_dom
 #align mul_opposite.continuous_unop MulOpposite.continuous_unop
 #align add_opposite.continuous_unop AddOpposite.continuous_unop
 
-@[to_additive, continuity]
+@[to_additive (attr := continuity)]
 theorem continuous_op : Continuous (op : M → Mᵐᵒᵖ) :=
   continuous_induced_rng.2 continuous_id
 #align mul_opposite.continuous_op MulOpposite.continuous_op

c10e724b

feat: add units.embedding_val₀ (#2590)

Forward-port #18536

3155a57a

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Nicolò Cavalleri
 
 ! This file was ported from Lean 3 source module topology.algebra.constructions
-! leanprover-community/mathlib commit d90e4e186f1d18e375dcd4e5b5f6364b01cb3e46
+! leanprover-community/mathlib commit c10e724be91096453ee3db13862b9fb9a992fef2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -112,6 +112,29 @@ theorem embedding_embedProduct : Embedding (embedProduct M) :=
 #align units.embedding_embed_product Units.embedding_embedProduct
 #align add_units.embedding_embed_product AddUnits.embedding_embedProduct
 
+@[to_additive] lemma topology_eq_inf :
+    instTopologicalSpaceUnits =
+      .induced (val : Mˣ → M) ‹_› ⊓ .induced (fun u ↦ ↑u⁻¹ : Mˣ → M) ‹_› := by
+  simp only [inducing_embedProduct.1, instTopologicalSpaceProd, induced_inf,
+    instTopologicalSpaceMulOpposite, induced_compose]; rfl
+#align units.topology_eq_inf Units.topology_eq_inf
+#align add_units.topology_eq_inf AddUnits.topology_eq_inf
+
+/-- An auxiliary lemma that can be used to prove that coercion `Mˣ → M` is a topological embedding.
+Use `Units.embedding_val₀`, `Units.embedding_val`, or `toUnits_homeomorph` instead. -/
+@[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
+topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
+lemma embedding_val_mk {M : Type _} [DivisionMonoid M] [TopologicalSpace M]
+    (h : ContinuousOn Inv.inv {x : M | IsUnit x}) : Embedding (val : Mˣ → M) := by
+  refine ⟨⟨?_⟩, ext⟩
+  rw [topology_eq_inf, inf_eq_left, ← continuous_iff_le_induced,
+    @continuous_iff_continuousAt _ _ (.induced _ _)]
+  intros u s hs
+  simp only [val_inv_eq_inv_val, nhds_induced, Filter.mem_map] at hs ⊢
+  exact ⟨_, mem_inf_principal.1 (h u u.isUnit hs), fun u' hu' ↦ hu' u'.isUnit⟩
+#align units.embedding_coe_mk Units.embedding_val_mk
+#align add_units.embedding_coe_mk AddUnits.embedding_val_mk
+
 @[to_additive]
 theorem continuous_embedProduct : Continuous (embedProduct M) :=
   continuous_induced_dom

d90e4e18

feat: port continuity tactic (#2145)

We implement the continuity tactic using aesop, this makes it more robust and reduces the code to trivial macros.

4f818d25

Diff

@@ -37,13 +37,13 @@ instance [TopologicalSpace M] : TopologicalSpace Mᵐᵒᵖ :=
 
 variable [TopologicalSpace M]
 
-@[to_additive] -- porting note: todo: restore `continuity`
+@[to_additive, continuity]
 theorem continuous_unop : Continuous (unop : Mᵐᵒᵖ → M) :=
   continuous_induced_dom
 #align mul_opposite.continuous_unop MulOpposite.continuous_unop
 #align add_opposite.continuous_unop AddOpposite.continuous_unop
 
-@[to_additive] -- porting note: todo: restore `continuity`
+@[to_additive, continuity]
 theorem continuous_op : Continuous (op : M → Mᵐᵒᵖ) :=
   continuous_induced_rng.2 continuous_id
 #align mul_opposite.continuous_op MulOpposite.continuous_op

d90e4e18

feat: require @[simps!] if simps runs in expensive mode (#1885)

This does not change the behavior of simps, just raises a linter error if you run simps in a more expensive mode without writing !.
Fixed some incorrect occurrences of to_additive, simps. Will do that systematically in future PR.
Fix port of OmegaCompletePartialOrder.ContinuousHom.ofMono a bit

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

52c04a34

Diff

@@ -50,7 +50,7 @@ theorem continuous_op : Continuous (op : M → Mᵐᵒᵖ) :=
 #align add_opposite.continuous_op AddOpposite.continuous_op
 
 /-- `MulOpposite.op` as a homeomorphism. -/
-@[to_additive (attr := simps) "`AddOpposite.op` as a homeomorphism."]
+@[to_additive (attr := simps!) "`AddOpposite.op` as a homeomorphism."]
 def opHomeomorph : M ≃ₜ Mᵐᵒᵖ where
   toEquiv := opEquiv
   continuous_toFun := continuous_op

d90e4e18

fix: use to_additive (attr := _) here and there (#2073)

adaaf293

Diff

@@ -50,7 +50,7 @@ theorem continuous_op : Continuous (op : M → Mᵐᵒᵖ) :=
 #align add_opposite.continuous_op AddOpposite.continuous_op
 
 /-- `MulOpposite.op` as a homeomorphism. -/
-@[to_additive "`AddOpposite.op` as a homeomorphism.", simps]
+@[to_additive (attr := simps) "`AddOpposite.op` as a homeomorphism."]
 def opHomeomorph : M ≃ₜ Mᵐᵒᵖ where
   toEquiv := opEquiv
   continuous_toFun := continuous_op

d90e4e18

chore: tidy various files (#2056)

a347ef63

Diff

@@ -13,9 +13,9 @@ import Mathlib.Topology.Homeomorph
 /-!
 # Topological space structure on the opposite monoid and on the units group
 
-In this file we define `topological_space` structure on `Mᵐᵒᵖ`, `Mᵃᵒᵖ`, `Mˣ`, and `add_units M`.
+In this file we define `TopologicalSpace` structure on `Mᵐᵒᵖ`, `Mᵃᵒᵖ`, `Mˣ`, and `add_units M`.
 This file does not import definitions of a topological monoid and/or a continuous multiplicative
-action, so we postpone the proofs of `has_continuous_mul Mᵐᵒᵖ` etc till we have these definitions.
+action, so we postpone the proofs of `HasContinuousMul Mᵐᵒᵖ` etc till we have these definitions.
 
 ## Tags
 
@@ -49,8 +49,8 @@ theorem continuous_op : Continuous (op : M → Mᵐᵒᵖ) :=
 #align mul_opposite.continuous_op MulOpposite.continuous_op
 #align add_opposite.continuous_op AddOpposite.continuous_op
 
-/-- `mul_opposite.op` as a homeomorphism. -/
-@[to_additive "`add_opposite.op` as a homeomorphism.", simps]
+/-- `MulOpposite.op` as a homeomorphism. -/
+@[to_additive "`AddOpposite.op` as a homeomorphism.", simps]
 def opHomeomorph : M ≃ₜ Mᵐᵒᵖ where
   toEquiv := opEquiv
   continuous_toFun := continuous_op

d90e4e18

feat: port Topology.Algebra.Constructions (#2011)

e823ef89

`topology.algebra.constructions` ⟷ `Mathlib.Topology.Algebra.Constructions`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 306

topology.algebra.constructions ⟷ Mathlib.Topology.Algebra.Constructions

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 306

`topology.algebra.constructions` ⟷ `Mathlib.Topology.Algebra.Constructions`