Algebraic operations on SeparationQuotient

In this file we define algebraic operations (multiplication, addition etc) on the separation quotient of a topological space with corresponding operation, provided that the original operation is continuous.

We also prove continuity of these operations and show that they satisfy the same kind of laws (Monoid etc) as the original ones.

Finally, we construct a section of the quotient map which is a continuous linear map SeparationQuotient E →L[K] E.

instance SeparationQuotient.instSMul {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [SMul M X] [ContinuousConstSMul M X] : SMul M (SeparationQuotient X)

Equations

• SeparationQuotient.instSMul = { smul := fun (c : M) => Quotient.map' (fun (x : X) => c • x) ⋯ }

instance SeparationQuotient.instVAdd {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [VAdd M X] [ContinuousConstVAdd M X] : VAdd M (SeparationQuotient X)

Equations

• SeparationQuotient.instVAdd = { vadd := fun (c : M) => Quotient.map' (fun (x : X) => c +ᵥ x) ⋯ }

@[simp]

theorem SeparationQuotient.mk_smul {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [SMul M X] [ContinuousConstSMul M X] (c : M) (x : X) : SeparationQuotient.mk (c • x) = c • SeparationQuotient.mk x

@[simp]

theorem SeparationQuotient.mk_vadd {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [VAdd M X] [ContinuousConstVAdd M X] (c : M) (x : X) : SeparationQuotient.mk (c +ᵥ x) = c +ᵥ SeparationQuotient.mk x

instance SeparationQuotient.instContinuousConstSMul {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [SMul M X] [ContinuousConstSMul M X] : ContinuousConstSMul M (SeparationQuotient X)

instance SeparationQuotient.instContinuousConstVAdd {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [VAdd M X] [ContinuousConstVAdd M X] : ContinuousConstVAdd M (SeparationQuotient X)

instance SeparationQuotient.instIsPretransitiveSMul {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [SMul M X] [ContinuousConstSMul M X] [MulAction.IsPretransitive M X] : MulAction.IsPretransitive M (SeparationQuotient X)

instance SeparationQuotient.instIsPretransitiveVAdd {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [VAdd M X] [ContinuousConstVAdd M X] [AddAction.IsPretransitive M X] : AddAction.IsPretransitive M (SeparationQuotient X)

instance SeparationQuotient.instIsCentralScalar {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [SMul M X] [ContinuousConstSMul M X] [SMul Mᵐᵒᵖ X] [IsCentralScalar M X] : IsCentralScalar M (SeparationQuotient X)

instance SeparationQuotient.instIsCentralVAdd {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [VAdd M X] [ContinuousConstVAdd M X] [VAdd Mᵃᵒᵖ X] [IsCentralVAdd M X] : IsCentralVAdd M (SeparationQuotient X)

instance SeparationQuotient.instSMulCommClass {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [SMul M X] [ContinuousConstSMul M X] {N : Type u_3} [SMul N X] [ContinuousConstSMul N X] [SMulCommClass M N X] : SMulCommClass M N (SeparationQuotient X)

instance SeparationQuotient.instVAddCommClass {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [VAdd M X] [ContinuousConstVAdd M X] {N : Type u_3} [VAdd N X] [ContinuousConstVAdd N X] [VAddCommClass M N X] : VAddCommClass M N (SeparationQuotient X)

instance SeparationQuotient.instIsScalarTower {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [SMul M X] [ContinuousConstSMul M X] {N : Type u_3} [SMul N X] [SMul M N] [ContinuousConstSMul N X] [IsScalarTower M N X] : IsScalarTower M N (SeparationQuotient X)

instance SeparationQuotient.instVAddAssocClass {M : Type u_1} {X : Type u_2} [TopologicalSpace X] [VAdd M X] [ContinuousConstVAdd M X] {N : Type u_3} [VAdd N X] [VAdd M N] [ContinuousConstVAdd N X] [VAddAssocClass M N X] : VAddAssocClass M N (SeparationQuotient X)

instance SeparationQuotient.instContinuousSMul {M : Type u_1} {X : Type u_2} [SMul M X] [TopologicalSpace M] [TopologicalSpace X] [ContinuousSMul M X] : ContinuousSMul M (SeparationQuotient X)

instance SeparationQuotient.instSMulZeroClass {M : Type u_1} {X : Type u_2} [Zero X] [SMulZeroClass M X] [TopologicalSpace X] [ContinuousConstSMul M X] : SMulZeroClass M (SeparationQuotient X)

Equations

• SeparationQuotient.instSMulZeroClass = { toFun := SeparationQuotient.mk, map_zero' := ⋯ }.smulZeroClass ⋯

instance SeparationQuotient.instMulAction {M : Type u_1} {X : Type u_2} [Monoid M] [MulAction M X] [TopologicalSpace X] [ContinuousConstSMul M X] : MulAction M (SeparationQuotient X)

Equations

• SeparationQuotient.instMulAction = Function.Surjective.mulAction SeparationQuotient.mk ⋯ ⋯

instance SeparationQuotient.instAddAction {M : Type u_1} {X : Type u_2} [AddMonoid M] [AddAction M X] [TopologicalSpace X] [ContinuousConstVAdd M X] : AddAction M (SeparationQuotient X)

Equations

• SeparationQuotient.instAddAction = Function.Surjective.addAction SeparationQuotient.mk ⋯ ⋯

instance SeparationQuotient.instMul {M : Type u_1} [TopologicalSpace M] [Mul M] [ContinuousMul M] : Mul (SeparationQuotient M)

Equations

• SeparationQuotient.instMul = { mul := Quotient.map₂ (fun (x1 x2 : M) => x1 * x2) ⋯ }

instance SeparationQuotient.instAdd {M : Type u_1} [TopologicalSpace M] [Add M] [ContinuousAdd M] : Add (SeparationQuotient M)

Equations

• SeparationQuotient.instAdd = { add := Quotient.map₂ (fun (x1 x2 : M) => x1 + x2) ⋯ }

@[simp]

theorem SeparationQuotient.mk_mul {M : Type u_1} [TopologicalSpace M] [Mul M] [ContinuousMul M] (a b : M) : SeparationQuotient.mk (a * b) = SeparationQuotient.mk a * SeparationQuotient.mk b

@[simp]

theorem SeparationQuotient.mk_add {M : Type u_1} [TopologicalSpace M] [Add M] [ContinuousAdd M] (a b : M) : SeparationQuotient.mk (a + b) = SeparationQuotient.mk a + SeparationQuotient.mk b

instance SeparationQuotient.instContinuousMul {M : Type u_1} [TopologicalSpace M] [Mul M] [ContinuousMul M] : ContinuousMul (SeparationQuotient M)

instance SeparationQuotient.instContinuousAdd {M : Type u_1} [TopologicalSpace M] [Add M] [ContinuousAdd M] : ContinuousAdd (SeparationQuotient M)

instance SeparationQuotient.instCommMagma {M : Type u_1} [TopologicalSpace M] [CommMagma M] [ContinuousMul M] : CommMagma (SeparationQuotient M)

Equations

• SeparationQuotient.instCommMagma = Function.Surjective.commMagma SeparationQuotient.mk ⋯ ⋯

instance SeparationQuotient.instAddCommMagma {M : Type u_1} [TopologicalSpace M] [AddCommMagma M] [ContinuousAdd M] : AddCommMagma (SeparationQuotient M)

Equations

• SeparationQuotient.instAddCommMagma = Function.Surjective.addCommMagma SeparationQuotient.mk ⋯ ⋯

instance SeparationQuotient.instSemigroup {M : Type u_1} [TopologicalSpace M] [Semigroup M] [ContinuousMul M] : Semigroup (SeparationQuotient M)

Equations

• SeparationQuotient.instSemigroup = Function.Surjective.semigroup SeparationQuotient.mk ⋯ ⋯

instance SeparationQuotient.instAddSemigroup {M : Type u_1} [TopologicalSpace M] [AddSemigroup M] [ContinuousAdd M] : AddSemigroup (SeparationQuotient M)

Equations

• SeparationQuotient.instAddSemigroup = Function.Surjective.addSemigroup SeparationQuotient.mk ⋯ ⋯

instance SeparationQuotient.instCommSemigroup {M : Type u_1} [TopologicalSpace M] [CommSemigroup M] [ContinuousMul M] : CommSemigroup (SeparationQuotient M)

Equations

• SeparationQuotient.instCommSemigroup = Function.Surjective.commSemigroup SeparationQuotient.mk ⋯ ⋯

instance SeparationQuotient.instAddCommSemigroup {M : Type u_1} [TopologicalSpace M] [AddCommSemigroup M] [ContinuousAdd M] : AddCommSemigroup (SeparationQuotient M)

Equations

• SeparationQuotient.instAddCommSemigroup = Function.Surjective.addCommSemigroup SeparationQuotient.mk ⋯ ⋯

instance SeparationQuotient.instMulOneClass {M : Type u_1} [TopologicalSpace M] [MulOneClass M] [ContinuousMul M] : MulOneClass (SeparationQuotient M)

Equations

• SeparationQuotient.instMulOneClass = Function.Surjective.mulOneClass SeparationQuotient.mk ⋯ ⋯ ⋯

instance SeparationQuotient.instAddZeroClass {M : Type u_1} [TopologicalSpace M] [AddZeroClass M] [ContinuousAdd M] : AddZeroClass (SeparationQuotient M)

Equations

• SeparationQuotient.instAddZeroClass = Function.Surjective.addZeroClass SeparationQuotient.mk ⋯ ⋯ ⋯

def SeparationQuotient.mkMonoidHom {M : Type u_1} [TopologicalSpace M] [MulOneClass M] [ContinuousMul M] : M →* SeparationQuotient M

SeparationQuotient.mk as a MonoidHom.

Equations

• SeparationQuotient.mkMonoidHom = { toFun := SeparationQuotient.mk, map_one' := ⋯, map_mul' := ⋯ }

def SeparationQuotient.mkAddMonoidHom {M : Type u_1} [TopologicalSpace M] [AddZeroClass M] [ContinuousAdd M] : M →+ SeparationQuotient M

SeparationQuotient.mk as an AddMonoidHom.

Equations

• SeparationQuotient.mkAddMonoidHom = { toFun := SeparationQuotient.mk, map_zero' := ⋯, map_add' := ⋯ }

@[simp]

theorem SeparationQuotient.mkAddMonoidHom_apply {M : Type u_1} [TopologicalSpace M] [AddZeroClass M] [ContinuousAdd M] (a✝ : M) : SeparationQuotient.mkAddMonoidHom a✝ = SeparationQuotient.mk a✝

@[simp]

theorem SeparationQuotient.mkMonoidHom_apply {M : Type u_1} [TopologicalSpace M] [MulOneClass M] [ContinuousMul M] (a✝ : M) : SeparationQuotient.mkMonoidHom a✝ = SeparationQuotient.mk a✝

instance SeparationQuotient.instNSmul {M : Type u_1} [TopologicalSpace M] [AddMonoid M] [ContinuousAdd M] : SMul ℕ (SeparationQuotient M)

Equations

• SeparationQuotient.instNSmul = inferInstance

instance SeparationQuotient.instPow {M : Type u_1} [TopologicalSpace M] [Monoid M] [ContinuousMul M] : Pow (SeparationQuotient M) ℕ

Equations

• SeparationQuotient.instPow = { pow := fun (x : SeparationQuotient M) (n : ℕ) => Quotient.map' (fun (x : M) => x ^ n) ⋯ x }

@[simp]

theorem SeparationQuotient.mk_pow {M : Type u_1} [TopologicalSpace M] [Monoid M] [ContinuousMul M] (x : M) (n : ℕ) : SeparationQuotient.mk (x ^ n) = SeparationQuotient.mk x ^ n

theorem SeparationQuotient.mk_nsmul {M : Type u_1} [TopologicalSpace M] [AddMonoid M] [ContinuousAdd M] (x : M) (n : ℕ) : SeparationQuotient.mk (n • x) = n • SeparationQuotient.mk x

instance SeparationQuotient.instMonoid {M : Type u_1} [TopologicalSpace M] [Monoid M] [ContinuousMul M] : Monoid (SeparationQuotient M)

Equations

• SeparationQuotient.instMonoid = Function.Surjective.monoid SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instAddMonoid {M : Type u_1} [TopologicalSpace M] [AddMonoid M] [ContinuousAdd M] : AddMonoid (SeparationQuotient M)

Equations

• SeparationQuotient.instAddMonoid = Function.Surjective.addMonoid SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instCommMonoid {M : Type u_1} [TopologicalSpace M] [CommMonoid M] [ContinuousMul M] : CommMonoid (SeparationQuotient M)

Equations

• SeparationQuotient.instCommMonoid = Function.Surjective.commMonoid SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instAddCommMonoid {M : Type u_1} [TopologicalSpace M] [AddCommMonoid M] [ContinuousAdd M] : AddCommMonoid (SeparationQuotient M)

Equations

• SeparationQuotient.instAddCommMonoid = Function.Surjective.addCommMonoid SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instInv {G : Type u_1} [TopologicalSpace G] [Inv G] [ContinuousInv G] : Inv (SeparationQuotient G)

Equations

• SeparationQuotient.instInv = { inv := Quotient.map' (fun (x : G) => x⁻¹) ⋯ }

instance SeparationQuotient.instNeg {G : Type u_1} [TopologicalSpace G] [Neg G] [ContinuousNeg G] : Neg (SeparationQuotient G)

Equations

• SeparationQuotient.instNeg = { neg := Quotient.map' (fun (x : G) => -x) ⋯ }

@[simp]

theorem SeparationQuotient.mk_inv {G : Type u_1} [TopologicalSpace G] [Inv G] [ContinuousInv G] (x : G) : SeparationQuotient.mk x⁻¹ = (SeparationQuotient.mk x)⁻¹

@[simp]

theorem SeparationQuotient.mk_neg {G : Type u_1} [TopologicalSpace G] [Neg G] [ContinuousNeg G] (x : G) : SeparationQuotient.mk (-x) = -SeparationQuotient.mk x

instance SeparationQuotient.instContinuousInv {G : Type u_1} [TopologicalSpace G] [Inv G] [ContinuousInv G] : ContinuousInv (SeparationQuotient G)

instance SeparationQuotient.instContinuousNeg {G : Type u_1} [TopologicalSpace G] [Neg G] [ContinuousNeg G] : ContinuousNeg (SeparationQuotient G)

instance SeparationQuotient.instInvolutiveInv {G : Type u_1} [TopologicalSpace G] [InvolutiveInv G] [ContinuousInv G] : InvolutiveInv (SeparationQuotient G)

Equations

• SeparationQuotient.instInvolutiveInv = Function.Surjective.involutiveInv SeparationQuotient.mk ⋯ ⋯

instance SeparationQuotient.instInvolutiveNeg {G : Type u_1} [TopologicalSpace G] [InvolutiveNeg G] [ContinuousNeg G] : InvolutiveNeg (SeparationQuotient G)

Equations

• SeparationQuotient.instInvolutiveNeg = Function.Surjective.involutiveNeg SeparationQuotient.mk ⋯ ⋯

instance SeparationQuotient.instInvOneClass {G : Type u_1} [TopologicalSpace G] [InvOneClass G] [ContinuousInv G] : InvOneClass (SeparationQuotient G)

Equations

• SeparationQuotient.instInvOneClass = InvOneClass.mk ⋯

instance SeparationQuotient.instNegZeroClass {G : Type u_1} [TopologicalSpace G] [NegZeroClass G] [ContinuousNeg G] : NegZeroClass (SeparationQuotient G)

Equations

• SeparationQuotient.instNegZeroClass = NegZeroClass.mk ⋯

instance SeparationQuotient.instDiv {G : Type u_1} [TopologicalSpace G] [Div G] [ContinuousDiv G] : Div (SeparationQuotient G)

Equations

• SeparationQuotient.instDiv = { div := Quotient.map₂ (fun (x1 x2 : G) => x1 / x2) ⋯ }

instance SeparationQuotient.instSub {G : Type u_1} [TopologicalSpace G] [Sub G] [ContinuousSub G] : Sub (SeparationQuotient G)

Equations

• SeparationQuotient.instSub = { sub := Quotient.map₂ (fun (x1 x2 : G) => x1 - x2) ⋯ }

@[simp]

theorem SeparationQuotient.mk_div {G : Type u_1} [TopologicalSpace G] [Div G] [ContinuousDiv G] (x y : G) : SeparationQuotient.mk (x / y) = SeparationQuotient.mk x / SeparationQuotient.mk y

@[simp]

theorem SeparationQuotient.mk_sub {G : Type u_1} [TopologicalSpace G] [Sub G] [ContinuousSub G] (x y : G) : SeparationQuotient.mk (x - y) = SeparationQuotient.mk x - SeparationQuotient.mk y

instance SeparationQuotient.instContinuousDiv {G : Type u_1} [TopologicalSpace G] [Div G] [ContinuousDiv G] : ContinuousDiv (SeparationQuotient G)

instance SeparationQuotient.instContinuousSub {G : Type u_1} [TopologicalSpace G] [Sub G] [ContinuousSub G] : ContinuousSub (SeparationQuotient G)

instance SeparationQuotient.instZSMul {G : Type u_1} [TopologicalSpace G] [AddGroup G] [TopologicalAddGroup G] : SMul ℤ (SeparationQuotient G)

Equations

• SeparationQuotient.instZSMul = inferInstance

instance SeparationQuotient.instZPow {G : Type u_1} [TopologicalSpace G] [Group G] [TopologicalGroup G] : Pow (SeparationQuotient G) ℤ

Equations

• SeparationQuotient.instZPow = { pow := fun (x : SeparationQuotient G) (n : ℤ) => Quotient.map' (fun (x : G) => x ^ n) ⋯ x }

@[simp]

theorem SeparationQuotient.mk_zpow {G : Type u_1} [TopologicalSpace G] [Group G] [TopologicalGroup G] (x : G) (n : ℤ) : SeparationQuotient.mk (x ^ n) = SeparationQuotient.mk x ^ n

theorem SeparationQuotient.mk_zsmul {G : Type u_1} [TopologicalSpace G] [AddGroup G] [TopologicalAddGroup G] (x : G) (n : ℤ) : SeparationQuotient.mk (n • x) = n • SeparationQuotient.mk x

instance SeparationQuotient.instGroup {G : Type u_1} [TopologicalSpace G] [Group G] [TopologicalGroup G] : Group (SeparationQuotient G)

Equations

• SeparationQuotient.instGroup = Function.Surjective.group SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instAddGroup {G : Type u_1} [TopologicalSpace G] [AddGroup G] [TopologicalAddGroup G] : AddGroup (SeparationQuotient G)

Equations

• SeparationQuotient.instAddGroup = Function.Surjective.addGroup SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instCommGroup {G : Type u_1} [TopologicalSpace G] [CommGroup G] [TopologicalGroup G] : CommGroup (SeparationQuotient G)

Equations

• SeparationQuotient.instCommGroup = Function.Surjective.commGroup SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instAddCommGroup {G : Type u_1} [TopologicalSpace G] [AddCommGroup G] [TopologicalAddGroup G] : AddCommGroup (SeparationQuotient G)

Equations

• SeparationQuotient.instAddCommGroup = Function.Surjective.addCommGroup SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instUniformGroup {G : Type u_1} [Group G] [UniformSpace G] [UniformGroup G] : UniformGroup (SeparationQuotient G)

instance SeparationQuotient.instUniformAddGroup {G : Type u_1} [AddGroup G] [UniformSpace G] [UniformAddGroup G] : UniformAddGroup (SeparationQuotient G)

instance SeparationQuotient.instMulZeroClass {M₀ : Type u_1} [TopologicalSpace M₀] [MulZeroClass M₀] [ContinuousMul M₀] : MulZeroClass (SeparationQuotient M₀)

Equations

• SeparationQuotient.instMulZeroClass = Function.Surjective.mulZeroClass SeparationQuotient.mk ⋯ ⋯ ⋯

instance SeparationQuotient.instSemigroupWithZero {M₀ : Type u_1} [TopologicalSpace M₀] [SemigroupWithZero M₀] [ContinuousMul M₀] : SemigroupWithZero (SeparationQuotient M₀)

Equations

• SeparationQuotient.instSemigroupWithZero = Function.Surjective.semigroupWithZero SeparationQuotient.mk ⋯ ⋯ ⋯

instance SeparationQuotient.instMulZeroOneClass {M₀ : Type u_1} [TopologicalSpace M₀] [MulZeroOneClass M₀] [ContinuousMul M₀] : MulZeroOneClass (SeparationQuotient M₀)

Equations

• SeparationQuotient.instMulZeroOneClass = Function.Surjective.mulZeroOneClass SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instMonoidWithZero {M₀ : Type u_1} [TopologicalSpace M₀] [MonoidWithZero M₀] [ContinuousMul M₀] : MonoidWithZero (SeparationQuotient M₀)

Equations

• SeparationQuotient.instMonoidWithZero = Function.Surjective.monoidWithZero SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instCommMonoidWithZero {M₀ : Type u_1} [TopologicalSpace M₀] [CommMonoidWithZero M₀] [ContinuousMul M₀] : CommMonoidWithZero (SeparationQuotient M₀)

Equations

• SeparationQuotient.instCommMonoidWithZero = Function.Surjective.commMonoidWithZero SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instDistrib {R : Type u_1} [TopologicalSpace R] [Distrib R] [ContinuousMul R] [ContinuousAdd R] : Distrib (SeparationQuotient R)

Equations

• SeparationQuotient.instDistrib = Function.Surjective.distrib SeparationQuotient.mk ⋯ ⋯ ⋯

instance SeparationQuotient.instLeftDistribClass {R : Type u_1} [TopologicalSpace R] [Mul R] [Add R] [LeftDistribClass R] [ContinuousMul R] [ContinuousAdd R] : LeftDistribClass (SeparationQuotient R)

instance SeparationQuotient.instRightDistribClass {R : Type u_1} [TopologicalSpace R] [Mul R] [Add R] [RightDistribClass R] [ContinuousMul R] [ContinuousAdd R] : RightDistribClass (SeparationQuotient R)

instance SeparationQuotient.instNonUnitalnonAssocSemiring {R : Type u_1} [TopologicalSpace R] [NonUnitalNonAssocSemiring R] [TopologicalSemiring R] : NonUnitalNonAssocSemiring (SeparationQuotient R)

Equations

• SeparationQuotient.instNonUnitalnonAssocSemiring = Function.Surjective.nonUnitalNonAssocSemiring SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instNonUnitalSemiring {R : Type u_1} [TopologicalSpace R] [NonUnitalSemiring R] [TopologicalSemiring R] : NonUnitalSemiring (SeparationQuotient R)

Equations

• SeparationQuotient.instNonUnitalSemiring = Function.Surjective.nonUnitalSemiring SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instNatCast {R : Type u_1} [TopologicalSpace R] [NatCast R] : NatCast (SeparationQuotient R)

Equations

• SeparationQuotient.instNatCast = { natCast := fun (n : ℕ) => SeparationQuotient.mk ↑n }

@[simp]

theorem SeparationQuotient.mk_natCast {R : Type u_1} [TopologicalSpace R] [NatCast R] (n : ℕ) : SeparationQuotient.mk ↑n = ↑n

@[simp]

theorem SeparationQuotient.mk_ofNat {R : Type u_1} [TopologicalSpace R] [NatCast R] (n : ℕ) [n.AtLeastTwo] : SeparationQuotient.mk (OfNat.ofNat n) = OfNat.ofNat n

instance SeparationQuotient.instIntCast {R : Type u_1} [TopologicalSpace R] [IntCast R] : IntCast (SeparationQuotient R)

Equations

• SeparationQuotient.instIntCast = { intCast := fun (n : ℤ) => SeparationQuotient.mk ↑n }

@[simp]

theorem SeparationQuotient.mk_intCast {R : Type u_1} [TopologicalSpace R] [IntCast R] (n : ℤ) : SeparationQuotient.mk ↑n = ↑n

instance SeparationQuotient.instNonAssocSemiring {R : Type u_1} [TopologicalSpace R] [NonAssocSemiring R] [TopologicalSemiring R] : NonAssocSemiring (SeparationQuotient R)

Equations

• SeparationQuotient.instNonAssocSemiring = Function.Surjective.nonAssocSemiring SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instNonUnitalNonAssocRing {R : Type u_1} [TopologicalSpace R] [NonUnitalNonAssocRing R] [TopologicalRing R] : NonUnitalNonAssocRing (SeparationQuotient R)

Equations

• SeparationQuotient.instNonUnitalNonAssocRing = Function.Surjective.nonUnitalNonAssocRing SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instNonUnitalRing {R : Type u_1} [TopologicalSpace R] [NonUnitalRing R] [TopologicalRing R] : NonUnitalRing (SeparationQuotient R)

Equations

• SeparationQuotient.instNonUnitalRing = Function.Surjective.nonUnitalRing SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instNonAssocRing {R : Type u_1} [TopologicalSpace R] [NonAssocRing R] [TopologicalRing R] : NonAssocRing (SeparationQuotient R)

Equations

• SeparationQuotient.instNonAssocRing = Function.Surjective.nonAssocRing SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instSemiring {R : Type u_1} [TopologicalSpace R] [Semiring R] [TopologicalSemiring R] : Semiring (SeparationQuotient R)

Equations

• SeparationQuotient.instSemiring = Function.Surjective.semiring SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instRing {R : Type u_1} [TopologicalSpace R] [Ring R] [TopologicalRing R] : Ring (SeparationQuotient R)

Equations

• SeparationQuotient.instRing = Function.Surjective.ring SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instNonUnitalNonAssocCommSemiring {R : Type u_1} [TopologicalSpace R] [NonUnitalNonAssocCommSemiring R] [TopologicalSemiring R] : NonUnitalNonAssocCommSemiring (SeparationQuotient R)

Equations

• SeparationQuotient.instNonUnitalNonAssocCommSemiring = Function.Surjective.nonUnitalNonAssocCommSemiring SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instNonUnitalCommSemiring {R : Type u_1} [TopologicalSpace R] [NonUnitalCommSemiring R] [TopologicalSemiring R] : NonUnitalCommSemiring (SeparationQuotient R)

Equations

• SeparationQuotient.instNonUnitalCommSemiring = Function.Surjective.nonUnitalCommSemiring SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instCommSemiring {R : Type u_1} [TopologicalSpace R] [CommSemiring R] [TopologicalSemiring R] : CommSemiring (SeparationQuotient R)

Equations

• SeparationQuotient.instCommSemiring = Function.Surjective.commSemiring SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instHasDistribNeg {R : Type u_1} [TopologicalSpace R] [Mul R] [HasDistribNeg R] [ContinuousMul R] [ContinuousNeg R] : HasDistribNeg (SeparationQuotient R)

Equations

• SeparationQuotient.instHasDistribNeg = Function.Surjective.hasDistribNeg SeparationQuotient.mk ⋯ ⋯ ⋯

instance SeparationQuotient.instNonUnitalNonAssocCommRing {R : Type u_1} [TopologicalSpace R] [NonUnitalNonAssocCommRing R] [TopologicalRing R] : NonUnitalNonAssocCommRing (SeparationQuotient R)

Equations

• SeparationQuotient.instNonUnitalNonAssocCommRing = Function.Surjective.nonUnitalNonAssocCommRing SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instNonUnitalCommRing {R : Type u_1} [TopologicalSpace R] [NonUnitalCommRing R] [TopologicalRing R] : NonUnitalCommRing (SeparationQuotient R)

Equations

• SeparationQuotient.instNonUnitalCommRing = Function.Surjective.nonUnitalCommRing SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance SeparationQuotient.instCommRing {R : Type u_1} [TopologicalSpace R] [CommRing R] [TopologicalRing R] : CommRing (SeparationQuotient R)

Equations

• SeparationQuotient.instCommRing = Function.Surjective.commRing SeparationQuotient.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

def SeparationQuotient.mkRingHom {R : Type u_1} [TopologicalSpace R] [NonAssocSemiring R] [TopologicalSemiring R] : R →+* SeparationQuotient R

SeparationQuotient.mk as a RingHom.

Equations

• SeparationQuotient.mkRingHom = { toFun := SeparationQuotient.mk, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }

@[simp]

theorem SeparationQuotient.mkRingHom_apply {R : Type u_1} [TopologicalSpace R] [NonAssocSemiring R] [TopologicalSemiring R] (a✝ : R) : SeparationQuotient.mkRingHom a✝ = SeparationQuotient.mk a✝

instance SeparationQuotient.instDistribSMul {M : Type u_1} {A : Type u_2} [TopologicalSpace A] [AddZeroClass A] [DistribSMul M A] [ContinuousAdd A] [ContinuousConstSMul M A] : DistribSMul M (SeparationQuotient A)

Equations

• SeparationQuotient.instDistribSMul = Function.Surjective.distribSMul SeparationQuotient.mkAddMonoidHom ⋯ ⋯

instance SeparationQuotient.instDistribMulAction {M : Type u_1} {A : Type u_2} [TopologicalSpace A] [Monoid M] [AddMonoid A] [DistribMulAction M A] [ContinuousAdd A] [ContinuousConstSMul M A] : DistribMulAction M (SeparationQuotient A)

Equations

• SeparationQuotient.instDistribMulAction = Function.Surjective.distribMulAction SeparationQuotient.mkAddMonoidHom ⋯ ⋯

instance SeparationQuotient.instMulDistribMulAction {M : Type u_1} {A : Type u_2} [TopologicalSpace A] [Monoid M] [Monoid A] [MulDistribMulAction M A] [ContinuousMul A] [ContinuousConstSMul M A] : MulDistribMulAction M (SeparationQuotient A)

Equations

• SeparationQuotient.instMulDistribMulAction = Function.Surjective.mulDistribMulAction SeparationQuotient.mkMonoidHom ⋯ ⋯

instance SeparationQuotient.instModule {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] [TopologicalSpace M] [ContinuousAdd M] [ContinuousConstSMul R M] : Module R (SeparationQuotient M)

Equations

• SeparationQuotient.instModule = Function.Surjective.module R SeparationQuotient.mkAddMonoidHom ⋯ ⋯

def SeparationQuotient.mkCLM (R : Type u_1) (M : Type u_2) [Semiring R] [AddCommMonoid M] [Module R M] [TopologicalSpace M] [ContinuousAdd M] [ContinuousConstSMul R M] : M →L[R] SeparationQuotient M

SeparationQuotient.mk as a continuous linear map.

Equations

• SeparationQuotient.mkCLM R M = { toFun := SeparationQuotient.mk, map_add' := ⋯, map_smul' := ⋯, cont := ⋯ }

@[simp]

theorem SeparationQuotient.mkCLM_apply (R : Type u_1) (M : Type u_2) [Semiring R] [AddCommMonoid M] [Module R M] [TopologicalSpace M] [ContinuousAdd M] [ContinuousConstSMul R M] (a✝ : M) : (SeparationQuotient.mkCLM R M) a✝ = SeparationQuotient.mk a✝

instance SeparationQuotient.instAlgebra {R : Type u_1} {A : Type u_2} [CommSemiring R] [Semiring A] [Algebra R A] [TopologicalSpace A] [TopologicalSemiring A] [ContinuousConstSMul R A] : Algebra R (SeparationQuotient A)

Equations

• SeparationQuotient.instAlgebra = Algebra.mk (SeparationQuotient.mkRingHom.comp (algebraMap R A)) ⋯ ⋯

@[simp]

theorem SeparationQuotient.mk_algebraMap {R : Type u_1} {A : Type u_2} [CommSemiring R] [Semiring A] [Algebra R A] [TopologicalSpace A] [TopologicalSemiring A] [ContinuousConstSMul R A] (r : R) : SeparationQuotient.mk ((algebraMap R A) r) = (algebraMap R (SeparationQuotient A)) r