Algebraic structure on locally constant functions

This file puts algebraic structure (Group, AddGroup, etc) on the type of locally constant functions.

instance LocallyConstant.instOne {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [One Y] : One (LocallyConstant X Y)

Equations

• LocallyConstant.instOne = { one := LocallyConstant.const X 1 }

instance LocallyConstant.instZero {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Zero Y] : Zero (LocallyConstant X Y)

Equations

• LocallyConstant.instZero = { zero := LocallyConstant.const X 0 }

@[simp]

theorem LocallyConstant.coe_one {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [One Y] : ⇑1 = 1

@[simp]

theorem LocallyConstant.coe_zero {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Zero Y] : ⇑0 = 0

theorem LocallyConstant.one_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [One Y] (x : X) : 1 x = 1

theorem LocallyConstant.zero_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Zero Y] (x : X) : 0 x = 0

instance LocallyConstant.instInv {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Inv Y] : Inv (LocallyConstant X Y)

Equations

• LocallyConstant.instInv = { inv := fun (f : LocallyConstant X Y) => { toFun := (⇑f)⁻¹, isLocallyConstant := ⋯ } }

instance LocallyConstant.instNeg {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Neg Y] : Neg (LocallyConstant X Y)

Equations

• LocallyConstant.instNeg = { neg := fun (f : LocallyConstant X Y) => { toFun := -⇑f, isLocallyConstant := ⋯ } }

@[simp]

theorem LocallyConstant.coe_inv {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Inv Y] (f : LocallyConstant X Y) : ⇑f⁻¹ = (⇑f)⁻¹

@[simp]

theorem LocallyConstant.coe_neg {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Neg Y] (f : LocallyConstant X Y) : ⇑(-f) = -⇑f

theorem LocallyConstant.inv_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Inv Y] (f : LocallyConstant X Y) (x : X) : f⁻¹ x = (f x)⁻¹

theorem LocallyConstant.neg_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Neg Y] (f : LocallyConstant X Y) (x : X) : (-f) x = -f x

instance LocallyConstant.instMul {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Mul Y] : Mul (LocallyConstant X Y)

Equations

• LocallyConstant.instMul = { mul := fun (f g : LocallyConstant X Y) => { toFun := ⇑f * ⇑g, isLocallyConstant := ⋯ } }

instance LocallyConstant.instAdd {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Add Y] : Add (LocallyConstant X Y)

Equations

• LocallyConstant.instAdd = { add := fun (f g : LocallyConstant X Y) => { toFun := ⇑f + ⇑g, isLocallyConstant := ⋯ } }

@[simp]

theorem LocallyConstant.coe_mul {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Mul Y] (f g : LocallyConstant X Y) : ⇑(f * g) = ⇑f * ⇑g

@[simp]

theorem LocallyConstant.coe_add {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Add Y] (f g : LocallyConstant X Y) : ⇑(f + g) = ⇑f + ⇑g

theorem LocallyConstant.mul_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Mul Y] (f g : LocallyConstant X Y) (x : X) : (f * g) x = f x * g x

theorem LocallyConstant.add_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Add Y] (f g : LocallyConstant X Y) (x : X) : (f + g) x = f x + g x

instance LocallyConstant.instMulOneClass {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [MulOneClass Y] : MulOneClass (LocallyConstant X Y)

Equations

• LocallyConstant.instMulOneClass = Function.Injective.mulOneClass DFunLike.coe ⋯ ⋯ ⋯

instance LocallyConstant.instAddZeroClass {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddZeroClass Y] : AddZeroClass (LocallyConstant X Y)

Equations

• LocallyConstant.instAddZeroClass = Function.Injective.addZeroClass DFunLike.coe ⋯ ⋯ ⋯

def LocallyConstant.coeFnMonoidHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [MulOneClass Y] : LocallyConstant X Y →* X → Y

DFunLike.coe as a MonoidHom.

Equations

• LocallyConstant.coeFnMonoidHom = { toFun := DFunLike.coe, map_one' := ⋯, map_mul' := ⋯ }

def LocallyConstant.coeFnAddMonoidHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddZeroClass Y] : LocallyConstant X Y →+ X → Y

DFunLike.coe as an AddMonoidHom.

Equations

• LocallyConstant.coeFnAddMonoidHom = { toFun := DFunLike.coe, map_zero' := ⋯, map_add' := ⋯ }

@[simp]

theorem LocallyConstant.coeFnMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [MulOneClass Y] (a✝ : LocallyConstant X Y) (a : X) : LocallyConstant.coeFnMonoidHom a✝ a = a✝ a

@[simp]

theorem LocallyConstant.coeFnAddMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddZeroClass Y] (a✝ : LocallyConstant X Y) (a : X) : LocallyConstant.coeFnAddMonoidHom a✝ a = a✝ a

def LocallyConstant.constMonoidHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [MulOneClass Y] : Y →* LocallyConstant X Y

The constant-function embedding, as a multiplicative monoid hom.

Equations

• LocallyConstant.constMonoidHom = { toFun := LocallyConstant.const X, map_one' := ⋯, map_mul' := ⋯ }

def LocallyConstant.constAddMonoidHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddZeroClass Y] : Y →+ LocallyConstant X Y

The constant-function embedding, as an additive monoid hom.

Equations

• LocallyConstant.constAddMonoidHom = { toFun := LocallyConstant.const X, map_zero' := ⋯, map_add' := ⋯ }

@[simp]

theorem LocallyConstant.constAddMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddZeroClass Y] (y : Y) : LocallyConstant.constAddMonoidHom y = LocallyConstant.const X y

@[simp]

theorem LocallyConstant.constMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [MulOneClass Y] (y : Y) : LocallyConstant.constMonoidHom y = LocallyConstant.const X y

instance LocallyConstant.instMulZeroClass {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [MulZeroClass Y] : MulZeroClass (LocallyConstant X Y)

Equations

• LocallyConstant.instMulZeroClass = Function.Injective.mulZeroClass DFunLike.coe ⋯ ⋯ ⋯

instance LocallyConstant.instMulZeroOneClass {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [MulZeroOneClass Y] : MulZeroOneClass (LocallyConstant X Y)

Equations

• LocallyConstant.instMulZeroOneClass = Function.Injective.mulZeroOneClass DFunLike.coe ⋯ ⋯ ⋯ ⋯

noncomputable def LocallyConstant.charFn {X : Type u_1} (Y : Type u_2) [TopologicalSpace X] [MulZeroOneClass Y] {U : Set X} (hU : IsClopen U) : LocallyConstant X Y

Characteristic functions are locally constant functions taking x : X to 1 if x ∈ U, where U is a clopen set, and 0 otherwise.

Equations

• LocallyConstant.charFn Y hU = LocallyConstant.indicator 1 hU

theorem LocallyConstant.coe_charFn {X : Type u_1} (Y : Type u_2) [TopologicalSpace X] [MulZeroOneClass Y] {U : Set X} (hU : IsClopen U) : ⇑(LocallyConstant.charFn Y hU) = U.indicator 1

theorem LocallyConstant.charFn_eq_one {X : Type u_1} (Y : Type u_2) [TopologicalSpace X] [MulZeroOneClass Y] {U : Set X} [Nontrivial Y] (x : X) (hU : IsClopen U) : (LocallyConstant.charFn Y hU) x = 1 ↔ x ∈ U

theorem LocallyConstant.charFn_eq_zero {X : Type u_1} (Y : Type u_2) [TopologicalSpace X] [MulZeroOneClass Y] {U : Set X} [Nontrivial Y] (x : X) (hU : IsClopen U) : (LocallyConstant.charFn Y hU) x = 0 ↔ x ∉ U

theorem LocallyConstant.charFn_inj {X : Type u_1} (Y : Type u_2) [TopologicalSpace X] [MulZeroOneClass Y] {U V : Set X} [Nontrivial Y] (hU : IsClopen U) (hV : IsClopen V) (h : LocallyConstant.charFn Y hU = LocallyConstant.charFn Y hV) : U = V

instance LocallyConstant.instDiv {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Div Y] : Div (LocallyConstant X Y)

Equations

• LocallyConstant.instDiv = { div := fun (f g : LocallyConstant X Y) => { toFun := ⇑f / ⇑g, isLocallyConstant := ⋯ } }

instance LocallyConstant.instSub {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Sub Y] : Sub (LocallyConstant X Y)

Equations

• LocallyConstant.instSub = { sub := fun (f g : LocallyConstant X Y) => { toFun := ⇑f - ⇑g, isLocallyConstant := ⋯ } }

theorem LocallyConstant.coe_div {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Div Y] (f g : LocallyConstant X Y) : ⇑(f / g) = ⇑f / ⇑g

theorem LocallyConstant.coe_sub {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Sub Y] (f g : LocallyConstant X Y) : ⇑(f - g) = ⇑f - ⇑g

theorem LocallyConstant.div_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Div Y] (f g : LocallyConstant X Y) (x : X) : (f / g) x = f x / g x

theorem LocallyConstant.sub_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Sub Y] (f g : LocallyConstant X Y) (x : X) : (f - g) x = f x - g x

instance LocallyConstant.instSemigroup {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Semigroup Y] : Semigroup (LocallyConstant X Y)

Equations

• LocallyConstant.instSemigroup = Function.Injective.semigroup DFunLike.coe ⋯ ⋯

instance LocallyConstant.instAddSemigroup {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddSemigroup Y] : AddSemigroup (LocallyConstant X Y)

Equations

• LocallyConstant.instAddSemigroup = Function.Injective.addSemigroup DFunLike.coe ⋯ ⋯

instance LocallyConstant.instSemigroupWithZero {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [SemigroupWithZero Y] : SemigroupWithZero (LocallyConstant X Y)

Equations

• LocallyConstant.instSemigroupWithZero = Function.Injective.semigroupWithZero DFunLike.coe ⋯ ⋯ ⋯

instance LocallyConstant.instCommSemigroup {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [CommSemigroup Y] : CommSemigroup (LocallyConstant X Y)

Equations

• LocallyConstant.instCommSemigroup = Function.Injective.commSemigroup DFunLike.coe ⋯ ⋯

instance LocallyConstant.instAddCommSemigroup {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddCommSemigroup Y] : AddCommSemigroup (LocallyConstant X Y)

Equations

• LocallyConstant.instAddCommSemigroup = Function.Injective.addCommSemigroup DFunLike.coe ⋯ ⋯

instance LocallyConstant.smul {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {α : Type u_3} [SMul α Y] : SMul α (LocallyConstant X Y)

Equations

• LocallyConstant.smul = { smul := fun (n : α) (f : LocallyConstant X Y) => LocallyConstant.map (fun (x : Y) => n • x) f }

instance LocallyConstant.vadd {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {α : Type u_3} [VAdd α Y] : VAdd α (LocallyConstant X Y)

Equations

• LocallyConstant.vadd = { vadd := fun (n : α) (f : LocallyConstant X Y) => LocallyConstant.map (fun (x : Y) => n +ᵥ x) f }

@[simp]

theorem LocallyConstant.coe_smul {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_4} [SMul R Y] (r : R) (f : LocallyConstant X Y) : ⇑(r • f) = r • ⇑f

@[simp]

theorem LocallyConstant.coe_vadd {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_4} [VAdd R Y] (r : R) (f : LocallyConstant X Y) : ⇑(r +ᵥ f) = r +ᵥ ⇑f

theorem LocallyConstant.smul_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_4} [SMul R Y] (r : R) (f : LocallyConstant X Y) (x : X) : (r • f) x = r • f x

theorem LocallyConstant.vadd_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_4} [VAdd R Y] (r : R) (f : LocallyConstant X Y) (x : X) : (r +ᵥ f) x = r +ᵥ f x

instance LocallyConstant.instPow {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {α : Type u_3} [Pow Y α] : Pow (LocallyConstant X Y) α

Equations

• LocallyConstant.instPow = { pow := fun (f : LocallyConstant X Y) (n : α) => LocallyConstant.map (fun (x : Y) => x ^ n) f }

instance LocallyConstant.instMonoid {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Monoid Y] : Monoid (LocallyConstant X Y)

Equations

• LocallyConstant.instMonoid = Function.Injective.monoid DFunLike.coe ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instAddMonoid {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddMonoid Y] : AddMonoid (LocallyConstant X Y)

Equations

• LocallyConstant.instAddMonoid = Function.Injective.addMonoid DFunLike.coe ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instNatCast {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [NatCast Y] : NatCast (LocallyConstant X Y)

Equations

• LocallyConstant.instNatCast = { natCast := fun (n : ℕ) => LocallyConstant.const X ↑n }

instance LocallyConstant.instIntCast {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [IntCast Y] : IntCast (LocallyConstant X Y)

Equations

• LocallyConstant.instIntCast = { intCast := fun (n : ℤ) => LocallyConstant.const X ↑n }

instance LocallyConstant.instAddMonoidWithOne {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddMonoidWithOne Y] : AddMonoidWithOne (LocallyConstant X Y)

Equations

• LocallyConstant.instAddMonoidWithOne = Function.Injective.addMonoidWithOne DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instCommMonoid {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [CommMonoid Y] : CommMonoid (LocallyConstant X Y)

Equations

• LocallyConstant.instCommMonoid = Function.Injective.commMonoid DFunLike.coe ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instAddCommMonoid {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddCommMonoid Y] : AddCommMonoid (LocallyConstant X Y)

Equations

• LocallyConstant.instAddCommMonoid = Function.Injective.addCommMonoid DFunLike.coe ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instGroup {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Group Y] : Group (LocallyConstant X Y)

Equations

• LocallyConstant.instGroup = Function.Injective.group DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instAddGroup {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddGroup Y] : AddGroup (LocallyConstant X Y)

Equations

• LocallyConstant.instAddGroup = Function.Injective.addGroup DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instCommGroup {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [CommGroup Y] : CommGroup (LocallyConstant X Y)

Equations

• LocallyConstant.instCommGroup = Function.Injective.commGroup DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instAddCommGroup {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddCommGroup Y] : AddCommGroup (LocallyConstant X Y)

Equations

• LocallyConstant.instAddCommGroup = Function.Injective.addCommGroup DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instDistrib {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Distrib Y] : Distrib (LocallyConstant X Y)

Equations

• LocallyConstant.instDistrib = Function.Injective.distrib DFunLike.coe ⋯ ⋯ ⋯

instance LocallyConstant.instNonUnitalNonAssocSemiring {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [NonUnitalNonAssocSemiring Y] : NonUnitalNonAssocSemiring (LocallyConstant X Y)

Equations

• LocallyConstant.instNonUnitalNonAssocSemiring = Function.Injective.nonUnitalNonAssocSemiring DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instNonUnitalSemiring {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [NonUnitalSemiring Y] : NonUnitalSemiring (LocallyConstant X Y)

Equations

• LocallyConstant.instNonUnitalSemiring = Function.Injective.nonUnitalSemiring DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instNonAssocSemiring {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [NonAssocSemiring Y] : NonAssocSemiring (LocallyConstant X Y)

Equations

• LocallyConstant.instNonAssocSemiring = Function.Injective.nonAssocSemiring DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

def LocallyConstant.constRingHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [NonAssocSemiring Y] : Y →+* LocallyConstant X Y

The constant-function embedding, as a ring hom.

Equations

• LocallyConstant.constRingHom = { toFun := LocallyConstant.const X, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }

@[simp]

theorem LocallyConstant.constRingHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [NonAssocSemiring Y] (y : Y) : LocallyConstant.constRingHom y = LocallyConstant.const X y

instance LocallyConstant.instSemiring {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Semiring Y] : Semiring (LocallyConstant X Y)

Equations

• LocallyConstant.instSemiring = Function.Injective.semiring DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instNonUnitalCommSemiring {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [NonUnitalCommSemiring Y] : NonUnitalCommSemiring (LocallyConstant X Y)

Equations

• LocallyConstant.instNonUnitalCommSemiring = Function.Injective.nonUnitalCommSemiring DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instCommSemiring {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [CommSemiring Y] : CommSemiring (LocallyConstant X Y)

Equations

• LocallyConstant.instCommSemiring = Function.Injective.commSemiring DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instNonUnitalNonAssocRing {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [NonUnitalNonAssocRing Y] : NonUnitalNonAssocRing (LocallyConstant X Y)

Equations

• LocallyConstant.instNonUnitalNonAssocRing = Function.Injective.nonUnitalNonAssocRing DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instNonUnitalRing {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [NonUnitalRing Y] : NonUnitalRing (LocallyConstant X Y)

Equations

• LocallyConstant.instNonUnitalRing = Function.Injective.nonUnitalRing DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instNonAssocRing {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [NonAssocRing Y] : NonAssocRing (LocallyConstant X Y)

Equations

• LocallyConstant.instNonAssocRing = Function.Injective.nonAssocRing DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instRing {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Ring Y] : Ring (LocallyConstant X Y)

Equations

• LocallyConstant.instRing = Function.Injective.ring DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instNonUnitalCommRing {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [NonUnitalCommRing Y] : NonUnitalCommRing (LocallyConstant X Y)

Equations

• LocallyConstant.instNonUnitalCommRing = Function.Injective.nonUnitalCommRing DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instCommRing {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [CommRing Y] : CommRing (LocallyConstant X Y)

Equations

• LocallyConstant.instCommRing = Function.Injective.commRing DFunLike.coe ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

instance LocallyConstant.instMulAction {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_5} [Monoid R] [MulAction R Y] : MulAction R (LocallyConstant X Y)

Equations

• LocallyConstant.instMulAction = Function.Injective.mulAction DFunLike.coe ⋯ ⋯

instance LocallyConstant.instDistribMulAction {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_5} [Monoid R] [AddMonoid Y] [DistribMulAction R Y] : DistribMulAction R (LocallyConstant X Y)

Equations

• LocallyConstant.instDistribMulAction = Function.Injective.distribMulAction LocallyConstant.coeFnAddMonoidHom ⋯ ⋯

instance LocallyConstant.instModule {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_5} [Semiring R] [AddCommMonoid Y] [Module R Y] : Module R (LocallyConstant X Y)

Equations

• LocallyConstant.instModule = Function.Injective.module R LocallyConstant.coeFnAddMonoidHom ⋯ ⋯

instance LocallyConstant.instAlgebra {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_5} [CommSemiring R] [Semiring Y] [Algebra R Y] : Algebra R (LocallyConstant X Y)

Equations

• LocallyConstant.instAlgebra = Algebra.mk (LocallyConstant.constRingHom.comp (algebraMap R Y)) ⋯ ⋯

@[simp]

theorem LocallyConstant.coe_algebraMap {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_5} [CommSemiring R] [Semiring Y] [Algebra R Y] (r : R) : ⇑((algebraMap R (LocallyConstant X Y)) r) = (algebraMap R (X → Y)) r

def LocallyConstant.coeFnRingHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Semiring Y] : LocallyConstant X Y →+* X → Y

DFunLike.coe as a RingHom.

Equations

• LocallyConstant.coeFnRingHom = { toMonoidHom := LocallyConstant.coeFnMonoidHom, map_zero' := ⋯, map_add' := ⋯ }

@[simp]

theorem LocallyConstant.coeFnRingHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Semiring Y] (a✝ : LocallyConstant X Y) (a : X) : LocallyConstant.coeFnRingHom a✝ a = a✝ a

def LocallyConstant.coeFnₗ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [Semiring R] [AddCommMonoid Y] [Module R Y] : LocallyConstant X Y →ₗ[R] X → Y

DFunLike.coe as a linear map.

Equations

• LocallyConstant.coeFnₗ R = { toAddHom := ↑LocallyConstant.coeFnAddMonoidHom, map_smul' := ⋯ }

@[simp]

theorem LocallyConstant.coeFnₗ_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [Semiring R] [AddCommMonoid Y] [Module R Y] (a✝ : LocallyConstant X Y) (a✝¹ : X) : (LocallyConstant.coeFnₗ R) a✝ a✝¹ = a✝ a✝¹

def LocallyConstant.coeFnAlgHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [CommSemiring R] [Semiring Y] [Algebra R Y] : LocallyConstant X Y →ₐ[R] X → Y

DFunLike.coe as an AlgHom.

Equations

• LocallyConstant.coeFnAlgHom R = { toRingHom := LocallyConstant.coeFnRingHom, commutes' := ⋯ }

@[simp]

theorem LocallyConstant.coeFnAlgHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [CommSemiring R] [Semiring Y] [Algebra R Y] (a✝ : LocallyConstant X Y) (a : X) : (LocallyConstant.coeFnAlgHom R) a✝ a = a✝ a

def LocallyConstant.evalMonoidHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [MulOneClass Y] (x : X) : LocallyConstant X Y →* Y

Evaluation as a MonoidHom

Equations

• LocallyConstant.evalMonoidHom x = (Pi.evalMonoidHom (fun (a : X) => Y) x).comp LocallyConstant.coeFnMonoidHom

def LocallyConstant.evalAddMonoidHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddZeroClass Y] (x : X) : LocallyConstant X Y →+ Y

Evaluation as an AddMonoidHom

Equations

• LocallyConstant.evalAddMonoidHom x = (Pi.evalAddMonoidHom (fun (a : X) => Y) x).comp LocallyConstant.coeFnAddMonoidHom

@[simp]

theorem LocallyConstant.evalAddMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddZeroClass Y] (x : X) (a✝ : LocallyConstant X Y) : (LocallyConstant.evalAddMonoidHom x) a✝ = a✝ x

@[simp]

theorem LocallyConstant.evalMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [MulOneClass Y] (x : X) (a✝ : LocallyConstant X Y) : (LocallyConstant.evalMonoidHom x) a✝ = a✝ x

def LocallyConstant.evalₗ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [Semiring R] [AddCommMonoid Y] [Module R Y] (x : X) : LocallyConstant X Y →ₗ[R] Y

Evaluation as a linear map

Equations

• LocallyConstant.evalₗ R x = LinearMap.proj x ∘ₗ LocallyConstant.coeFnₗ R

@[simp]

theorem LocallyConstant.evalₗ_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [Semiring R] [AddCommMonoid Y] [Module R Y] (x : X) (a✝ : LocallyConstant X Y) : (LocallyConstant.evalₗ R x) a✝ = a✝ x

def LocallyConstant.evalRingHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Semiring Y] (x : X) : LocallyConstant X Y →+* Y

Evaluation as a RingHom

Equations

• LocallyConstant.evalRingHom x = (Pi.evalRingHom (fun (a : X) => Y) x).comp LocallyConstant.coeFnRingHom

@[simp]

theorem LocallyConstant.evalRingHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Semiring Y] (x : X) (a✝ : LocallyConstant X Y) : (LocallyConstant.evalRingHom x) a✝ = a✝ x

def LocallyConstant.evalₐ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [CommSemiring R] [Semiring Y] [Algebra R Y] (x : X) : LocallyConstant X Y →ₐ[R] Y

Evaluation as an AlgHom

Equations

• LocallyConstant.evalₐ R x = (Pi.evalAlgHom R (fun (a : X) => Y) x).comp (LocallyConstant.coeFnAlgHom R)

@[simp]

theorem LocallyConstant.evalₐ_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [CommSemiring R] [Semiring Y] [Algebra R Y] (x : X) (a✝ : LocallyConstant X Y) : (LocallyConstant.evalₐ R x) a✝ = a✝ x

def LocallyConstant.comapMonoidHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} [MulOneClass Z] (f : C(X, Y)) : LocallyConstant Y Z →* LocallyConstant X Z

LocallyConstant.comap as a MonoidHom.

Equations

• LocallyConstant.comapMonoidHom f = { toFun := LocallyConstant.comap f, map_one' := ⋯, map_mul' := ⋯ }

def LocallyConstant.comapAddMonoidHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} [AddZeroClass Z] (f : C(X, Y)) : LocallyConstant Y Z →+ LocallyConstant X Z

LocallyConstant.comap as an AddMonoidHom.

Equations

• LocallyConstant.comapAddMonoidHom f = { toFun := LocallyConstant.comap f, map_zero' := ⋯, map_add' := ⋯ }

@[simp]

theorem LocallyConstant.comapAddMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} [AddZeroClass Z] (f : C(X, Y)) (g : LocallyConstant Y Z) : (LocallyConstant.comapAddMonoidHom f) g = LocallyConstant.comap f g

@[simp]

theorem LocallyConstant.comapMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} [MulOneClass Z] (f : C(X, Y)) (g : LocallyConstant Y Z) : (LocallyConstant.comapMonoidHom f) g = LocallyConstant.comap f g

def LocallyConstant.comapₗ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} (R : Type u_7) [Semiring R] [AddCommMonoid Z] [Module R Z] (f : C(X, Y)) : LocallyConstant Y Z →ₗ[R] LocallyConstant X Z

LocallyConstant.comap as a linear map.

Equations

• LocallyConstant.comapₗ R f = { toFun := LocallyConstant.comap f, map_add' := ⋯, map_smul' := ⋯ }

@[simp]

theorem LocallyConstant.comapₗ_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} (R : Type u_7) [Semiring R] [AddCommMonoid Z] [Module R Z] (f : C(X, Y)) (g : LocallyConstant Y Z) (a✝ : X) : ((LocallyConstant.comapₗ R f) g) a✝ = g (f a✝)

def LocallyConstant.comapRingHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} [Semiring Z] (f : C(X, Y)) : LocallyConstant Y Z →+* LocallyConstant X Z

LocallyConstant.comap as a RingHom.

Equations

• LocallyConstant.comapRingHom f = { toMonoidHom := LocallyConstant.comapMonoidHom f, map_zero' := ⋯, map_add' := ⋯ }

@[simp]

theorem LocallyConstant.comapRingHom_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} [Semiring Z] (f : C(X, Y)) (g : LocallyConstant Y Z) (a✝ : X) : ((LocallyConstant.comapRingHom f) g) a✝ = g (f a✝)

def LocallyConstant.comapₐ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} (R : Type u_7) [CommSemiring R] [Semiring Z] [Algebra R Z] (f : C(X, Y)) : LocallyConstant Y Z →ₐ[R] LocallyConstant X Z

LocallyConstant.comap as an AlgHom

Equations

• LocallyConstant.comapₐ R f = { toRingHom := LocallyConstant.comapRingHom f, commutes' := ⋯ }

@[simp]

theorem LocallyConstant.comapₐ_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} (R : Type u_7) [CommSemiring R] [Semiring Z] [Algebra R Z] (f : C(X, Y)) (g : LocallyConstant Y Z) (a✝ : X) : ((LocallyConstant.comapₐ R f) g) a✝ = g (f a✝)

theorem LocallyConstant.ker_comapₗ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_5} [TopologicalSpace Y] {Z : Type u_6} [Semiring R] [AddCommMonoid Z] [Module R Z] (f : C(X, Y)) (hfs : Function.Surjective ⇑f) : LinearMap.ker (LocallyConstant.comapₗ R f) = ⊥

def LocallyConstant.congrLeftₗ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} (R : Type u_7) [Semiring R] [AddCommMonoid Z] [Module R Z] (e : X ≃ₜ Y) : LocallyConstant X Z ≃ₗ[R] LocallyConstant Y Z

LocallyConstant.congrLeft as a linear equivalence.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem LocallyConstant.congrLeftₗ_symm_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} (R : Type u_7) [Semiring R] [AddCommMonoid Z] [Module R Z] (e : X ≃ₜ Y) (a✝ : LocallyConstant Y Z) (a✝¹ : X) : ((LocallyConstant.congrLeftₗ R e).symm a✝) a✝¹ = a✝ (e a✝¹)

@[simp]

theorem LocallyConstant.congrLeftₗ_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} (R : Type u_7) [Semiring R] [AddCommMonoid Z] [Module R Z] (e : X ≃ₜ Y) (g : LocallyConstant X Z) (a✝ : Y) : ((LocallyConstant.congrLeftₗ R e) g) a✝ = g (e.symm a✝)

def LocallyConstant.congrLeftRingEquiv {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} [Semiring Z] (e : X ≃ₜ Y) : LocallyConstant X Z ≃+* LocallyConstant Y Z

LocallyConstant.congrLeft as a RingEquiv.

Equations

• LocallyConstant.congrLeftRingEquiv e = { toEquiv := LocallyConstant.congrLeft e, map_mul' := ⋯, map_add' := ⋯ }

@[simp]

theorem LocallyConstant.congrLeftRingEquiv_symm_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} [Semiring Z] (e : X ≃ₜ Y) (g : LocallyConstant Y Z) (a✝ : X) : ((LocallyConstant.congrLeftRingEquiv e).symm g) a✝ = g (e a✝)

@[simp]

theorem LocallyConstant.congrLeftRingEquiv_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} [Semiring Z] (e : X ≃ₜ Y) (g : LocallyConstant X Z) (a✝ : Y) : ((LocallyConstant.congrLeftRingEquiv e) g) a✝ = g (e.symm a✝)

def LocallyConstant.congrLeftₐ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} (R : Type u_7) [CommSemiring R] [Semiring Z] [Algebra R Z] (e : X ≃ₜ Y) : LocallyConstant X Z ≃ₐ[R] LocallyConstant Y Z

LocallyConstant.congrLeft as an AlgEquiv.

Equations

• LocallyConstant.congrLeftₐ R e = { toEquiv := LocallyConstant.congrLeft e, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ }

@[simp]

theorem LocallyConstant.congrLeftₐ_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} (R : Type u_7) [CommSemiring R] [Semiring Z] [Algebra R Z] (e : X ≃ₜ Y) (g : LocallyConstant X Z) (a✝ : Y) : ((LocallyConstant.congrLeftₐ R e) g) a✝ = g (e.symm a✝)

@[simp]

theorem LocallyConstant.congrLeftₐ_symm_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {Z : Type u_6} (R : Type u_7) [CommSemiring R] [Semiring Z] [Algebra R Z] (e : X ≃ₜ Y) (g : LocallyConstant Y Z) (a✝ : X) : ((LocallyConstant.congrLeftₐ R e).symm g) a✝ = g (e a✝)

def LocallyConstant.mapMonoidHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} [MulOneClass Y] [MulOneClass Z] (f : Y →* Z) : LocallyConstant X Y →* LocallyConstant X Z

LocallyConstant.map as a MonoidHom.

Equations

• LocallyConstant.mapMonoidHom f = { toFun := LocallyConstant.map ⇑f, map_one' := ⋯, map_mul' := ⋯ }

def LocallyConstant.mapAddMonoidHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} [AddZeroClass Y] [AddZeroClass Z] (f : Y →+ Z) : LocallyConstant X Y →+ LocallyConstant X Z

LocallyConstant.map as an AddMonoidHom.

Equations

• LocallyConstant.mapAddMonoidHom f = { toFun := LocallyConstant.map ⇑f, map_zero' := ⋯, map_add' := ⋯ }

@[simp]

theorem LocallyConstant.mapAddMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} [AddZeroClass Y] [AddZeroClass Z] (f : Y →+ Z) (g : LocallyConstant X Y) : (LocallyConstant.mapAddMonoidHom f) g = LocallyConstant.map (⇑f) g

@[simp]

theorem LocallyConstant.mapMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} [MulOneClass Y] [MulOneClass Z] (f : Y →* Z) (g : LocallyConstant X Y) : (LocallyConstant.mapMonoidHom f) g = LocallyConstant.map (⇑f) g

def LocallyConstant.mapₗ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} (R : Type u_7) [Semiring R] [AddCommMonoid Y] [Module R Y] [AddCommMonoid Z] [Module R Z] (f : Y →ₗ[R] Z) : LocallyConstant X Y →ₗ[R] LocallyConstant X Z

LocallyConstant.map as a linear map.

Equations

• LocallyConstant.mapₗ R f = { toFun := LocallyConstant.map ⇑f, map_add' := ⋯, map_smul' := ⋯ }

@[simp]

theorem LocallyConstant.mapₗ_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} (R : Type u_7) [Semiring R] [AddCommMonoid Y] [Module R Y] [AddCommMonoid Z] [Module R Z] (f : Y →ₗ[R] Z) (g : LocallyConstant X Y) (a✝ : X) : ((LocallyConstant.mapₗ R f) g) a✝ = f (g a✝)

def LocallyConstant.mapRingHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} [Semiring Y] [Semiring Z] (f : Y →+* Z) : LocallyConstant X Y →+* LocallyConstant X Z

LocallyConstant.map as a RingHom.

Equations

• LocallyConstant.mapRingHom f = { toMonoidHom := LocallyConstant.mapMonoidHom ↑f, map_zero' := ⋯, map_add' := ⋯ }

@[simp]

theorem LocallyConstant.mapRingHom_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} [Semiring Y] [Semiring Z] (f : Y →+* Z) (g : LocallyConstant X Y) (a✝ : X) : ((LocallyConstant.mapRingHom f) g) a✝ = f (g a✝)

def LocallyConstant.mapₐ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} (R : Type u_7) [CommSemiring R] [Semiring Y] [Algebra R Y] [Semiring Z] [Algebra R Z] (f : Y →ₐ[R] Z) : LocallyConstant X Y →ₐ[R] LocallyConstant X Z

LocallyConstant.map as an AlgHom

Equations

• LocallyConstant.mapₐ R f = { toRingHom := LocallyConstant.mapRingHom ↑f, commutes' := ⋯ }

@[simp]

theorem LocallyConstant.mapₐ_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} (R : Type u_7) [CommSemiring R] [Semiring Y] [Algebra R Y] [Semiring Z] [Algebra R Z] (f : Y →ₐ[R] Z) (g : LocallyConstant X Y) (a✝ : X) : ((LocallyConstant.mapₐ R f) g) a✝ = f (g a✝)

def LocallyConstant.congrRightₗ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} (R : Type u_7) [Semiring R] [AddCommMonoid Y] [Module R Y] [AddCommMonoid Z] [Module R Z] (e : Y ≃ₗ[R] Z) : LocallyConstant X Y ≃ₗ[R] LocallyConstant X Z

LocallyConstant.congrRight as a linear equivalence.

Equations

• LocallyConstant.congrRightₗ R e = { toLinearMap := LocallyConstant.mapₗ R ↑e, invFun := (LocallyConstant.congrRight e.toEquiv).invFun, left_inv := ⋯, right_inv := ⋯ }

@[simp]

theorem LocallyConstant.congrRightₗ_symm_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} (R : Type u_7) [Semiring R] [AddCommMonoid Y] [Module R Y] [AddCommMonoid Z] [Module R Z] (e : Y ≃ₗ[R] Z) (a✝ : LocallyConstant X Z) (a✝¹ : X) : ((LocallyConstant.congrRightₗ R e).symm a✝) a✝¹ = e.symm (a✝ a✝¹)

@[simp]

theorem LocallyConstant.congrRightₗ_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} (R : Type u_7) [Semiring R] [AddCommMonoid Y] [Module R Y] [AddCommMonoid Z] [Module R Z] (e : Y ≃ₗ[R] Z) (g : LocallyConstant X Y) (a✝ : X) : ((LocallyConstant.congrRightₗ R e) g) a✝ = e (g a✝)

def LocallyConstant.congrRightRingEquiv {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} [Semiring Y] [Semiring Z] (e : Y ≃+* Z) : LocallyConstant X Y ≃+* LocallyConstant X Z

LocallyConstant.congrRight as a RingEquiv.

Equations

• LocallyConstant.congrRightRingEquiv e = { toEquiv := LocallyConstant.congrRight ↑e, map_mul' := ⋯, map_add' := ⋯ }

@[simp]

theorem LocallyConstant.congrRightRingEquiv_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} [Semiring Y] [Semiring Z] (e : Y ≃+* Z) (g : LocallyConstant X Y) (a✝ : X) : ((LocallyConstant.congrRightRingEquiv e) g) a✝ = e (g a✝)

@[simp]

theorem LocallyConstant.congrRightRingEquiv_symm_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} [Semiring Y] [Semiring Z] (e : Y ≃+* Z) (g : LocallyConstant X Z) (a✝ : X) : ((LocallyConstant.congrRightRingEquiv e).symm g) a✝ = (↑e).symm (g a✝)

def LocallyConstant.congrRightₐ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} (R : Type u_7) [CommSemiring R] [Semiring Y] [Algebra R Y] [Semiring Z] [Algebra R Z] (e : Y ≃ₐ[R] Z) : LocallyConstant X Y ≃ₐ[R] LocallyConstant X Z

LocallyConstant.congrRight as an AlgEquiv.

Equations

• LocallyConstant.congrRightₐ R e = { toEquiv := LocallyConstant.congrRight ↑e, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ }

@[simp]

theorem LocallyConstant.congrRightₐ_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} (R : Type u_7) [CommSemiring R] [Semiring Y] [Algebra R Y] [Semiring Z] [Algebra R Z] (e : Y ≃ₐ[R] Z) (g : LocallyConstant X Y) (a✝ : X) : ((LocallyConstant.congrRightₐ R e) g) a✝ = e (g a✝)

@[simp]

theorem LocallyConstant.congrRightₐ_symm_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {Z : Type u_6} (R : Type u_7) [CommSemiring R] [Semiring Y] [Algebra R Y] [Semiring Z] [Algebra R Z] (e : Y ≃ₐ[R] Z) (g : LocallyConstant X Z) (a✝ : X) : ((LocallyConstant.congrRightₐ R e).symm g) a✝ = e.symm (g a✝)

def LocallyConstant.constₗ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [Semiring R] [AddCommMonoid Y] [Module R Y] : Y →ₗ[R] LocallyConstant X Y

LocallyConstant.const as a linear map.

Equations

• LocallyConstant.constₗ R = { toFun := LocallyConstant.const X, map_add' := ⋯, map_smul' := ⋯ }

@[simp]

theorem LocallyConstant.constₗ_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [Semiring R] [AddCommMonoid Y] [Module R Y] (y : Y) (a✝ : X) : ((LocallyConstant.constₗ R) y) a✝ = y

def LocallyConstant.constₐ {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [CommSemiring R] [Semiring Y] [Algebra R Y] : Y →ₐ[R] LocallyConstant X Y

LocallyConstant.const as an AlgHom

Equations

• LocallyConstant.constₐ R = { toRingHom := LocallyConstant.constRingHom, commutes' := ⋯ }

@[simp]

theorem LocallyConstant.constₐ_apply_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] (R : Type u_6) [CommSemiring R] [Semiring Y] [Algebra R Y] (y : Y) (a✝ : X) : ((LocallyConstant.constₐ R) y) a✝ = y