Documentation

Mathlib.Topology.LocallyConstant.Algebra

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] :
Equations
    instance LocallyConstant.instZero {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Zero Y] :
    Equations
      @[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] :
      Equations
        instance LocallyConstant.instNeg {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Neg Y] :
        Equations
          @[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] :
          Equations
            instance LocallyConstant.instAdd {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Add Y] :
            Equations
              @[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

              DFunLike.coe as a MonoidHom.

              Equations
                Instances For

                  DFunLike.coe as an AddMonoidHom.

                  Equations
                    Instances For
                      @[simp]
                      theorem LocallyConstant.coeFnMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [MulOneClass Y] (a✝ : LocallyConstant X Y) (a : X) :
                      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) :
                      coeFnAddMonoidHom a✝ a = a✝ a

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

                      Equations
                        Instances For

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

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

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

                              Equations
                                Instances For
                                  theorem LocallyConstant.coe_charFn {X : Type u_1} (Y : Type u_2) [TopologicalSpace X] [MulZeroOneClass Y] {U : Set X} (hU : IsClopen U) :
                                  (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) :
                                  (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) :
                                  (charFn Y hU) x = 0 xU
                                  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 : charFn Y hU = charFn Y hV) :
                                  U = V
                                  instance LocallyConstant.instDiv {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Div Y] :
                                  Equations
                                    instance LocallyConstant.instSub {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Sub Y] :
                                    Equations
                                      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.smul {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {α : Type u_3} [SMul α Y] :
                                      Equations
                                        instance LocallyConstant.vadd {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {α : Type u_3} [VAdd α Y] :
                                        Equations
                                          @[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 α] :
                                          Equations
                                            Equations
                                              Equations
                                                Equations
                                                  instance LocallyConstant.instGroup {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Group Y] :
                                                  Equations
                                                    Equations

                                                      The constant-function embedding, as a ring hom.

                                                      Equations
                                                        Instances For
                                                          @[simp]
                                                          instance LocallyConstant.instRing {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Ring Y] :
                                                          Equations
                                                            instance LocallyConstant.instMulAction {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_5} [Monoid R] [MulAction R Y] :
                                                            Equations
                                                              instance LocallyConstant.instModule {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_5} [Semiring R] [AddCommMonoid Y] [Module R Y] :
                                                              Equations
                                                                instance LocallyConstant.instAlgebra {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {R : Type u_5} [CommSemiring R] [Semiring Y] [Algebra R Y] :
                                                                Equations
                                                                  @[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 (XY)) r

                                                                  DFunLike.coe as a RingHom.

                                                                  Equations
                                                                    Instances For
                                                                      @[simp]
                                                                      theorem LocallyConstant.coeFnRingHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Semiring Y] (a✝ : LocallyConstant X Y) (a : X) :
                                                                      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] :

                                                                      DFunLike.coe as a linear map.

                                                                      Equations
                                                                        Instances For
                                                                          @[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) :
                                                                          (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] :

                                                                          DFunLike.coe as an AlgHom.

                                                                          Equations
                                                                            Instances For
                                                                              @[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) :
                                                                              (coeFnAlgHom R) a✝ a = a✝ a

                                                                              Evaluation as a MonoidHom

                                                                              Equations
                                                                                Instances For

                                                                                  Evaluation as an AddMonoidHom

                                                                                  Equations
                                                                                    Instances For
                                                                                      @[simp]
                                                                                      theorem LocallyConstant.evalAddMonoidHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [AddZeroClass Y] (x : X) (a✝ : LocallyConstant X Y) :
                                                                                      (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) :
                                                                                      (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) :

                                                                                      Evaluation as a linear map

                                                                                      Equations
                                                                                        Instances For
                                                                                          @[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) :
                                                                                          (evalₗ R x) a✝ = a✝ x
                                                                                          def LocallyConstant.evalRingHom {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Semiring Y] (x : X) :

                                                                                          Evaluation as a RingHom

                                                                                          Equations
                                                                                            Instances For
                                                                                              @[simp]
                                                                                              theorem LocallyConstant.evalRingHom_apply {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [Semiring Y] (x : X) (a✝ : LocallyConstant X Y) :
                                                                                              (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) :

                                                                                              Evaluation as an AlgHom

                                                                                              Equations
                                                                                                Instances For
                                                                                                  @[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) :
                                                                                                  (evalₐ R x) a✝ = a✝ x
                                                                                                  @[simp]
                                                                                                  @[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) :
                                                                                                  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.comap as a linear map.

                                                                                                  Equations
                                                                                                    Instances For
                                                                                                      @[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) :
                                                                                                      ((comapₗ R f) g) a✝ = g (f a✝)

                                                                                                      LocallyConstant.comap as a RingHom.

                                                                                                      Equations
                                                                                                        Instances For
                                                                                                          @[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) :
                                                                                                          ((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.comap as an AlgHom

                                                                                                          Equations
                                                                                                            Instances For
                                                                                                              @[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) :
                                                                                                              ((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) :
                                                                                                              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.congrLeft as a linear equivalence.

                                                                                                              Equations
                                                                                                                Instances For
                                                                                                                  @[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) :
                                                                                                                  ((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) :
                                                                                                                  ((congrLeftₗ R e) g) a✝ = g (e.symm a✝)
                                                                                                                  @[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) :
                                                                                                                  ((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) :
                                                                                                                  ((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.congrLeft as an AlgEquiv.

                                                                                                                  Equations
                                                                                                                    Instances For
                                                                                                                      @[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) :
                                                                                                                      ((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) :
                                                                                                                      ((congrLeftₐ R e).symm g) a✝ = g (e a✝)

                                                                                                                      LocallyConstant.map as a MonoidHom.

                                                                                                                      Equations
                                                                                                                        Instances For
                                                                                                                          @[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) :
                                                                                                                          (mapAddMonoidHom f) g = 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) :
                                                                                                                          (mapMonoidHom f) g = 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.map as a linear map.

                                                                                                                          Equations
                                                                                                                            Instances For
                                                                                                                              @[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) :
                                                                                                                              ((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.map as a RingHom.

                                                                                                                              Equations
                                                                                                                                Instances For
                                                                                                                                  @[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) :
                                                                                                                                  ((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.map as an AlgHom

                                                                                                                                  Equations
                                                                                                                                    Instances For
                                                                                                                                      @[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) :
                                                                                                                                      ((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.congrRight as a linear equivalence.

                                                                                                                                      Equations
                                                                                                                                        Instances For
                                                                                                                                          @[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) :
                                                                                                                                          ((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) :
                                                                                                                                          ((congrRightₗ R e) g) a✝ = e (g a✝)
                                                                                                                                          @[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) :
                                                                                                                                          ((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) :
                                                                                                                                          ((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.congrRight as an AlgEquiv.

                                                                                                                                          Equations
                                                                                                                                            Instances For
                                                                                                                                              @[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) :
                                                                                                                                              ((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) :
                                                                                                                                              ((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] :

                                                                                                                                              LocallyConstant.const as a linear map.

                                                                                                                                              Equations
                                                                                                                                                Instances For
                                                                                                                                                  @[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) :
                                                                                                                                                  ((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] :

                                                                                                                                                  LocallyConstant.const as an AlgHom

                                                                                                                                                  Equations
                                                                                                                                                    Instances For
                                                                                                                                                      @[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) :
                                                                                                                                                      ((constₐ R) y) a✝ = y