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

70fd9563

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

f4758115

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2022 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 -/
-import Mathbin.Topology.Algebra.UniformGroup
-import Mathbin.Topology.UniformSpace.Completion
+import Topology.Algebra.UniformGroup
+import Topology.UniformSpace.Completion
 
 #align_import topology.algebra.uniform_mul_action from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"

f4758115

bump to nightly-2023-08-17-09

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

60285dcc

Diff

@@ -224,7 +224,7 @@ instance [Monoid M] [MulAction M X] [UniformContinuousConstSMul M X] : MulAction
     where
   smul := (· • ·)
   one_smul := ext' (continuous_const_smul _) continuous_id fun a => by rw [← coe_smul, one_smul]
-  mul_smul x y :=
+  hMul_smul x y :=
     ext' (continuous_const_smul _) ((continuous_const_smul _).const_smul _) fun a => by
       simp only [← coe_smul, mul_smul]

f4758115

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module topology.algebra.uniform_mul_action
-! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.Algebra.UniformGroup
 import Mathbin.Topology.UniformSpace.Completion
 
+#align_import topology.algebra.uniform_mul_action from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
+
 /-!
 # Multiplicative action on the completion of a uniform space

f4758115

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -71,6 +71,7 @@ instance AddGroup.uniformContinuousConstSMul_int [AddGroup X] [UniformAddGroup X
 #align add_group.has_uniform_continuous_const_smul_int AddGroup.uniformContinuousConstSMul_int
 -/
 
+#print uniformContinuousConstSMul_of_continuousConstSMul /-
 /-- A `distrib_mul_action` that is continuous on a uniform group is uniformly continuous.
 This can't be an instance due to it forming a loop with
 `has_uniform_continuous_const_smul.to_has_continuous_const_smul` -/
@@ -81,18 +82,23 @@ theorem uniformContinuousConstSMul_of_continuousConstSMul [Monoid R] [AddCommGro
     uniformContinuous_of_continuousAt_zero (DistribMulAction.toAddMonoidHom M r)
       (Continuous.continuousAt (continuous_const_smul r))⟩
 #align has_uniform_continuous_const_smul_of_continuous_const_smul uniformContinuousConstSMul_of_continuousConstSMul
+-/
 
+#print Ring.uniformContinuousConstSMul /-
 /-- The action of `semiring.to_module` is uniformly continuous. -/
 instance Ring.uniformContinuousConstSMul [Ring R] [UniformSpace R] [UniformAddGroup R]
     [ContinuousMul R] : UniformContinuousConstSMul R R :=
   uniformContinuousConstSMul_of_continuousConstSMul _ _
 #align ring.has_uniform_continuous_const_smul Ring.uniformContinuousConstSMul
+-/
 
+#print Ring.uniformContinuousConstSMul_op /-
 /-- The action of `semiring.to_opposite_module` is uniformly continuous. -/
 instance Ring.uniformContinuousConstSMul_op [Ring R] [UniformSpace R] [UniformAddGroup R]
     [ContinuousMul R] : UniformContinuousConstSMul Rᵐᵒᵖ R :=
   uniformContinuousConstSMul_of_continuousConstSMul _ _
 #align ring.has_uniform_continuous_const_op_smul Ring.uniformContinuousConstSMul_op
+-/
 
 section SMul
 
@@ -146,12 +152,14 @@ instance MulOpposite.uniformContinuousConstSMul [UniformContinuousConstSMul M X]
 
 end SMul
 
+#print UniformGroup.to_uniformContinuousConstSMul /-
 @[to_additive]
 instance UniformGroup.to_uniformContinuousConstSMul {G : Type u} [Group G] [UniformSpace G]
     [UniformGroup G] : UniformContinuousConstSMul G G :=
   ⟨fun c => uniformContinuous_const.mul uniformContinuous_id⟩
 #align uniform_group.to_has_uniform_continuous_const_smul UniformGroup.to_uniformContinuousConstSMul
 #align uniform_add_group.to_has_uniform_continuous_const_vadd UniformAddGroup.to_uniformContinuousConstVAdd
+-/
 
 namespace UniformSpace
 
@@ -204,11 +212,13 @@ instance [SMul Mᵐᵒᵖ X] [IsCentralScalar M X] : IsCentralScalar M (Completi
 
 variable {M X} [UniformContinuousConstSMul M X]
 
+#print UniformSpace.Completion.coe_smul /-
 @[simp, norm_cast, to_additive]
 theorem coe_smul (c : M) (x : X) : ↑(c • x) = (c • x : Completion X) :=
   (map_coe (uniformContinuous_const_smul c) x).symm
 #align uniform_space.completion.coe_smul UniformSpace.Completion.coe_smul
 #align uniform_space.completion.coe_vadd UniformSpace.Completion.coe_vadd
+-/
 
 end SMul

f4758115

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -71,12 +71,6 @@ instance AddGroup.uniformContinuousConstSMul_int [AddGroup X] [UniformAddGroup X
 #align add_group.has_uniform_continuous_const_smul_int AddGroup.uniformContinuousConstSMul_int
 -/
 
-/- warning: has_uniform_continuous_const_smul_of_continuous_const_smul -> uniformContinuousConstSMul_of_continuousConstSMul is a dubious translation:
-lean 3 declaration is
-  forall (R : Type.{u1}) (M : Type.{u2}) [_inst_3 : Monoid.{u1} R] [_inst_4 : AddCommGroup.{u2} M] [_inst_5 : DistribMulAction.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))] [_inst_6 : UniformSpace.{u2} M] [_inst_7 : UniformAddGroup.{u2} M _inst_6 (AddCommGroup.toAddGroup.{u2} M _inst_4)] [_inst_8 : ContinuousConstSMul.{u1, u2} R M (UniformSpace.toTopologicalSpace.{u2} M _inst_6) (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))))) (DistribSMul.toSmulZeroClass.{u1, u2} R M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))) (DistribMulAction.toDistribSMul.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))) _inst_5)))], UniformContinuousConstSMul.{u1, u2} R M _inst_6 (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))))) (DistribSMul.toSmulZeroClass.{u1, u2} R M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))) (DistribMulAction.toDistribSMul.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))) _inst_5)))
-but is expected to have type
-  forall (R : Type.{u1}) (M : Type.{u2}) [_inst_3 : Monoid.{u1} R] [_inst_4 : AddCommGroup.{u2} M] [_inst_5 : DistribMulAction.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))] [_inst_6 : UniformSpace.{u2} M] [_inst_7 : UniformAddGroup.{u2} M _inst_6 (AddCommGroup.toAddGroup.{u2} M _inst_4)] [_inst_8 : ContinuousConstSMul.{u1, u2} R M (UniformSpace.toTopologicalSpace.{u2} M _inst_6) (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_4))))) (DistribSMul.toSMulZeroClass.{u1, u2} R M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))) (DistribMulAction.toDistribSMul.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))) _inst_5)))], UniformContinuousConstSMul.{u1, u2} R M _inst_6 (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_4))))) (DistribSMul.toSMulZeroClass.{u1, u2} R M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))) (DistribMulAction.toDistribSMul.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))) _inst_5)))
-Case conversion may be inaccurate. Consider using '#align has_uniform_continuous_const_smul_of_continuous_const_smul uniformContinuousConstSMul_of_continuousConstSMulₓ'. -/
 /-- A `distrib_mul_action` that is continuous on a uniform group is uniformly continuous.
 This can't be an instance due to it forming a loop with
 `has_uniform_continuous_const_smul.to_has_continuous_const_smul` -/
@@ -88,24 +82,12 @@ theorem uniformContinuousConstSMul_of_continuousConstSMul [Monoid R] [AddCommGro
       (Continuous.continuousAt (continuous_const_smul r))⟩
 #align has_uniform_continuous_const_smul_of_continuous_const_smul uniformContinuousConstSMul_of_continuousConstSMul
 
-/- warning: ring.has_uniform_continuous_const_smul -> Ring.uniformContinuousConstSMul is a dubious translation:
-lean 3 declaration is
-  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_3)))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3))], UniformContinuousConstSMul.{u1, u1} R R _inst_4 (Mul.toSMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3)))
-but is expected to have type
-  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_3))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))], UniformContinuousConstSMul.{u1, u1} R R _inst_4 (SMulZeroClass.toSMul.{u1, u1} R R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_3))) (SMulWithZero.toSMulZeroClass.{u1, u1} R R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_3))) (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_3))) (MulZeroClass.toSMulWithZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))))))
-Case conversion may be inaccurate. Consider using '#align ring.has_uniform_continuous_const_smul Ring.uniformContinuousConstSMulₓ'. -/
 /-- The action of `semiring.to_module` is uniformly continuous. -/
 instance Ring.uniformContinuousConstSMul [Ring R] [UniformSpace R] [UniformAddGroup R]
     [ContinuousMul R] : UniformContinuousConstSMul R R :=
   uniformContinuousConstSMul_of_continuousConstSMul _ _
 #align ring.has_uniform_continuous_const_smul Ring.uniformContinuousConstSMul
 
-/- warning: ring.has_uniform_continuous_const_op_smul -> Ring.uniformContinuousConstSMul_op is a dubious translation:
-lean 3 declaration is
-  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_3)))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3))], UniformContinuousConstSMul.{u1, u1} (MulOpposite.{u1} R) R _inst_4 (Mul.toHasOppositeSMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3)))
-but is expected to have type
-  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_3))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))], UniformContinuousConstSMul.{u1, u1} (MulOpposite.{u1} R) R _inst_4 (Mul.toHasOppositeSMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3))))
-Case conversion may be inaccurate. Consider using '#align ring.has_uniform_continuous_const_op_smul Ring.uniformContinuousConstSMul_opₓ'. -/
 /-- The action of `semiring.to_opposite_module` is uniformly continuous. -/
 instance Ring.uniformContinuousConstSMul_op [Ring R] [UniformSpace R] [UniformAddGroup R]
     [ContinuousMul R] : UniformContinuousConstSMul Rᵐᵒᵖ R :=
@@ -164,12 +146,6 @@ instance MulOpposite.uniformContinuousConstSMul [UniformContinuousConstSMul M X]
 
 end SMul
 
-/- warning: uniform_group.to_has_uniform_continuous_const_smul -> UniformGroup.to_uniformContinuousConstSMul is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] [_inst_4 : UniformSpace.{u1} G] [_inst_5 : UniformGroup.{u1} G _inst_4 _inst_3], UniformContinuousConstSMul.{u1, u1} G G _inst_4 (Mul.toSMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] [_inst_4 : UniformSpace.{u1} G] [_inst_5 : UniformGroup.{u1} G _inst_4 _inst_3], UniformContinuousConstSMul.{u1, u1} G G _inst_4 (MulAction.toSMul.{u1, u1} G G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)) (Monoid.toMulAction.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))
-Case conversion may be inaccurate. Consider using '#align uniform_group.to_has_uniform_continuous_const_smul UniformGroup.to_uniformContinuousConstSMulₓ'. -/
 @[to_additive]
 instance UniformGroup.to_uniformContinuousConstSMul {G : Type u} [Group G] [UniformSpace G]
     [UniformGroup G] : UniformContinuousConstSMul G G :=
@@ -228,12 +204,6 @@ instance [SMul Mᵐᵒᵖ X] [IsCentralScalar M X] : IsCentralScalar M (Completi
 
 variable {M X} [UniformContinuousConstSMul M X]
 
-/- warning: uniform_space.completion.coe_smul -> UniformSpace.Completion.coe_smul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {X : Type.{u2}} [_inst_1 : UniformSpace.{u2} X] [_inst_3 : SMul.{u1, u2} M X] [_inst_4 : UniformContinuousConstSMul.{u1, u2} M X _inst_1 _inst_3] (c : M) (x : X), Eq.{succ u2} (UniformSpace.Completion.{u2} X _inst_1) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) X (UniformSpace.Completion.{u2} X _inst_1) (HasLiftT.mk.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (CoeTCₓ.coe.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.hasCoeT.{u2} X _inst_1))) (SMul.smul.{u1, u2} M X _inst_3 c x)) (SMul.smul.{u1, u2} M (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.hasSmul.{u1, u2} M X _inst_1 _inst_3) c ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) X (UniformSpace.Completion.{u2} X _inst_1) (HasLiftT.mk.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (CoeTCₓ.coe.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.hasCoeT.{u2} X _inst_1))) x))
-but is expected to have type
-  forall {M : Type.{u1}} {X : Type.{u2}} [_inst_1 : UniformSpace.{u2} X] [_inst_3 : SMul.{u1, u2} M X] [_inst_4 : UniformContinuousConstSMul.{u1, u2} M X _inst_1 _inst_3] (c : M) (x : X), Eq.{succ u2} (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.coe'.{u2} X _inst_1 (HSMul.hSMul.{u1, u2, u2} M X X (instHSMul.{u1, u2} M X _inst_3) c x)) (HSMul.hSMul.{u1, u2, u2} M (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.{u2} X _inst_1) (instHSMul.{u1, u2} M (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.instSMulCompletion.{u1, u2} M X _inst_1 _inst_3)) c (UniformSpace.Completion.coe'.{u2} X _inst_1 x))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.coe_smul UniformSpace.Completion.coe_smulₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_smul (c : M) (x : X) : ↑(c • x) = (c • x : Completion X) :=
   (map_coe (uniformContinuous_const_smul c) x).symm

f4758115

bump to nightly-2023-03-27-10

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

1caedb6b

Diff

@@ -57,18 +57,18 @@ export UniformContinuousConstVAdd (uniformContinuous_const_vadd)
 
 export UniformContinuousConstSMul (uniformContinuous_const_smul)
 
-#print AddMonoid.hasUniformContinuousConstSMul_nat /-
-instance AddMonoid.hasUniformContinuousConstSMul_nat [AddGroup X] [UniformAddGroup X] :
+#print AddMonoid.uniformContinuousConstSMul_nat /-
+instance AddMonoid.uniformContinuousConstSMul_nat [AddGroup X] [UniformAddGroup X] :
     UniformContinuousConstSMul ℕ X :=
   ⟨uniformContinuous_const_nsmul⟩
-#align add_monoid.has_uniform_continuous_const_smul_nat AddMonoid.hasUniformContinuousConstSMul_nat
+#align add_monoid.has_uniform_continuous_const_smul_nat AddMonoid.uniformContinuousConstSMul_nat
 -/
 
-#print AddGroup.hasUniformContinuousConstSMul_int /-
-instance AddGroup.hasUniformContinuousConstSMul_int [AddGroup X] [UniformAddGroup X] :
+#print AddGroup.uniformContinuousConstSMul_int /-
+instance AddGroup.uniformContinuousConstSMul_int [AddGroup X] [UniformAddGroup X] :
     UniformContinuousConstSMul ℤ X :=
   ⟨uniformContinuous_const_zsmul⟩
-#align add_group.has_uniform_continuous_const_smul_int AddGroup.hasUniformContinuousConstSMul_int
+#align add_group.has_uniform_continuous_const_smul_int AddGroup.uniformContinuousConstSMul_int
 -/
 
 /- warning: has_uniform_continuous_const_smul_of_continuous_const_smul -> uniformContinuousConstSMul_of_continuousConstSMul is a dubious translation:
@@ -100,17 +100,17 @@ instance Ring.uniformContinuousConstSMul [Ring R] [UniformSpace R] [UniformAddGr
   uniformContinuousConstSMul_of_continuousConstSMul _ _
 #align ring.has_uniform_continuous_const_smul Ring.uniformContinuousConstSMul
 
-/- warning: ring.has_uniform_continuous_const_op_smul -> Ring.has_uniform_continuous_const_op_smul is a dubious translation:
+/- warning: ring.has_uniform_continuous_const_op_smul -> Ring.uniformContinuousConstSMul_op is a dubious translation:
 lean 3 declaration is
   forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_3)))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3))], UniformContinuousConstSMul.{u1, u1} (MulOpposite.{u1} R) R _inst_4 (Mul.toHasOppositeSMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3)))
 but is expected to have type
   forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_3))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))], UniformContinuousConstSMul.{u1, u1} (MulOpposite.{u1} R) R _inst_4 (Mul.toHasOppositeSMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3))))
-Case conversion may be inaccurate. Consider using '#align ring.has_uniform_continuous_const_op_smul Ring.has_uniform_continuous_const_op_smulₓ'. -/
+Case conversion may be inaccurate. Consider using '#align ring.has_uniform_continuous_const_op_smul Ring.uniformContinuousConstSMul_opₓ'. -/
 /-- The action of `semiring.to_opposite_module` is uniformly continuous. -/
-instance Ring.has_uniform_continuous_const_op_smul [Ring R] [UniformSpace R] [UniformAddGroup R]
+instance Ring.uniformContinuousConstSMul_op [Ring R] [UniformSpace R] [UniformAddGroup R]
     [ContinuousMul R] : UniformContinuousConstSMul Rᵐᵒᵖ R :=
   uniformContinuousConstSMul_of_continuousConstSMul _ _
-#align ring.has_uniform_continuous_const_op_smul Ring.has_uniform_continuous_const_op_smul
+#align ring.has_uniform_continuous_const_op_smul Ring.uniformContinuousConstSMul_op
 
 section SMul

f4758115

bump to nightly-2023-03-27-02

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

0e4ebd8c

Diff

@@ -90,7 +90,7 @@ theorem uniformContinuousConstSMul_of_continuousConstSMul [Monoid R] [AddCommGro
 
 /- warning: ring.has_uniform_continuous_const_smul -> Ring.uniformContinuousConstSMul is a dubious translation:
 lean 3 declaration is
-  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3))], UniformContinuousConstSMul.{u1, u1} R R _inst_4 (Mul.toSMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3)))
+  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_3)))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3))], UniformContinuousConstSMul.{u1, u1} R R _inst_4 (Mul.toSMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3)))
 but is expected to have type
   forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_3))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))], UniformContinuousConstSMul.{u1, u1} R R _inst_4 (SMulZeroClass.toSMul.{u1, u1} R R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_3))) (SMulWithZero.toSMulZeroClass.{u1, u1} R R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_3))) (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_3))) (MulZeroClass.toSMulWithZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))))))
 Case conversion may be inaccurate. Consider using '#align ring.has_uniform_continuous_const_smul Ring.uniformContinuousConstSMulₓ'. -/
@@ -102,7 +102,7 @@ instance Ring.uniformContinuousConstSMul [Ring R] [UniformSpace R] [UniformAddGr
 
 /- warning: ring.has_uniform_continuous_const_op_smul -> Ring.has_uniform_continuous_const_op_smul is a dubious translation:
 lean 3 declaration is
-  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3))], UniformContinuousConstSMul.{u1, u1} (MulOpposite.{u1} R) R _inst_4 (Mul.toHasOppositeSMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3)))
+  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_3)))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3))], UniformContinuousConstSMul.{u1, u1} (MulOpposite.{u1} R) R _inst_4 (Mul.toHasOppositeSMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3)))
 but is expected to have type
   forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_3))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))], UniformContinuousConstSMul.{u1, u1} (MulOpposite.{u1} R) R _inst_4 (Mul.toHasOppositeSMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3))))
 Case conversion may be inaccurate. Consider using '#align ring.has_uniform_continuous_const_op_smul Ring.has_uniform_continuous_const_op_smulₓ'. -/

f4758115

bump to nightly-2023-03-09-03

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

061741a1

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 
 ! This file was ported from Lean 3 source module topology.algebra.uniform_mul_action
-! leanprover-community/mathlib commit 70fd9563a21e7b963887c9360bd29b2393e6225a
+! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Topology.UniformSpace.Completion
 /-!
 # Multiplicative action on the completion of a uniform space
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we define typeclasses `has_uniform_continuous_const_vadd` and
 `has_uniform_continuous_const_smul` and prove that a multiplicative action on `X` with uniformly
 continuous `(•) c` can be extended to a multiplicative action on `uniform_space.completion X`.

70fd9563

bump to nightly-2023-03-07-03

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

e067364a

Diff

@@ -229,7 +229,7 @@ variable {M X} [UniformContinuousConstSMul M X]
 lean 3 declaration is
   forall {M : Type.{u1}} {X : Type.{u2}} [_inst_1 : UniformSpace.{u2} X] [_inst_3 : SMul.{u1, u2} M X] [_inst_4 : UniformContinuousConstSMul.{u1, u2} M X _inst_1 _inst_3] (c : M) (x : X), Eq.{succ u2} (UniformSpace.Completion.{u2} X _inst_1) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) X (UniformSpace.Completion.{u2} X _inst_1) (HasLiftT.mk.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (CoeTCₓ.coe.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.hasCoeT.{u2} X _inst_1))) (SMul.smul.{u1, u2} M X _inst_3 c x)) (SMul.smul.{u1, u2} M (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.hasSmul.{u1, u2} M X _inst_1 _inst_3) c ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) X (UniformSpace.Completion.{u2} X _inst_1) (HasLiftT.mk.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (CoeTCₓ.coe.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.hasCoeT.{u2} X _inst_1))) x))
 but is expected to have type
-  forall {M : Type.{u1}} {X : Type.{u2}} [_inst_1 : UniformSpace.{u2} X] [_inst_3 : SMul.{u1, u2} M X] [_inst_4 : UniformContinuousConstSMul.{u1, u2} M X _inst_1 _inst_3] (c : M) (x : X), Eq.{succ u2} (UniformSpace.Completion.{u2} X _inst_1) (Function.comp.{succ u2, succ u2, succ u2} X (CauchyFilter.{u2} X _inst_1) (UniformSpace.Completion.{u2} X _inst_1) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} X _inst_1) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} X _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} X _inst_1))) (CauchyFilter.pureCauchy.{u2} X _inst_1) (HSMul.hSMul.{u1, u2, u2} M X X (instHSMul.{u1, u2} M X _inst_3) c x)) (HSMul.hSMul.{u1, u2, u2} M (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.{u2} X _inst_1) (instHSMul.{u1, u2} M (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.instSMulCompletion.{u1, u2} M X _inst_1 _inst_3)) c (Function.comp.{succ u2, succ u2, succ u2} X (CauchyFilter.{u2} X _inst_1) (UniformSpace.Completion.{u2} X _inst_1) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} X _inst_1) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} X _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} X _inst_1))) (CauchyFilter.pureCauchy.{u2} X _inst_1) x))
+  forall {M : Type.{u1}} {X : Type.{u2}} [_inst_1 : UniformSpace.{u2} X] [_inst_3 : SMul.{u1, u2} M X] [_inst_4 : UniformContinuousConstSMul.{u1, u2} M X _inst_1 _inst_3] (c : M) (x : X), Eq.{succ u2} (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.coe'.{u2} X _inst_1 (HSMul.hSMul.{u1, u2, u2} M X X (instHSMul.{u1, u2} M X _inst_3) c x)) (HSMul.hSMul.{u1, u2, u2} M (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.{u2} X _inst_1) (instHSMul.{u1, u2} M (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.instSMulCompletion.{u1, u2} M X _inst_1 _inst_3)) c (UniformSpace.Completion.coe'.{u2} X _inst_1 x))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.coe_smul UniformSpace.Completion.coe_smulₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_smul (c : M) (x : X) : ↑(c • x) = (c • x : Completion X) :=

70fd9563

bump to nightly-2023-03-02-12

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

cda909c7

Diff

@@ -34,105 +34,145 @@ noncomputable section
 variable (R : Type u) (M : Type v) (N : Type w) (X : Type x) (Y : Type y) [UniformSpace X]
   [UniformSpace Y]
 
+#print UniformContinuousConstVAdd /-
 /-- An additive action such that for all `c`, the map `λ x, c +ᵥ x` is uniformly continuous. -/
-class HasUniformContinuousConstVadd [VAdd M X] : Prop where
+class UniformContinuousConstVAdd [VAdd M X] : Prop where
   uniformContinuous_const_vadd : ∀ c : M, UniformContinuous ((· +ᵥ ·) c : X → X)
-#align has_uniform_continuous_const_vadd HasUniformContinuousConstVadd
+#align has_uniform_continuous_const_vadd UniformContinuousConstVAdd
+-/
 
+#print UniformContinuousConstSMul /-
 /-- A multiplicative action such that for all `c`, the map `λ x, c • x` is uniformly continuous. -/
 @[to_additive]
-class HasUniformContinuousConstSmul [SMul M X] : Prop where
+class UniformContinuousConstSMul [SMul M X] : Prop where
   uniformContinuous_const_smul : ∀ c : M, UniformContinuous ((· • ·) c : X → X)
-#align has_uniform_continuous_const_smul HasUniformContinuousConstSmul
-#align has_uniform_continuous_const_vadd HasUniformContinuousConstVadd
+#align has_uniform_continuous_const_smul UniformContinuousConstSMul
+#align has_uniform_continuous_const_vadd UniformContinuousConstVAdd
+-/
 
-export HasUniformContinuousConstVadd (uniformContinuous_const_vadd)
+export UniformContinuousConstVAdd (uniformContinuous_const_vadd)
 
-export HasUniformContinuousConstSmul (uniformContinuous_const_smul)
+export UniformContinuousConstSMul (uniformContinuous_const_smul)
 
-instance AddMonoid.hasUniformContinuousConstSmul_nat [AddGroup X] [UniformAddGroup X] :
-    HasUniformContinuousConstSmul ℕ X :=
+#print AddMonoid.hasUniformContinuousConstSMul_nat /-
+instance AddMonoid.hasUniformContinuousConstSMul_nat [AddGroup X] [UniformAddGroup X] :
+    UniformContinuousConstSMul ℕ X :=
   ⟨uniformContinuous_const_nsmul⟩
-#align add_monoid.has_uniform_continuous_const_smul_nat AddMonoid.hasUniformContinuousConstSmul_nat
+#align add_monoid.has_uniform_continuous_const_smul_nat AddMonoid.hasUniformContinuousConstSMul_nat
+-/
 
-instance AddGroup.hasUniformContinuousConstSmul_int [AddGroup X] [UniformAddGroup X] :
-    HasUniformContinuousConstSmul ℤ X :=
+#print AddGroup.hasUniformContinuousConstSMul_int /-
+instance AddGroup.hasUniformContinuousConstSMul_int [AddGroup X] [UniformAddGroup X] :
+    UniformContinuousConstSMul ℤ X :=
   ⟨uniformContinuous_const_zsmul⟩
-#align add_group.has_uniform_continuous_const_smul_int AddGroup.hasUniformContinuousConstSmul_int
+#align add_group.has_uniform_continuous_const_smul_int AddGroup.hasUniformContinuousConstSMul_int
+-/
 
+/- warning: has_uniform_continuous_const_smul_of_continuous_const_smul -> uniformContinuousConstSMul_of_continuousConstSMul is a dubious translation:
+lean 3 declaration is
+  forall (R : Type.{u1}) (M : Type.{u2}) [_inst_3 : Monoid.{u1} R] [_inst_4 : AddCommGroup.{u2} M] [_inst_5 : DistribMulAction.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))] [_inst_6 : UniformSpace.{u2} M] [_inst_7 : UniformAddGroup.{u2} M _inst_6 (AddCommGroup.toAddGroup.{u2} M _inst_4)] [_inst_8 : ContinuousConstSMul.{u1, u2} R M (UniformSpace.toTopologicalSpace.{u2} M _inst_6) (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))))) (DistribSMul.toSmulZeroClass.{u1, u2} R M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))) (DistribMulAction.toDistribSMul.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))) _inst_5)))], UniformContinuousConstSMul.{u1, u2} R M _inst_6 (SMulZeroClass.toHasSmul.{u1, u2} R M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))))) (DistribSMul.toSmulZeroClass.{u1, u2} R M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))) (DistribMulAction.toDistribSMul.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))) _inst_5)))
+but is expected to have type
+  forall (R : Type.{u1}) (M : Type.{u2}) [_inst_3 : Monoid.{u1} R] [_inst_4 : AddCommGroup.{u2} M] [_inst_5 : DistribMulAction.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))] [_inst_6 : UniformSpace.{u2} M] [_inst_7 : UniformAddGroup.{u2} M _inst_6 (AddCommGroup.toAddGroup.{u2} M _inst_4)] [_inst_8 : ContinuousConstSMul.{u1, u2} R M (UniformSpace.toTopologicalSpace.{u2} M _inst_6) (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_4))))) (DistribSMul.toSMulZeroClass.{u1, u2} R M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))) (DistribMulAction.toDistribSMul.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))) _inst_5)))], UniformContinuousConstSMul.{u1, u2} R M _inst_6 (SMulZeroClass.toSMul.{u1, u2} R M (NegZeroClass.toZero.{u2} M (SubNegZeroMonoid.toNegZeroClass.{u2} M (SubtractionMonoid.toSubNegZeroMonoid.{u2} M (SubtractionCommMonoid.toSubtractionMonoid.{u2} M (AddCommGroup.toDivisionAddCommMonoid.{u2} M _inst_4))))) (DistribSMul.toSMulZeroClass.{u1, u2} R M (AddMonoid.toAddZeroClass.{u2} M (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4)))) (DistribMulAction.toDistribSMul.{u1, u2} R M _inst_3 (SubNegMonoid.toAddMonoid.{u2} M (AddGroup.toSubNegMonoid.{u2} M (AddCommGroup.toAddGroup.{u2} M _inst_4))) _inst_5)))
+Case conversion may be inaccurate. Consider using '#align has_uniform_continuous_const_smul_of_continuous_const_smul uniformContinuousConstSMul_of_continuousConstSMulₓ'. -/
 /-- A `distrib_mul_action` that is continuous on a uniform group is uniformly continuous.
 This can't be an instance due to it forming a loop with
 `has_uniform_continuous_const_smul.to_has_continuous_const_smul` -/
-theorem hasUniformContinuousConstSmul_of_continuous_const_smul [Monoid R] [AddCommGroup M]
+theorem uniformContinuousConstSMul_of_continuousConstSMul [Monoid R] [AddCommGroup M]
     [DistribMulAction R M] [UniformSpace M] [UniformAddGroup M] [ContinuousConstSMul R M] :
-    HasUniformContinuousConstSmul R M :=
+    UniformContinuousConstSMul R M :=
   ⟨fun r =>
     uniformContinuous_of_continuousAt_zero (DistribMulAction.toAddMonoidHom M r)
       (Continuous.continuousAt (continuous_const_smul r))⟩
-#align has_uniform_continuous_const_smul_of_continuous_const_smul hasUniformContinuousConstSmul_of_continuous_const_smul
-
+#align has_uniform_continuous_const_smul_of_continuous_const_smul uniformContinuousConstSMul_of_continuousConstSMul
+
+/- warning: ring.has_uniform_continuous_const_smul -> Ring.uniformContinuousConstSMul is a dubious translation:
+lean 3 declaration is
+  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3))], UniformContinuousConstSMul.{u1, u1} R R _inst_4 (Mul.toSMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3)))
+but is expected to have type
+  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_3))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))], UniformContinuousConstSMul.{u1, u1} R R _inst_4 (SMulZeroClass.toSMul.{u1, u1} R R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_3))) (SMulWithZero.toSMulZeroClass.{u1, u1} R R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_3))) (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_3))) (MulZeroClass.toSMulWithZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))))))
+Case conversion may be inaccurate. Consider using '#align ring.has_uniform_continuous_const_smul Ring.uniformContinuousConstSMulₓ'. -/
 /-- The action of `semiring.to_module` is uniformly continuous. -/
-instance Ring.hasUniformContinuousConstSmul [Ring R] [UniformSpace R] [UniformAddGroup R]
-    [ContinuousMul R] : HasUniformContinuousConstSmul R R :=
-  hasUniformContinuousConstSmul_of_continuous_const_smul _ _
-#align ring.has_uniform_continuous_const_smul Ring.hasUniformContinuousConstSmul
-
+instance Ring.uniformContinuousConstSMul [Ring R] [UniformSpace R] [UniformAddGroup R]
+    [ContinuousMul R] : UniformContinuousConstSMul R R :=
+  uniformContinuousConstSMul_of_continuousConstSMul _ _
+#align ring.has_uniform_continuous_const_smul Ring.uniformContinuousConstSMul
+
+/- warning: ring.has_uniform_continuous_const_op_smul -> Ring.has_uniform_continuous_const_op_smul is a dubious translation:
+lean 3 declaration is
+  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3))], UniformContinuousConstSMul.{u1, u1} (MulOpposite.{u1} R) R _inst_4 (Mul.toHasOppositeSMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_3)))
+but is expected to have type
+  forall (R : Type.{u1}) [_inst_3 : Ring.{u1} R] [_inst_4 : UniformSpace.{u1} R] [_inst_5 : UniformAddGroup.{u1} R _inst_4 (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_3))] [_inst_6 : ContinuousMul.{u1} R (UniformSpace.toTopologicalSpace.{u1} R _inst_4) (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3)))], UniformContinuousConstSMul.{u1, u1} (MulOpposite.{u1} R) R _inst_4 (Mul.toHasOppositeSMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_3))))
+Case conversion may be inaccurate. Consider using '#align ring.has_uniform_continuous_const_op_smul Ring.has_uniform_continuous_const_op_smulₓ'. -/
 /-- The action of `semiring.to_opposite_module` is uniformly continuous. -/
 instance Ring.has_uniform_continuous_const_op_smul [Ring R] [UniformSpace R] [UniformAddGroup R]
-    [ContinuousMul R] : HasUniformContinuousConstSmul Rᵐᵒᵖ R :=
-  hasUniformContinuousConstSmul_of_continuous_const_smul _ _
+    [ContinuousMul R] : UniformContinuousConstSMul Rᵐᵒᵖ R :=
+  uniformContinuousConstSMul_of_continuousConstSMul _ _
 #align ring.has_uniform_continuous_const_op_smul Ring.has_uniform_continuous_const_op_smul
 
 section SMul
 
 variable [SMul M X]
 
+#print UniformContinuousConstSMul.to_continuousConstSMul /-
 @[to_additive]
-instance (priority := 100) HasUniformContinuousConstSmul.to_continuousConstSMul
-    [HasUniformContinuousConstSmul M X] : ContinuousConstSMul M X :=
+instance (priority := 100) UniformContinuousConstSMul.to_continuousConstSMul
+    [UniformContinuousConstSMul M X] : ContinuousConstSMul M X :=
   ⟨fun c => (uniformContinuous_const_smul c).Continuous⟩
-#align has_uniform_continuous_const_smul.to_has_continuous_const_smul HasUniformContinuousConstSmul.to_continuousConstSMul
-#align has_uniform_continuous_const_vadd.to_has_continuous_const_vadd HasUniformContinuousConstVadd.to_has_continuous_const_vadd
+#align has_uniform_continuous_const_smul.to_has_continuous_const_smul UniformContinuousConstSMul.to_continuousConstSMul
+#align has_uniform_continuous_const_vadd.to_has_continuous_const_vadd UniformContinuousConstVAdd.to_continuousConstVAdd
+-/
 
 variable {M X Y}
 
+#print UniformContinuous.const_smul /-
 @[to_additive]
-theorem UniformContinuous.const_smul [HasUniformContinuousConstSmul M X] {f : Y → X}
+theorem UniformContinuous.const_smul [UniformContinuousConstSMul M X] {f : Y → X}
     (hf : UniformContinuous f) (c : M) : UniformContinuous (c • f) :=
   (uniformContinuous_const_smul c).comp hf
 #align uniform_continuous.const_smul UniformContinuous.const_smul
 #align uniform_continuous.const_vadd UniformContinuous.const_vadd
+-/
 
+#print UniformContinuousConstSMul.op /-
 /-- If a scalar action is central, then its right action is uniform continuous when its left action
 is. -/
 @[to_additive
       "If an additive action is central, then its right action is uniform\ncontinuous when its left action,is."]
-instance (priority := 100) HasUniformContinuousConstSmul.op [SMul Mᵐᵒᵖ X] [IsCentralScalar M X]
-    [HasUniformContinuousConstSmul M X] : HasUniformContinuousConstSmul Mᵐᵒᵖ X :=
+instance (priority := 100) UniformContinuousConstSMul.op [SMul Mᵐᵒᵖ X] [IsCentralScalar M X]
+    [UniformContinuousConstSMul M X] : UniformContinuousConstSMul Mᵐᵒᵖ X :=
   ⟨MulOpposite.rec' fun c =>
       by
       change UniformContinuous fun m => MulOpposite.op c • m
       simp_rw [op_smul_eq_smul]
       exact uniform_continuous_const_smul c⟩
-#align has_uniform_continuous_const_smul.op HasUniformContinuousConstSmul.op
-#align has_uniform_continuous_const_vadd.op HasUniformContinuousConstVadd.op
+#align has_uniform_continuous_const_smul.op UniformContinuousConstSMul.op
+#align has_uniform_continuous_const_vadd.op UniformContinuousConstVAdd.op
+-/
 
+#print MulOpposite.uniformContinuousConstSMul /-
 @[to_additive]
-instance MulOpposite.hasUniformContinuousConstSmul [HasUniformContinuousConstSmul M X] :
-    HasUniformContinuousConstSmul M Xᵐᵒᵖ :=
+instance MulOpposite.uniformContinuousConstSMul [UniformContinuousConstSMul M X] :
+    UniformContinuousConstSMul M Xᵐᵒᵖ :=
   ⟨fun c =>
     MulOpposite.uniformContinuous_op.comp <| MulOpposite.uniformContinuous_unop.const_smul c⟩
-#align mul_opposite.has_uniform_continuous_const_smul MulOpposite.hasUniformContinuousConstSmul
-#align add_opposite.has_uniform_continuous_const_vadd AddOpposite.has_uniform_continuous_const_vadd
+#align mul_opposite.has_uniform_continuous_const_smul MulOpposite.uniformContinuousConstSMul
+#align add_opposite.has_uniform_continuous_const_vadd AddOpposite.uniformContinuousConstVAdd
+-/
 
 end SMul
 
+/- warning: uniform_group.to_has_uniform_continuous_const_smul -> UniformGroup.to_uniformContinuousConstSMul is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] [_inst_4 : UniformSpace.{u1} G] [_inst_5 : UniformGroup.{u1} G _inst_4 _inst_3], UniformContinuousConstSMul.{u1, u1} G G _inst_4 (Mul.toSMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] [_inst_4 : UniformSpace.{u1} G] [_inst_5 : UniformGroup.{u1} G _inst_4 _inst_3], UniformContinuousConstSMul.{u1, u1} G G _inst_4 (MulAction.toSMul.{u1, u1} G G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)) (Monoid.toMulAction.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))
+Case conversion may be inaccurate. Consider using '#align uniform_group.to_has_uniform_continuous_const_smul UniformGroup.to_uniformContinuousConstSMulₓ'. -/
 @[to_additive]
-instance UniformGroup.to_hasUniformContinuousConstSmul {G : Type u} [Group G] [UniformSpace G]
-    [UniformGroup G] : HasUniformContinuousConstSmul G G :=
+instance UniformGroup.to_uniformContinuousConstSMul {G : Type u} [Group G] [UniformSpace G]
+    [UniformGroup G] : UniformContinuousConstSMul G G :=
   ⟨fun c => uniformContinuous_const.mul uniformContinuous_id⟩
-#align uniform_group.to_has_uniform_continuous_const_smul UniformGroup.to_hasUniformContinuousConstSmul
-#align uniform_add_group.to_has_uniform_continuous_const_vadd UniformAddGroup.to_has_uniform_continuous_const_vadd
+#align uniform_group.to_has_uniform_continuous_const_smul UniformGroup.to_uniformContinuousConstSMul
+#align uniform_add_group.to_has_uniform_continuous_const_vadd UniformAddGroup.to_uniformContinuousConstVAdd
 
 namespace UniformSpace
 
@@ -146,19 +186,21 @@ variable [SMul M X]
 instance : SMul M (Completion X) :=
   ⟨fun c => Completion.map ((· • ·) c)⟩
 
+#print UniformSpace.Completion.smul_def /-
 @[to_additive]
 theorem smul_def (c : M) (x : Completion X) : c • x = Completion.map ((· • ·) c) x :=
   rfl
 #align uniform_space.completion.smul_def UniformSpace.Completion.smul_def
 #align uniform_space.completion.vadd_def UniformSpace.Completion.vadd_def
+-/
 
 @[to_additive]
-instance : HasUniformContinuousConstSmul M (Completion X) :=
+instance : UniformContinuousConstSMul M (Completion X) :=
   ⟨fun c => uniformContinuous_map⟩
 
 @[to_additive]
-instance [SMul N X] [SMul M N] [HasUniformContinuousConstSmul M X]
-    [HasUniformContinuousConstSmul N X] [IsScalarTower M N X] : IsScalarTower M N (Completion X) :=
+instance [SMul N X] [SMul M N] [UniformContinuousConstSMul M X] [UniformContinuousConstSMul N X]
+    [IsScalarTower M N X] : IsScalarTower M N (Completion X) :=
   ⟨fun m n x =>
     by
     have : _ = (_ : completion X → completion X) :=
@@ -167,8 +209,8 @@ instance [SMul N X] [SMul M N] [HasUniformContinuousConstSmul M X]
     exact congr_arg (fun f => completion.map f x) (funext (smul_assoc _ _))⟩
 
 @[to_additive]
-instance [SMul N X] [SMulCommClass M N X] [HasUniformContinuousConstSmul M X]
-    [HasUniformContinuousConstSmul N X] : SMulCommClass M N (Completion X) :=
+instance [SMul N X] [SMulCommClass M N X] [UniformContinuousConstSMul M X]
+    [UniformContinuousConstSMul N X] : SMulCommClass M N (Completion X) :=
   ⟨fun m n x =>
     by
     have hmn : m • n • x = (completion.map (SMul.smul m) ∘ completion.map (SMul.smul n)) x := rfl
@@ -181,8 +223,14 @@ instance [SMul N X] [SMulCommClass M N X] [HasUniformContinuousConstSmul M X]
 instance [SMul Mᵐᵒᵖ X] [IsCentralScalar M X] : IsCentralScalar M (Completion X) :=
   ⟨fun c a => (congr_arg fun f => Completion.map f a) <| funext (op_smul_eq_smul c)⟩
 
-variable {M X} [HasUniformContinuousConstSmul M X]
+variable {M X} [UniformContinuousConstSMul M X]
 
+/- warning: uniform_space.completion.coe_smul -> UniformSpace.Completion.coe_smul is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} {X : Type.{u2}} [_inst_1 : UniformSpace.{u2} X] [_inst_3 : SMul.{u1, u2} M X] [_inst_4 : UniformContinuousConstSMul.{u1, u2} M X _inst_1 _inst_3] (c : M) (x : X), Eq.{succ u2} (UniformSpace.Completion.{u2} X _inst_1) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) X (UniformSpace.Completion.{u2} X _inst_1) (HasLiftT.mk.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (CoeTCₓ.coe.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.hasCoeT.{u2} X _inst_1))) (SMul.smul.{u1, u2} M X _inst_3 c x)) (SMul.smul.{u1, u2} M (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.hasSmul.{u1, u2} M X _inst_1 _inst_3) c ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) X (UniformSpace.Completion.{u2} X _inst_1) (HasLiftT.mk.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (CoeTCₓ.coe.{succ u2, succ u2} X (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.hasCoeT.{u2} X _inst_1))) x))
+but is expected to have type
+  forall {M : Type.{u1}} {X : Type.{u2}} [_inst_1 : UniformSpace.{u2} X] [_inst_3 : SMul.{u1, u2} M X] [_inst_4 : UniformContinuousConstSMul.{u1, u2} M X _inst_1 _inst_3] (c : M) (x : X), Eq.{succ u2} (UniformSpace.Completion.{u2} X _inst_1) (Function.comp.{succ u2, succ u2, succ u2} X (CauchyFilter.{u2} X _inst_1) (UniformSpace.Completion.{u2} X _inst_1) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} X _inst_1) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} X _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} X _inst_1))) (CauchyFilter.pureCauchy.{u2} X _inst_1) (HSMul.hSMul.{u1, u2, u2} M X X (instHSMul.{u1, u2} M X _inst_3) c x)) (HSMul.hSMul.{u1, u2, u2} M (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.{u2} X _inst_1) (instHSMul.{u1, u2} M (UniformSpace.Completion.{u2} X _inst_1) (UniformSpace.Completion.instSMulCompletion.{u1, u2} M X _inst_1 _inst_3)) c (Function.comp.{succ u2, succ u2, succ u2} X (CauchyFilter.{u2} X _inst_1) (UniformSpace.Completion.{u2} X _inst_1) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} X _inst_1) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} X _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} X _inst_1))) (CauchyFilter.pureCauchy.{u2} X _inst_1) x))
+Case conversion may be inaccurate. Consider using '#align uniform_space.completion.coe_smul UniformSpace.Completion.coe_smulₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_smul (c : M) (x : X) : ↑(c • x) = (c • x : Completion X) :=
   (map_coe (uniformContinuous_const_smul c) x).symm
@@ -192,7 +240,7 @@ theorem coe_smul (c : M) (x : X) : ↑(c • x) = (c • x : Completion X) :=
 end SMul
 
 @[to_additive]
-instance [Monoid M] [MulAction M X] [HasUniformContinuousConstSmul M X] : MulAction M (Completion X)
+instance [Monoid M] [MulAction M X] [UniformContinuousConstSMul M X] : MulAction M (Completion X)
     where
   smul := (· • ·)
   one_smul := ext' (continuous_const_smul _) continuous_id fun a => by rw [← coe_smul, one_smul]

70fd9563

bump to nightly-2023-02-27-16

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

feafc24f

Diff

@@ -67,7 +67,7 @@ theorem hasUniformContinuousConstSmul_of_continuous_const_smul [Monoid R] [AddCo
     [DistribMulAction R M] [UniformSpace M] [UniformAddGroup M] [ContinuousConstSMul R M] :
     HasUniformContinuousConstSmul R M :=
   ⟨fun r =>
-    uniform_continuous_of_continuous_at_zero (DistribMulAction.toAddMonoidHom M r)
+    uniformContinuous_of_continuousAt_zero (DistribMulAction.toAddMonoidHom M r)
       (Continuous.continuousAt (continuous_const_smul r))⟩
 #align has_uniform_continuous_const_smul_of_continuous_const_smul hasUniformContinuousConstSmul_of_continuous_const_smul

70fd9563

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

70fd9563

chore: adapt to multiple goal linter 3 (#12372)

A PR analogous to #12338 and #12361: reformatting proofs following the multiple goals linter of #12339.

d29b3780

Diff

@@ -175,7 +175,7 @@ instance [SMul N X] [SMulCommClass M N X] [UniformContinuousConstSMul M X]
     have hmn : m • n • x = (Completion.map (SMul.smul m) ∘ Completion.map (SMul.smul n)) x := rfl
     have hnm : n • m • x = (Completion.map (SMul.smul n) ∘ Completion.map (SMul.smul m)) x := rfl
     rw [hmn, hnm, map_comp, map_comp]
-    exact congr_arg (fun f => Completion.map f x) (funext (smul_comm _ _))
+    · exact congr_arg (fun f => Completion.map f x) (funext (smul_comm _ _))
     repeat' exact uniformContinuous_const_smul _⟩
 
 @[to_additive]

70fd9563

chore: replace Lean 3 syntax λ x, in doc comments (#10727)

Use Lean 4 syntax fun x ↦ instead, matching the style guide. This is close to exhaustive for doc comments; mathlib has about 460 remaining uses of λ (not all in Lean 3 syntax).

4a99b7e2

Diff

@@ -36,7 +36,8 @@ class UniformContinuousConstVAdd [VAdd M X] : Prop where
   uniformContinuous_const_vadd : ∀ c : M, UniformContinuous (c +ᵥ · : X → X)
 #align has_uniform_continuous_const_vadd UniformContinuousConstVAdd
 
-/-- A multiplicative action such that for all `c`, the map `λ x, c • x` is uniformly continuous. -/
+/-- A multiplicative action such that for all `c`,
+the map `fun x ↦c • x` is uniformly continuous. -/
 @[to_additive]
 class UniformContinuousConstSMul [SMul M X] : Prop where
   uniformContinuous_const_smul : ∀ c : M, UniformContinuous (c • · : X → X)

70fd9563

feat: action on UniformOnFun is uniformly continuous (#9714)

add UniformInducing.uniformContinuousConstSMul and its additive version;
use it to prove that the pointwise actions on α →ᵤ X and α →ᵤ[𝔖] X are uniformly continuous;
use the latter facts to prove that the pointwise action on E →SL[σ] F is uniformly continuous;
make M explicit in ContinuousLinearMap.strongTopology.continuousConstSMul, drop unneeded arguments.

6dd549bf

Diff

@@ -99,6 +99,14 @@ theorem UniformContinuous.const_smul [UniformContinuousConstSMul M X] {f : Y →
 #align uniform_continuous.const_smul UniformContinuous.const_smul
 #align uniform_continuous.const_vadd UniformContinuous.const_vadd
 
+@[to_additive]
+lemma UniformInducing.uniformContinuousConstSMul [SMul M Y] [UniformContinuousConstSMul M Y]
+    {f : X → Y} (hf : UniformInducing f) (hsmul : ∀ (c : M) x, f (c • x) = c • f x) :
+    UniformContinuousConstSMul M X where
+  uniformContinuous_const_smul c := by
+    simpa only [hf.uniformContinuous_iff, Function.comp_def, hsmul]
+      using hf.uniformContinuous.const_smul c
+
 /-- If a scalar action is central, then its right action is uniform continuous when its left action
 is. -/
 @[to_additive "If an additive action is central, then its right action is uniform

70fd9563

chore: Replace (· op ·) a by (a op ·) (#8843)

I used the regex $\(· (.) ·$ (.)\), replacing with ($2 $1 ·).

d14658b4

Diff

@@ -33,13 +33,13 @@ variable (R : Type u) (M : Type v) (N : Type w) (X : Type x) (Y : Type y) [Unifo
 
 /-- An additive action such that for all `c`, the map `fun x ↦ c +ᵥ x` is uniformly continuous. -/
 class UniformContinuousConstVAdd [VAdd M X] : Prop where
-  uniformContinuous_const_vadd : ∀ c : M, UniformContinuous ((· +ᵥ ·) c : X → X)
+  uniformContinuous_const_vadd : ∀ c : M, UniformContinuous (c +ᵥ · : X → X)
 #align has_uniform_continuous_const_vadd UniformContinuousConstVAdd
 
 /-- A multiplicative action such that for all `c`, the map `λ x, c • x` is uniformly continuous. -/
 @[to_additive]
 class UniformContinuousConstSMul [SMul M X] : Prop where
-  uniformContinuous_const_smul : ∀ c : M, UniformContinuous ((· • ·) c : X → X)
+  uniformContinuous_const_smul : ∀ c : M, UniformContinuous (c • · : X → X)
 #align has_uniform_continuous_const_smul UniformContinuousConstSMul
 
 export UniformContinuousConstVAdd (uniformContinuous_const_vadd)
@@ -105,10 +105,7 @@ is. -/
 continuous when its left action is."]
 instance (priority := 100) UniformContinuousConstSMul.op [SMul Mᵐᵒᵖ X] [IsCentralScalar M X]
     [UniformContinuousConstSMul M X] : UniformContinuousConstSMul Mᵐᵒᵖ X :=
-  ⟨MulOpposite.rec' fun c => by
-    dsimp only
-    simp_rw [op_smul_eq_smul]
-    exact uniformContinuous_const_smul c⟩
+  ⟨MulOpposite.rec' fun c ↦ by simpa only [op_smul_eq_smul] using uniformContinuous_const_smul c⟩
 #align has_uniform_continuous_const_smul.op UniformContinuousConstSMul.op
 #align has_uniform_continuous_const_vadd.op UniformContinuousConstVAdd.op
 
@@ -139,7 +136,7 @@ variable [SMul M X]
 
 @[to_additive]
 noncomputable instance : SMul M (Completion X) :=
-  ⟨fun c => Completion.map ((· • ·) c)⟩
+  ⟨fun c => Completion.map (c • ·)⟩
 
 @[to_additive]
 theorem smul_def (c : M) (x : Completion X) : c • x = Completion.map (c • ·) x :=

70fd9563

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module topology.algebra.uniform_mul_action
-! leanprover-community/mathlib commit 70fd9563a21e7b963887c9360bd29b2393e6225a
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.Algebra.UniformGroup
 import Mathlib.Topology.UniformSpace.Completion
 
+#align_import topology.algebra.uniform_mul_action from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
+
 /-!
 # Multiplicative action on the completion of a uniform space

70fd9563

chore: bump to nightly-2023-07-01 (#5409)

depends on: https://github.com/leanprover/std4/pull/163
depends on: #5584
depends on: #5715
depends on: #5729
depends on: https://github.com/leanprover/std4/pull/173

Co-authored-by: Komyyy <pol_tta@outlook.jp> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

906f7221

Diff

@@ -191,8 +191,8 @@ theorem coe_smul (c : M) (x : X) : (↑(c • x) : Completion X) = c • (x : Co
 end SMul
 
 @[to_additive]
-instance [Monoid M] [MulAction M X] [UniformContinuousConstSMul M X] : MulAction M (Completion X)
-    where
+noncomputable instance [Monoid M] [MulAction M X] [UniformContinuousConstSMul M X] :
+    MulAction M (Completion X) where
   smul := (· • ·)
   one_smul := ext' (continuous_const_smul _) continuous_id fun a => by rw [← coe_smul, one_smul]
   mul_smul x y :=

70fd9563

feat: port RingTheory.DedekindDomain.AdicValuation (#5372)

Co-authored-by: Chris Hughes <chrishughes24@gmail.com>

a53975a7

Diff

@@ -154,14 +154,16 @@ theorem smul_def (c : M) (x : Completion X) : c • x = Completion.map (c • ·
 instance : UniformContinuousConstSMul M (Completion X) :=
   ⟨fun _ => uniformContinuous_map⟩
 
-@[to_additive]
-instance [SMul N X] [SMul M N] [UniformContinuousConstSMul M X]
+@[to_additive instVAddAssocClass]
+instance instIsScalarTower [SMul N X] [SMul M N] [UniformContinuousConstSMul M X]
     [UniformContinuousConstSMul N X] [IsScalarTower M N X] : IsScalarTower M N (Completion X) :=
   ⟨fun m n x => by
     have : _ = (_ : Completion X → Completion X) :=
       map_comp (uniformContinuous_const_smul m) (uniformContinuous_const_smul n)
     refine' Eq.trans _ (congr_fun this.symm x)
     exact congr_arg (fun f => Completion.map f x) (funext (smul_assoc _ _))⟩
+#align uniform_space.completion.is_scalar_tower UniformSpace.Completion.instIsScalarTower
+#align uniform_space.completion.vadd_assoc_class UniformSpace.Completion.instVAddAssocClass
 
 @[to_additive]
 instance [SMul N X] [SMulCommClass M N X] [UniformContinuousConstSMul M X]

70fd9563

chore: convert lambda in docs to fun (#5045)

Found with git grep -n "λ [a-zA-Z_ ]*,"

1164cf04

Diff

@@ -34,7 +34,7 @@ noncomputable section
 variable (R : Type u) (M : Type v) (N : Type w) (X : Type x) (Y : Type y) [UniformSpace X]
   [UniformSpace Y]
 
-/-- An additive action such that for all `c`, the map `λ x, c +ᵥ x` is uniformly continuous. -/
+/-- An additive action such that for all `c`, the map `fun x ↦ c +ᵥ x` is uniformly continuous. -/
 class UniformContinuousConstVAdd [VAdd M X] : Prop where
   uniformContinuous_const_vadd : ∀ c : M, UniformContinuous ((· +ᵥ ·) c : X → X)
 #align has_uniform_continuous_const_vadd UniformContinuousConstVAdd

70fd9563

chore: delete 2074 references (#4030)

1877b122

Diff

@@ -70,28 +70,18 @@ theorem uniformContinuousConstSMul_of_continuousConstSMul [Monoid R] [AddCommGro
       (Continuous.continuousAt (continuous_const_smul r))⟩
 #align has_uniform_continuous_const_smul_of_continuous_const_smul uniformContinuousConstSMul_of_continuousConstSMul
 
-section instances
-
-variable [Ring R]
-
--- Porting note: needs Lean4#2074
-local instance : Module R R := Semiring.toModule
 /-- The action of `Semiring.toModule` is uniformly continuous. -/
 instance Ring.uniformContinuousConstSMul [Ring R] [UniformSpace R] [UniformAddGroup R]
     [ContinuousMul R] : UniformContinuousConstSMul R R :=
   uniformContinuousConstSMul_of_continuousConstSMul _ _
 #align ring.has_uniform_continuous_const_smul Ring.uniformContinuousConstSMul
 
--- Porting note: needs Lean4#2074
-local instance : Module Rᵐᵒᵖ R := Semiring.toOppositeModule
 /-- The action of `Semiring.toOppositeModule` is uniformly continuous. -/
 instance Ring.uniformContinuousConstSMul_op [Ring R] [UniformSpace R] [UniformAddGroup R]
     [ContinuousMul R] : UniformContinuousConstSMul Rᵐᵒᵖ R :=
   uniformContinuousConstSMul_of_continuousConstSMul _ _
 #align ring.has_uniform_continuous_const_op_smul Ring.uniformContinuousConstSMul_op
 
-end instances
-
 section SMul
 
 variable [SMul M X]

70fd9563

chore: use etaExperiment rather than hacking with instances (#3668)

This is to fix timeouts in https://github.com/leanprover-community/mathlib4/pull/3552.

See discussion at https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/!4.233552.20.28LinearAlgebra.2EMatrix.2EToLin.29.

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

0f225a7f

Diff

@@ -75,7 +75,7 @@ section instances
 variable [Ring R]
 
 -- Porting note: needs Lean4#2074
-instance : Module R R := Semiring.toModule
+local instance : Module R R := Semiring.toModule
 /-- The action of `Semiring.toModule` is uniformly continuous. -/
 instance Ring.uniformContinuousConstSMul [Ring R] [UniformSpace R] [UniformAddGroup R]
     [ContinuousMul R] : UniformContinuousConstSMul R R :=
@@ -83,7 +83,7 @@ instance Ring.uniformContinuousConstSMul [Ring R] [UniformSpace R] [UniformAddGr
 #align ring.has_uniform_continuous_const_smul Ring.uniformContinuousConstSMul
 
 -- Porting note: needs Lean4#2074
-instance : Module Rᵐᵒᵖ R := Semiring.toOppositeModule
+local instance : Module Rᵐᵒᵖ R := Semiring.toOppositeModule
 /-- The action of `Semiring.toOppositeModule` is uniformly continuous. -/
 instance Ring.uniformContinuousConstSMul_op [Ring R] [UniformSpace R] [UniformAddGroup R]
     [ContinuousMul R] : UniformContinuousConstSMul Rᵐᵒᵖ R :=

70fd9563

chore: tidy various files (#3530)

8cf71b01

Diff

@@ -27,7 +27,7 @@ TODO: Generalise the results here from the concrete `Completion` to any `Abstrac
 -/
 
 
-universe u v w x y z
+universe u v w x y
 
 noncomputable section
 
@@ -118,11 +118,10 @@ is. -/
 continuous when its left action is."]
 instance (priority := 100) UniformContinuousConstSMul.op [SMul Mᵐᵒᵖ X] [IsCentralScalar M X]
     [UniformContinuousConstSMul M X] : UniformContinuousConstSMul Mᵐᵒᵖ X :=
-  ⟨MulOpposite.rec' fun c =>
-      by
-      change UniformContinuous fun m => MulOpposite.op c • m
-      simp_rw [op_smul_eq_smul]
-      exact uniformContinuous_const_smul c⟩
+  ⟨MulOpposite.rec' fun c => by
+    dsimp only
+    simp_rw [op_smul_eq_smul]
+    exact uniformContinuous_const_smul c⟩
 #align has_uniform_continuous_const_smul.op UniformContinuousConstSMul.op
 #align has_uniform_continuous_const_vadd.op UniformContinuousConstVAdd.op
 
@@ -168,8 +167,7 @@ instance : UniformContinuousConstSMul M (Completion X) :=
 @[to_additive]
 instance [SMul N X] [SMul M N] [UniformContinuousConstSMul M X]
     [UniformContinuousConstSMul N X] [IsScalarTower M N X] : IsScalarTower M N (Completion X) :=
-  ⟨fun m n x =>
-    by
+  ⟨fun m n x => by
     have : _ = (_ : Completion X → Completion X) :=
       map_comp (uniformContinuous_const_smul m) (uniformContinuous_const_smul n)
     refine' Eq.trans _ (congr_fun this.symm x)
@@ -178,8 +176,7 @@ instance [SMul N X] [SMul M N] [UniformContinuousConstSMul M X]
 @[to_additive]
 instance [SMul N X] [SMulCommClass M N X] [UniformContinuousConstSMul M X]
     [UniformContinuousConstSMul N X] : SMulCommClass M N (Completion X) :=
-  ⟨fun m n x =>
-    by
+  ⟨fun m n x => by
     have hmn : m • n • x = (Completion.map (SMul.smul m) ∘ Completion.map (SMul.smul n)) x := rfl
     have hnm : n • m • x = (Completion.map (SMul.smul n) ∘ Completion.map (SMul.smul m)) x := rfl
     rw [hmn, hnm, map_comp, map_comp]
@@ -193,9 +190,7 @@ instance [SMul Mᵐᵒᵖ X] [IsCentralScalar M X] : IsCentralScalar M (Completi
 variable {M X}
 variable [UniformContinuousConstSMul M X]
 
-@[to_additive (attr := simp, nolint simpNF)]
--- Porting note: `simpNF` complains that this lemma can be reduced using `Function.comp`
--- Porting note: `norm_cast` claims this is a badly shaped lemma
+@[to_additive (attr := simp, norm_cast)]
 theorem coe_smul (c : M) (x : X) : (↑(c • x) : Completion X) = c • (x : Completion X) :=
   (map_coe (uniformContinuous_const_smul c) x).symm
 #align uniform_space.completion.coe_smul UniformSpace.Completion.coe_smul

70fd9563

chore: tidy various files (#3110)

0bcbc985

Diff

@@ -49,15 +49,15 @@ export UniformContinuousConstVAdd (uniformContinuous_const_vadd)
 
 export UniformContinuousConstSMul (uniformContinuous_const_smul)
 
-instance AddMonoid.hasUniformContinuousConstSMul_nat [AddGroup X] [UniformAddGroup X] :
+instance AddMonoid.uniformContinuousConstSMul_nat [AddGroup X] [UniformAddGroup X] :
     UniformContinuousConstSMul ℕ X :=
   ⟨uniformContinuous_const_nsmul⟩
-#align add_monoid.has_uniform_continuous_const_smul_nat AddMonoid.hasUniformContinuousConstSMul_nat
+#align add_monoid.has_uniform_continuous_const_smul_nat AddMonoid.uniformContinuousConstSMul_nat
 
-instance AddGroup.hasUniformContinuousConstSMul_int [AddGroup X] [UniformAddGroup X] :
+instance AddGroup.uniformContinuousConstSMul_int [AddGroup X] [UniformAddGroup X] :
     UniformContinuousConstSMul ℤ X :=
   ⟨uniformContinuous_const_zsmul⟩
-#align add_group.has_uniform_continuous_const_smul_int AddGroup.hasUniformContinuousConstSMul_int
+#align add_group.has_uniform_continuous_const_smul_int AddGroup.uniformContinuousConstSMul_int
 
 /-- A `DistribMulAction` that is continuous on a uniform group is uniformly continuous.
 This can't be an instance due to it forming a loop with
@@ -85,10 +85,10 @@ instance Ring.uniformContinuousConstSMul [Ring R] [UniformSpace R] [UniformAddGr
 -- Porting note: needs Lean4#2074
 instance : Module Rᵐᵒᵖ R := Semiring.toOppositeModule
 /-- The action of `Semiring.toOppositeModule` is uniformly continuous. -/
-instance Ring.has_uniform_continuous_const_op_smul [Ring R] [UniformSpace R] [UniformAddGroup R]
+instance Ring.uniformContinuousConstSMul_op [Ring R] [UniformSpace R] [UniformAddGroup R]
     [ContinuousMul R] : UniformContinuousConstSMul Rᵐᵒᵖ R :=
   uniformContinuousConstSMul_of_continuousConstSMul _ _
-#align ring.has_uniform_continuous_const_op_smul Ring.has_uniform_continuous_const_op_smul
+#align ring.has_uniform_continuous_const_op_smul Ring.uniformContinuousConstSMul_op
 
 end instances
 
@@ -115,7 +115,7 @@ theorem UniformContinuous.const_smul [UniformContinuousConstSMul M X] {f : Y →
 /-- If a scalar action is central, then its right action is uniform continuous when its left action
 is. -/
 @[to_additive "If an additive action is central, then its right action is uniform
-continuous when its left action,is."]
+continuous when its left action is."]
 instance (priority := 100) UniformContinuousConstSMul.op [SMul Mᵐᵒᵖ X] [IsCentralScalar M X]
     [UniformContinuousConstSMul M X] : UniformContinuousConstSMul Mᵐᵒᵖ X :=
   ⟨MulOpposite.rec' fun c =>
@@ -156,7 +156,7 @@ noncomputable instance : SMul M (Completion X) :=
   ⟨fun c => Completion.map ((· • ·) c)⟩
 
 @[to_additive]
-theorem smul_def (c : M) (x : Completion X) : c • x = Completion.map ((· • ·) c) x :=
+theorem smul_def (c : M) (x : Completion X) : c • x = Completion.map (c • ·) x :=
   rfl
 #align uniform_space.completion.smul_def UniformSpace.Completion.smul_def
 #align uniform_space.completion.vadd_def UniformSpace.Completion.vadd_def

70fd9563

feat: port Topology.Algebra.UniformMulAction (#2499)

Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com>

8d0c08bd

`topology.algebra.uniform_mul_action` ⟷ `Mathlib.Topology.Algebra.UniformMulAction`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 9 + 402

topology.algebra.uniform_mul_action ⟷ Mathlib.Topology.Algebra.UniformMulAction

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 9 + 402

`topology.algebra.uniform_mul_action` ⟷ `Mathlib.Topology.Algebra.UniformMulAction`