File: Mathlib/Topology/LocallyConstant/Algebra.lean

full_name: LocallyConstant.instZero
code: @[to_additive]
instance [One Y] : One (LocallyConstant X Y) 
goal: Zero (LocallyConstant X Y)

full_name: LocallyConstant.instOne
code: @[to_additive]
instance [One Y] : One (LocallyConstant X Y) 
goal: One (LocallyConstant X Y)

full_name: LocallyConstant.coe_zero
code: @[to_additive (attr := simp)]
theorem coe_one [One Y] : ⇑(1 : LocallyConstant X Y) = (1 : X → Y) 
goal: ⇑0 = 0

full_name: LocallyConstant.coe_one
code: @[to_additive (attr := simp)]
theorem coe_one [One Y] : ⇑(1 : LocallyConstant X Y) = (1 : X → Y) 
goal: ⇑1 = 1

full_name: LocallyConstant.zero_apply
code: @[to_additive]
theorem one_apply [One Y] (x : X) : (1 : LocallyConstant X Y) x = 1 
goal: 0 x = 0

full_name: LocallyConstant.one_apply
code: @[to_additive]
theorem one_apply [One Y] (x : X) : (1 : LocallyConstant X Y) x = 1 
goal: 1 x = 1

full_name: LocallyConstant.instNeg
code: @[to_additive]
instance [Inv Y] : Inv (LocallyConstant X Y) 
goal: Neg (LocallyConstant X Y)

full_name: LocallyConstant.instInv
code: @[to_additive]
instance [Inv Y] : Inv (LocallyConstant X Y) 
goal: Inv (LocallyConstant X Y)

full_name: LocallyConstant.coe_neg
code: @[to_additive (attr := simp)]
theorem coe_inv [Inv Y] (f : LocallyConstant X Y) : ⇑(f⁻¹ : LocallyConstant X Y) = (f : X → Y)⁻¹ 
goal: ⇑(-f) = -⇑f

full_name: LocallyConstant.coe_inv
code: @[to_additive (attr := simp)]
theorem coe_inv [Inv Y] (f : LocallyConstant X Y) : ⇑(f⁻¹ : LocallyConstant X Y) = (f : X → Y)⁻¹ 
goal: ⇑f⁻¹ = (⇑f)⁻¹

full_name: LocallyConstant.neg_apply
code: @[to_additive]
theorem inv_apply [Inv Y] (f : LocallyConstant X Y) (x : X) : f⁻¹ x = (f x)⁻¹ 
goal: (-f) x = -f x

full_name: LocallyConstant.inv_apply
code: @[to_additive]
theorem inv_apply [Inv Y] (f : LocallyConstant X Y) (x : X) : f⁻¹ x = (f x)⁻¹ 
goal: f⁻¹ x = (f x)⁻¹

full_name: LocallyConstant.instAdd
code: @[to_additive]
instance [Mul Y] : Mul (LocallyConstant X Y) 
goal: Add (LocallyConstant X Y)

full_name: LocallyConstant.instMul
code: @[to_additive]
instance [Mul Y] : Mul (LocallyConstant X Y) 
goal: Mul (LocallyConstant X Y)

full_name: LocallyConstant.coe_add
code: @[to_additive (attr := simp)]
theorem coe_mul [Mul Y] (f g : LocallyConstant X Y) : ⇑(f * g) = f * g 
goal: ⇑(f + g) = ⇑f + ⇑g

full_name: LocallyConstant.coe_mul
code: @[to_additive (attr := simp)]
theorem coe_mul [Mul Y] (f g : LocallyConstant X Y) : ⇑(f * g) = f * g 
goal: ⇑(f * g) = ⇑f * ⇑g

full_name: LocallyConstant.mul_apply
code: @[to_additive]
theorem mul_apply [Mul Y] (f g : LocallyConstant X Y) (x : X) : (f * g) x = f x * g x 
goal: (f * g) x = f x * g x

full_name: LocallyConstant.add_apply
code: @[to_additive]
theorem mul_apply [Mul Y] (f g : LocallyConstant X Y) (x : X) : (f * g) x = f x * g x 
goal: (f + g) x = f x + g x

full_name: LocallyConstant.instAddZeroClass
code: @[to_additive]
instance [MulOneClass Y] : MulOneClass (LocallyConstant X Y) 
goal: AddZeroClass (LocallyConstant X Y)

full_name: LocallyConstant.instMulOneClass
code: @[to_additive]
instance [MulOneClass Y] : MulOneClass (LocallyConstant X Y) 
goal: MulOneClass (LocallyConstant X Y)

full_name: LocallyConstant.coeFnMonoidHom_apply
code: /-- `DFunLike.coe` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`DFunLike.coe` as an `AddMonoidHom`."]
def coeFnMonoidHom [MulOneClass Y] : LocallyConstant X Y →* X → Y 
goal: ∀ (a : LocallyConstant X Y) (a_1 : X), LocallyConstant.coeFnMonoidHom a a_1 = a a_1

full_name: LocallyConstant.coeFnAddMonoidHom_apply
code: /-- `DFunLike.coe` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`DFunLike.coe` as an `AddMonoidHom`."]
def coeFnMonoidHom [MulOneClass Y] : LocallyConstant X Y →* X → Y 
goal: ∀ (a : LocallyConstant X Y) (a_1 : X), LocallyConstant.coeFnAddMonoidHom a a_1 = a a_1

full_name: LocallyConstant.coeFnMonoidHom
code: /-- `DFunLike.coe` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`DFunLike.coe` as an `AddMonoidHom`."]
def coeFnMonoidHom [MulOneClass Y] : LocallyConstant X Y →* X → Y 
goal: LocallyConstant X Y →* X → Y

full_name: LocallyConstant.coeFnAddMonoidHom
code: /-- `DFunLike.coe` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`DFunLike.coe` as an `AddMonoidHom`."]
def coeFnMonoidHom [MulOneClass Y] : LocallyConstant X Y →* X → Y 
goal: LocallyConstant X Y →+ X → Y

full_name: LocallyConstant.constMonoidHom_apply
code: /-- The constant-function embedding, as a multiplicative monoid hom. -/
@[to_additive (attr := simps) "The constant-function embedding, as an additive monoid hom."]
def constMonoidHom [MulOneClass Y] : Y →* LocallyConstant X Y 
goal: LocallyConstant.constMonoidHom y = LocallyConstant.const X y

full_name: LocallyConstant.constAddMonoidHom
code: /-- The constant-function embedding, as a multiplicative monoid hom. -/
@[to_additive (attr := simps) "The constant-function embedding, as an additive monoid hom."]
def constMonoidHom [MulOneClass Y] : Y →* LocallyConstant X Y 
goal: Y →+ LocallyConstant X Y

full_name: LocallyConstant.constMonoidHom
code: /-- The constant-function embedding, as a multiplicative monoid hom. -/
@[to_additive (attr := simps) "The constant-function embedding, as an additive monoid hom."]
def constMonoidHom [MulOneClass Y] : Y →* LocallyConstant X Y 
goal: Y →* LocallyConstant X Y

full_name: LocallyConstant.constAddMonoidHom_apply
code: /-- The constant-function embedding, as a multiplicative monoid hom. -/
@[to_additive (attr := simps) "The constant-function embedding, as an additive monoid hom."]
def constMonoidHom [MulOneClass Y] : Y →* LocallyConstant X Y 
goal: LocallyConstant.constAddMonoidHom y = LocallyConstant.const X y

full_name: LocallyConstant.instMulZeroClass
code: instance [MulZeroClass Y] : MulZeroClass (LocallyConstant X Y) 
goal: MulZeroClass (LocallyConstant X Y)

full_name: LocallyConstant.instMulZeroOneClass
code: instance [MulZeroOneClass Y] : MulZeroOneClass (LocallyConstant X Y) 
goal: MulZeroOneClass (LocallyConstant X Y)

full_name: LocallyConstant.charFn
code: /-- Characteristic functions are locally constant functions taking `x : X` to `1` if `x ∈ U`,
  where `U` is a clopen set, and `0` otherwise. -/
noncomputable def charFn (hU : IsClopen U) : LocallyConstant X Y 
goal: LocallyConstant X Y

full_name: LocallyConstant.coe_charFn
code: theorem coe_charFn (hU : IsClopen U) : (charFn Y hU : X → Y) = Set.indicator U 1 
goal: ⇑(LocallyConstant.charFn Y hU) = U.indicator 1

full_name: LocallyConstant.charFn_eq_one
code: theorem charFn_eq_one [Nontrivial Y] (x : X) (hU : IsClopen U) : charFn Y hU x = (1 : Y) ↔ x ∈ U 
goal: (LocallyConstant.charFn Y hU) x = 1 ↔ x ∈ U

full_name: LocallyConstant.charFn_eq_zero
code: theorem charFn_eq_zero [Nontrivial Y] (x : X) (hU : IsClopen U) : charFn Y hU x = (0 : Y) ↔ x ∉ U 
goal: (LocallyConstant.charFn Y hU) x = 0 ↔ x ∉ U

full_name: LocallyConstant.charFn_inj
code: theorem charFn_inj [Nontrivial Y] (hU : IsClopen U) (hV : IsClopen V)
    (h : charFn Y hU = charFn Y hV) : U = V 
goal: U = V

full_name: LocallyConstant.instSub
code: @[to_additive]
instance [Div Y] : Div (LocallyConstant X Y) 
goal: Sub (LocallyConstant X Y)

full_name: LocallyConstant.instDiv
code: @[to_additive]
instance [Div Y] : Div (LocallyConstant X Y) 
goal: Div (LocallyConstant X Y)

full_name: LocallyConstant.coe_div
code: @[to_additive]
theorem coe_div [Div Y] (f g : LocallyConstant X Y) : ⇑(f / g) = f / g 
goal: ⇑(f / g) = ⇑f / ⇑g

full_name: LocallyConstant.coe_sub
code: @[to_additive]
theorem coe_div [Div Y] (f g : LocallyConstant X Y) : ⇑(f / g) = f / g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: LocallyConstant.sub_apply
code: @[to_additive]
theorem div_apply [Div Y] (f g : LocallyConstant X Y) (x : X) : (f / g) x = f x / g x 
goal: (f - g) x = f x - g x

full_name: LocallyConstant.div_apply
code: @[to_additive]
theorem div_apply [Div Y] (f g : LocallyConstant X Y) (x : X) : (f / g) x = f x / g x 
goal: (f / g) x = f x / g x

full_name: LocallyConstant.instSemigroup
code: @[to_additive]
instance [Semigroup Y] : Semigroup (LocallyConstant X Y) 
goal: Semigroup (LocallyConstant X Y)

full_name: LocallyConstant.instAddSemigroup
code: @[to_additive]
instance [Semigroup Y] : Semigroup (LocallyConstant X Y) 
goal: AddSemigroup (LocallyConstant X Y)

full_name: LocallyConstant.instSemigroupWithZero
code: instance [SemigroupWithZero Y] : SemigroupWithZero (LocallyConstant X Y) 
goal: SemigroupWithZero (LocallyConstant X Y)

full_name: LocallyConstant.instCommSemigroup
code: @[to_additive]
instance [CommSemigroup Y] : CommSemigroup (LocallyConstant X Y) 
goal: CommSemigroup (LocallyConstant X Y)

full_name: LocallyConstant.instAddCommSemigroup
code: @[to_additive]
instance [CommSemigroup Y] : CommSemigroup (LocallyConstant X Y) 
goal: AddCommSemigroup (LocallyConstant X Y)

full_name: LocallyConstant.smul
code: @[to_additive]
instance smul [SMul α Y] : SMul α (LocallyConstant X Y) 
goal: SMul α (LocallyConstant X Y)

full_name: LocallyConstant.vadd
code: @[to_additive]
instance smul [SMul α Y] : SMul α (LocallyConstant X Y) 
goal: VAdd α (LocallyConstant X Y)

full_name: LocallyConstant.coe_smul
code: @[to_additive (attr := simp)]
theorem coe_smul [SMul R Y] (r : R) (f : LocallyConstant X Y) : ⇑(r • f) = r • (f : X → Y) 
goal: ⇑(r • f) = r • ⇑f

full_name: LocallyConstant.coe_vadd
code: @[to_additive (attr := simp)]
theorem coe_smul [SMul R Y] (r : R) (f : LocallyConstant X Y) : ⇑(r • f) = r • (f : X → Y) 
goal: ⇑(r +ᵥ f) = r +ᵥ ⇑f

full_name: LocallyConstant.vadd_apply
code: @[to_additive]
theorem smul_apply [SMul R Y] (r : R) (f : LocallyConstant X Y) (x : X) : (r • f) x = r • f x 
goal: (r +ᵥ f) x = r +ᵥ f x

full_name: LocallyConstant.smul_apply
code: @[to_additive]
theorem smul_apply [SMul R Y] (r : R) (f : LocallyConstant X Y) (x : X) : (r • f) x = r • f x 
goal: (r • f) x = r • f x

full_name: LocallyConstant.instPow
code: @[to_additive existing LocallyConstant.smul]
instance [Pow Y α] : Pow (LocallyConstant X Y) α 
goal: Pow (LocallyConstant X Y) α

full_name: LocallyConstant.instMonoid
code: @[to_additive]
instance [Monoid Y] : Monoid (LocallyConstant X Y) 
goal: Monoid (LocallyConstant X Y)

full_name: LocallyConstant.instAddMonoid
code: @[to_additive]
instance [Monoid Y] : Monoid (LocallyConstant X Y) 
goal: AddMonoid (LocallyConstant X Y)

full_name: LocallyConstant.instNatCast
code: instance [NatCast Y] : NatCast (LocallyConstant X Y) 
goal: NatCast (LocallyConstant X Y)

full_name: LocallyConstant.instIntCast
code: instance [IntCast Y] : IntCast (LocallyConstant X Y) 
goal: IntCast (LocallyConstant X Y)

full_name: LocallyConstant.instAddMonoidWithOne
code: instance [AddMonoidWithOne Y] : AddMonoidWithOne (LocallyConstant X Y) 
goal: AddMonoidWithOne (LocallyConstant X Y)

full_name: LocallyConstant.instCommMonoid
code: @[to_additive]
instance [CommMonoid Y] : CommMonoid (LocallyConstant X Y) 
goal: CommMonoid (LocallyConstant X Y)

full_name: LocallyConstant.instAddCommMonoid
code: @[to_additive]
instance [CommMonoid Y] : CommMonoid (LocallyConstant X Y) 
goal: AddCommMonoid (LocallyConstant X Y)

full_name: LocallyConstant.instAddGroup
code: @[to_additive]
instance [Group Y] : Group (LocallyConstant X Y) 
goal: AddGroup (LocallyConstant X Y)

full_name: LocallyConstant.instGroup
code: @[to_additive]
instance [Group Y] : Group (LocallyConstant X Y) 
goal: Group (LocallyConstant X Y)

full_name: LocallyConstant.instCommGroup
code: @[to_additive]
instance [CommGroup Y] : CommGroup (LocallyConstant X Y) 
goal: CommGroup (LocallyConstant X Y)

full_name: LocallyConstant.instAddCommGroup
code: @[to_additive]
instance [CommGroup Y] : CommGroup (LocallyConstant X Y) 
goal: AddCommGroup (LocallyConstant X Y)

full_name: LocallyConstant.instDistrib
code: instance [Distrib Y] : Distrib (LocallyConstant X Y) 
goal: Distrib (LocallyConstant X Y)

full_name: LocallyConstant.instNonUnitalNonAssocSemiring
code: instance [NonUnitalNonAssocSemiring Y] : NonUnitalNonAssocSemiring (LocallyConstant X Y) 
goal: NonUnitalNonAssocSemiring (LocallyConstant X Y)

full_name: LocallyConstant.instNonUnitalSemiring
code: instance [NonUnitalSemiring Y] : NonUnitalSemiring (LocallyConstant X Y) 
goal: NonUnitalSemiring (LocallyConstant X Y)

full_name: LocallyConstant.instNonAssocSemiring
code: instance [NonAssocSemiring Y] : NonAssocSemiring (LocallyConstant X Y) 
goal: NonAssocSemiring (LocallyConstant X Y)

full_name: LocallyConstant.constRingHom
code: /-- The constant-function embedding, as a ring hom.  -/
@[simps]
def constRingHom [NonAssocSemiring Y] : Y →+* LocallyConstant X Y 
goal: Y →+* LocallyConstant X Y

full_name: LocallyConstant.constRingHom_apply
code: /-- The constant-function embedding, as a ring hom.  -/
@[simps]
def constRingHom [NonAssocSemiring Y] : Y →+* LocallyConstant X Y 
goal: LocallyConstant.constRingHom y = LocallyConstant.const X y

full_name: LocallyConstant.instSemiring
code: instance [Semiring Y] : Semiring (LocallyConstant X Y) 
goal: Semiring (LocallyConstant X Y)

full_name: LocallyConstant.instNonUnitalCommSemiring
code: instance [NonUnitalCommSemiring Y] : NonUnitalCommSemiring (LocallyConstant X Y) 
goal: NonUnitalCommSemiring (LocallyConstant X Y)

full_name: LocallyConstant.instCommSemiring
code: instance [CommSemiring Y] : CommSemiring (LocallyConstant X Y) 
goal: CommSemiring (LocallyConstant X Y)

full_name: LocallyConstant.instNonUnitalNonAssocRing
code: instance [NonUnitalNonAssocRing Y] : NonUnitalNonAssocRing (LocallyConstant X Y) 
goal: NonUnitalNonAssocRing (LocallyConstant X Y)

full_name: LocallyConstant.instNonUnitalRing
code: instance [NonUnitalRing Y] : NonUnitalRing (LocallyConstant X Y) 
goal: NonUnitalRing (LocallyConstant X Y)

full_name: LocallyConstant.instNonAssocRing
code: instance [NonAssocRing Y] : NonAssocRing (LocallyConstant X Y) 
goal: NonAssocRing (LocallyConstant X Y)

full_name: LocallyConstant.instRing
code: instance [Ring Y] : Ring (LocallyConstant X Y) 
goal: Ring (LocallyConstant X Y)

full_name: LocallyConstant.instNonUnitalCommRing
code: instance [NonUnitalCommRing Y] : NonUnitalCommRing (LocallyConstant X Y) 
goal: NonUnitalCommRing (LocallyConstant X Y)

full_name: LocallyConstant.instCommRing
code: instance [CommRing Y] : CommRing (LocallyConstant X Y) 
goal: CommRing (LocallyConstant X Y)

full_name: LocallyConstant.instMulAction
code: instance [Monoid R] [MulAction R Y] : MulAction R (LocallyConstant X Y) 
goal: MulAction R (LocallyConstant X Y)

full_name: LocallyConstant.instDistribMulAction
code: instance [Monoid R] [AddMonoid Y] [DistribMulAction R Y] :
    DistribMulAction R (LocallyConstant X Y) 
goal: DistribMulAction R (LocallyConstant X Y)

full_name: LocallyConstant.instModule
code: instance [Semiring R] [AddCommMonoid Y] [Module R Y] : Module R (LocallyConstant X Y) 
goal: Module R (LocallyConstant X Y)

full_name: LocallyConstant.instAlgebra
code: instance : Algebra R (LocallyConstant X Y) 
goal: Algebra R (LocallyConstant X Y)

full_name: LocallyConstant.coe_algebraMap
code: @[simp]
theorem coe_algebraMap (r : R) : ⇑(algebraMap R (LocallyConstant X Y) r) = algebraMap R (X → Y) r 
goal: ⇑((algebraMap R (LocallyConstant X Y)) r) = (algebraMap R (X → Y)) r

full_name: LocallyConstant.coeFnRingHom
code: /-- `DFunLike.coe` as a `RingHom`. -/
@[simps!] def coeFnRingHom [Semiring Y] : LocallyConstant X Y →+* X → Y 
goal: LocallyConstant X Y →+* X → Y

full_name: LocallyConstant.coeFnRingHom_apply
code: /-- `DFunLike.coe` as a `RingHom`. -/
@[simps!] def coeFnRingHom [Semiring Y] : LocallyConstant X Y →+* X → Y 
goal: ∀ (a : LocallyConstant X Y) (a_1 : X), LocallyConstant.coeFnRingHom a a_1 = a a_1

full_name: LocallyConstant.coeFnₗ_apply
code: /-- `DFunLike.coe` as a linear map. -/
@[simps!] def coeFnₗ (R : Type*) [Semiring R] [AddCommMonoid Y]
    [Module R Y] : LocallyConstant X Y →ₗ[R] X → Y 
goal: ∀ (a : LocallyConstant X Y) (a_1 : X), (LocallyConstant.coeFnₗ R) a a_1 = a a_1

full_name: LocallyConstant.coeFnₗ
code: /-- `DFunLike.coe` as a linear map. -/
@[simps!] def coeFnₗ (R : Type*) [Semiring R] [AddCommMonoid Y]
    [Module R Y] : LocallyConstant X Y →ₗ[R] X → Y 
goal: LocallyConstant X Y →ₗ[R] X → Y

full_name: LocallyConstant.coeFnAlgHom_apply
code: /-- `DFunLike.coe` as an `AlgHom`. -/
@[simps!] def coeFnAlgHom (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] :
    LocallyConstant X Y →ₐ[R] X → Y 
goal: ∀ (a : LocallyConstant X Y) (a_1 : X), (LocallyConstant.coeFnAlgHom R) a a_1 = a a_1

full_name: LocallyConstant.coeFnAlgHom
code: /-- `DFunLike.coe` as an `AlgHom`. -/
@[simps!] def coeFnAlgHom (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] :
    LocallyConstant X Y →ₐ[R] X → Y 
goal: LocallyConstant X Y →ₐ[R] X → Y

full_name: LocallyConstant.evalAddMonoidHom_apply
code: /-- Evaluation as a `MonoidHom` -/
@[to_additive (attr := simps!) "Evaluation as an `AddMonoidHom`"]
def evalMonoidHom [MulOneClass Y] (x : X) : LocallyConstant X Y →* Y 
goal: ∀ (a : LocallyConstant X Y), (LocallyConstant.evalAddMonoidHom x) a = a x

full_name: LocallyConstant.evalAddMonoidHom
code: /-- Evaluation as a `MonoidHom` -/
@[to_additive (attr := simps!) "Evaluation as an `AddMonoidHom`"]
def evalMonoidHom [MulOneClass Y] (x : X) : LocallyConstant X Y →* Y 
goal: LocallyConstant X Y →+ Y

full_name: LocallyConstant.evalMonoidHom
code: /-- Evaluation as a `MonoidHom` -/
@[to_additive (attr := simps!) "Evaluation as an `AddMonoidHom`"]
def evalMonoidHom [MulOneClass Y] (x : X) : LocallyConstant X Y →* Y 
goal: LocallyConstant X Y →* Y

full_name: LocallyConstant.evalMonoidHom_apply
code: /-- Evaluation as a `MonoidHom` -/
@[to_additive (attr := simps!) "Evaluation as an `AddMonoidHom`"]
def evalMonoidHom [MulOneClass Y] (x : X) : LocallyConstant X Y →* Y 
goal: ∀ (a : LocallyConstant X Y), (LocallyConstant.evalMonoidHom x) a = a x

full_name: LocallyConstant.evalₗ_apply
code: /-- Evaluation as a linear map -/
@[simps!] def evalₗ (R : Type*) [Semiring R] [AddCommMonoid Y]
    [Module R Y] (x : X) : LocallyConstant X Y →ₗ[R] Y 
goal: ∀ (a : LocallyConstant X Y), (LocallyConstant.evalₗ R x) a = a x

full_name: LocallyConstant.evalₗ
code: /-- Evaluation as a linear map -/
@[simps!] def evalₗ (R : Type*) [Semiring R] [AddCommMonoid Y]
    [Module R Y] (x : X) : LocallyConstant X Y →ₗ[R] Y 
goal: LocallyConstant X Y →ₗ[R] Y

full_name: LocallyConstant.evalRingHom_apply
code: /-- Evaluation as a `RingHom` -/
@[simps!] def evalRingHom [Semiring Y] (x : X) : LocallyConstant X Y →+* Y 
goal: ∀ (a : LocallyConstant X Y), (LocallyConstant.evalRingHom x) a = a x

full_name: LocallyConstant.evalRingHom
code: /-- Evaluation as a `RingHom` -/
@[simps!] def evalRingHom [Semiring Y] (x : X) : LocallyConstant X Y →+* Y 
goal: LocallyConstant X Y →+* Y

full_name: LocallyConstant.evalₐ
code: /-- Evaluation as an `AlgHom` -/
@[simps!]
def evalₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] (x : X) :
    LocallyConstant X Y →ₐ[R] Y 
goal: LocallyConstant X Y →ₐ[R] Y

full_name: LocallyConstant.evalₐ_apply
code: /-- Evaluation as an `AlgHom` -/
@[simps!]
def evalₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] (x : X) :
    LocallyConstant X Y →ₐ[R] Y 
goal: ∀ (a : LocallyConstant X Y), (LocallyConstant.evalₐ R x) a = a x

full_name: LocallyConstant.comapAddMonoidHom_apply
code: /-- `LocallyConstant.comap` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`LocallyConstant.comap` as an `AddMonoidHom`."]
def comapMonoidHom [MulOneClass Z]  (f : C(X, Y)) :
    LocallyConstant Y Z →* LocallyConstant X Z 
goal: (LocallyConstant.comapAddMonoidHom f) g = LocallyConstant.comap f g

full_name: LocallyConstant.comapAddMonoidHom
code: /-- `LocallyConstant.comap` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`LocallyConstant.comap` as an `AddMonoidHom`."]
def comapMonoidHom [MulOneClass Z]  (f : C(X, Y)) :
    LocallyConstant Y Z →* LocallyConstant X Z 
goal: LocallyConstant Y Z →+ LocallyConstant X Z

full_name: LocallyConstant.comapMonoidHom
code: /-- `LocallyConstant.comap` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`LocallyConstant.comap` as an `AddMonoidHom`."]
def comapMonoidHom [MulOneClass Z]  (f : C(X, Y)) :
    LocallyConstant Y Z →* LocallyConstant X Z 
goal: LocallyConstant Y Z →* LocallyConstant X Z

full_name: LocallyConstant.comapMonoidHom_apply
code: /-- `LocallyConstant.comap` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`LocallyConstant.comap` as an `AddMonoidHom`."]
def comapMonoidHom [MulOneClass Z]  (f : C(X, Y)) :
    LocallyConstant Y Z →* LocallyConstant X Z 
goal: (LocallyConstant.comapMonoidHom f) g = LocallyConstant.comap f g

full_name: LocallyConstant.comapₗ
code: /-- `LocallyConstant.comap` as a linear map. -/
@[simps!]
def comapₗ (R : Type*) [Semiring R] [AddCommMonoid Z] [Module R Z] (f : C(X, Y)) :
    LocallyConstant Y Z →ₗ[R] LocallyConstant X Z 
goal: LocallyConstant Y Z →ₗ[R] LocallyConstant X Z

full_name: LocallyConstant.comapₗ_apply_apply
code: /-- `LocallyConstant.comap` as a linear map. -/
@[simps!]
def comapₗ (R : Type*) [Semiring R] [AddCommMonoid Z] [Module R Z] (f : C(X, Y)) :
    LocallyConstant Y Z →ₗ[R] LocallyConstant X Z 
goal: ∀ (a : X), ((LocallyConstant.comapₗ R f) g) a = g (f a)

full_name: LocallyConstant.comapRingHom_apply_apply
code: /-- `LocallyConstant.comap` as a `RingHom`. -/
@[simps!]
def comapRingHom [Semiring Z] (f : C(X, Y)) :
    LocallyConstant Y Z →+* LocallyConstant X Z 
goal: ∀ (a : X), ((LocallyConstant.comapRingHom f) g) a = g (f a)

full_name: LocallyConstant.comapRingHom
code: /-- `LocallyConstant.comap` as a `RingHom`. -/
@[simps!]
def comapRingHom [Semiring Z] (f : C(X, Y)) :
    LocallyConstant Y Z →+* LocallyConstant X Z 
goal: LocallyConstant Y Z →+* LocallyConstant X Z

full_name: LocallyConstant.comapₐ_apply_apply
code: /-- `LocallyConstant.comap` as an `AlgHom` -/
@[simps!]
def comapₐ (R : Type*) [CommSemiring R] [Semiring Z] [Algebra R Z]
    (f : C(X, Y)) : LocallyConstant Y Z →ₐ[R] LocallyConstant X Z 
goal: ∀ (a : X), ((LocallyConstant.comapₐ R f) g) a = g (f a)

full_name: LocallyConstant.comapₐ
code: /-- `LocallyConstant.comap` as an `AlgHom` -/
@[simps!]
def comapₐ (R : Type*) [CommSemiring R] [Semiring Z] [Algebra R Z]
    (f : C(X, Y)) : LocallyConstant Y Z →ₐ[R] LocallyConstant X Z 
goal: LocallyConstant Y Z →ₐ[R] LocallyConstant X Z

full_name: LocallyConstant.ker_comapₗ
code: lemma ker_comapₗ [Semiring R] [AddCommMonoid Z] [Module R Z] (f : C(X, Y))
    (hfs : Function.Surjective f) :
    LinearMap.ker (comapₗ R f : LocallyConstant Y Z →ₗ[R] LocallyConstant X Z) = ⊥ 
goal: LinearMap.ker (LocallyConstant.comapₗ R f) = ⊥

full_name: LocallyConstant.congrLeftₗ_symm_apply_apply
code: /-- `LocallyConstant.congrLeft` as a linear equivalence. -/
@[simps!]
def congrLeftₗ (R : Type*) [Semiring R] [AddCommMonoid Z] [Module R Z] (e : X ≃ₜ Y) :
    LocallyConstant X Z ≃ₗ[R] LocallyConstant Y Z 
goal: ∀ (a : LocallyConstant Y Z) (a_1 : X), ((LocallyConstant.congrLeftₗ R e).symm a) a_1 = a (e a_1)

full_name: LocallyConstant.congrLeftₗ_apply_apply
code: /-- `LocallyConstant.congrLeft` as a linear equivalence. -/
@[simps!]
def congrLeftₗ (R : Type*) [Semiring R] [AddCommMonoid Z] [Module R Z] (e : X ≃ₜ Y) :
    LocallyConstant X Z ≃ₗ[R] LocallyConstant Y Z 
goal: ∀ (a : Y), ((LocallyConstant.congrLeftₗ R e) g) a = g (e.symm a)

full_name: LocallyConstant.congrLeftₗ
code: /-- `LocallyConstant.congrLeft` as a linear equivalence. -/
@[simps!]
def congrLeftₗ (R : Type*) [Semiring R] [AddCommMonoid Z] [Module R Z] (e : X ≃ₜ Y) :
    LocallyConstant X Z ≃ₗ[R] LocallyConstant Y Z 
goal: LocallyConstant X Z ≃ₗ[R] LocallyConstant Y Z

full_name: LocallyConstant.congrLeftRingEquiv
code: /-- `LocallyConstant.congrLeft` as a `RingEquiv`. -/
@[simps!]
def congrLeftRingEquiv [Semiring Z] (e : X ≃ₜ Y) :
    LocallyConstant X Z ≃+* LocallyConstant Y Z 
goal: LocallyConstant X Z ≃+* LocallyConstant Y Z

full_name: LocallyConstant.congrLeftRingEquiv_apply_apply
code: /-- `LocallyConstant.congrLeft` as a `RingEquiv`. -/
@[simps!]
def congrLeftRingEquiv [Semiring Z] (e : X ≃ₜ Y) :
    LocallyConstant X Z ≃+* LocallyConstant Y Z 
goal: ∀ (a : Y), ((LocallyConstant.congrLeftRingEquiv e) g) a = g (e.symm a)

full_name: LocallyConstant.congrLeftRingEquiv_symm_apply_apply
code: /-- `LocallyConstant.congrLeft` as a `RingEquiv`. -/
@[simps!]
def congrLeftRingEquiv [Semiring Z] (e : X ≃ₜ Y) :
    LocallyConstant X Z ≃+* LocallyConstant Y Z 
goal: ∀ (a : X), ((LocallyConstant.congrLeftRingEquiv e).symm g) a = g (e a)

full_name: LocallyConstant.congrLeftₐ_apply_apply
code: /-- `LocallyConstant.congrLeft` as an `AlgEquiv`. -/
@[simps!]
def congrLeftₐ (R : Type*) [CommSemiring R] [Semiring Z] [Algebra R Z] (e : X ≃ₜ Y) :
    LocallyConstant X Z ≃ₐ[R] LocallyConstant Y Z 
goal: ∀ (a : Y), ((LocallyConstant.congrLeftₐ R e) g) a = g (e.symm a)

full_name: LocallyConstant.congrLeftₐ
code: /-- `LocallyConstant.congrLeft` as an `AlgEquiv`. -/
@[simps!]
def congrLeftₐ (R : Type*) [CommSemiring R] [Semiring Z] [Algebra R Z] (e : X ≃ₜ Y) :
    LocallyConstant X Z ≃ₐ[R] LocallyConstant Y Z 
goal: LocallyConstant X Z ≃ₐ[R] LocallyConstant Y Z

full_name: LocallyConstant.congrLeftₐ_symm_apply_apply
code: /-- `LocallyConstant.congrLeft` as an `AlgEquiv`. -/
@[simps!]
def congrLeftₐ (R : Type*) [CommSemiring R] [Semiring Z] [Algebra R Z] (e : X ≃ₜ Y) :
    LocallyConstant X Z ≃ₐ[R] LocallyConstant Y Z 
goal: ∀ (a : X), ((LocallyConstant.congrLeftₐ R e).symm g) a = g (e a)

full_name: LocallyConstant.mapMonoidHom_apply
code: /-- `LocallyConstant.map` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`LocallyConstant.map` as an `AddMonoidHom`."]
def mapMonoidHom [MulOneClass Y] [MulOneClass Z] (f : Y →* Z) :
    LocallyConstant X Y →* LocallyConstant X Z 
goal: (LocallyConstant.mapMonoidHom f) g = LocallyConstant.map (⇑f) g

full_name: LocallyConstant.mapMonoidHom
code: /-- `LocallyConstant.map` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`LocallyConstant.map` as an `AddMonoidHom`."]
def mapMonoidHom [MulOneClass Y] [MulOneClass Z] (f : Y →* Z) :
    LocallyConstant X Y →* LocallyConstant X Z 
goal: LocallyConstant X Y →* LocallyConstant X Z

full_name: LocallyConstant.mapAddMonoidHom_apply
code: /-- `LocallyConstant.map` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`LocallyConstant.map` as an `AddMonoidHom`."]
def mapMonoidHom [MulOneClass Y] [MulOneClass Z] (f : Y →* Z) :
    LocallyConstant X Y →* LocallyConstant X Z 
goal: (LocallyConstant.mapAddMonoidHom f) g = LocallyConstant.map (⇑f) g

full_name: LocallyConstant.mapAddMonoidHom
code: /-- `LocallyConstant.map` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`LocallyConstant.map` as an `AddMonoidHom`."]
def mapMonoidHom [MulOneClass Y] [MulOneClass Z] (f : Y →* Z) :
    LocallyConstant X Y →* LocallyConstant X Z 
goal: LocallyConstant X Y →+ LocallyConstant X Z

full_name: LocallyConstant.mapₗ
code: /-- `LocallyConstant.map` as a linear map. -/
@[simps!]
def mapₗ (R : Type*) [Semiring R] [AddCommMonoid Y] [Module R Y]
    [AddCommMonoid Z] [Module R Z] (f : Y →ₗ[R] Z) :
    LocallyConstant X Y →ₗ[R] LocallyConstant X Z 
goal: LocallyConstant X Y →ₗ[R] LocallyConstant X Z

full_name: LocallyConstant.mapₗ_apply_apply
code: /-- `LocallyConstant.map` as a linear map. -/
@[simps!]
def mapₗ (R : Type*) [Semiring R] [AddCommMonoid Y] [Module R Y]
    [AddCommMonoid Z] [Module R Z] (f : Y →ₗ[R] Z) :
    LocallyConstant X Y →ₗ[R] LocallyConstant X Z 
goal: ∀ (a : X), ((LocallyConstant.mapₗ R f) g) a = f (g a)

full_name: LocallyConstant.mapRingHom_apply_apply
code: /-- `LocallyConstant.map` as a `RingHom`. -/
@[simps!]
def mapRingHom [Semiring Y] [Semiring Z] (f : Y →+* Z) :
    LocallyConstant X Y →+* LocallyConstant X Z 
goal: ∀ (a : X), ((LocallyConstant.mapRingHom f) g) a = f (g a)

full_name: LocallyConstant.mapRingHom
code: /-- `LocallyConstant.map` as a `RingHom`. -/
@[simps!]
def mapRingHom [Semiring Y] [Semiring Z] (f : Y →+* Z) :
    LocallyConstant X Y →+* LocallyConstant X Z 
goal: LocallyConstant X Y →+* LocallyConstant X Z

full_name: LocallyConstant.mapₐ
code: /-- `LocallyConstant.map` as an `AlgHom` -/
@[simps!]
def mapₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] [Semiring Z] [Algebra R Z]
    (f : Y →ₐ[R] Z) : LocallyConstant X Y →ₐ[R] LocallyConstant X Z 
goal: LocallyConstant X Y →ₐ[R] LocallyConstant X Z

full_name: LocallyConstant.mapₐ_apply_apply
code: /-- `LocallyConstant.map` as an `AlgHom` -/
@[simps!]
def mapₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] [Semiring Z] [Algebra R Z]
    (f : Y →ₐ[R] Z) : LocallyConstant X Y →ₐ[R] LocallyConstant X Z 
goal: ∀ (a : X), ((LocallyConstant.mapₐ R f) g) a = f (g a)

full_name: LocallyConstant.congrRightₗ
code: /-- `LocallyConstant.congrRight` as a linear equivalence. -/
@[simps!]
def congrRightₗ (R : Type*) [Semiring R] [AddCommMonoid Y] [Module R Y]
    [AddCommMonoid Z] [Module R Z] (e : Y ≃ₗ[R] Z) :
    LocallyConstant X Y ≃ₗ[R] LocallyConstant X Z 
goal: LocallyConstant X Y ≃ₗ[R] LocallyConstant X Z

full_name: LocallyConstant.congrRightₗ_symm_apply_apply
code: /-- `LocallyConstant.congrRight` as a linear equivalence. -/
@[simps!]
def congrRightₗ (R : Type*) [Semiring R] [AddCommMonoid Y] [Module R Y]
    [AddCommMonoid Z] [Module R Z] (e : Y ≃ₗ[R] Z) :
    LocallyConstant X Y ≃ₗ[R] LocallyConstant X Z 
goal: ∀ (a : LocallyConstant X Z) (a_1 : X), ((LocallyConstant.congrRightₗ R e).symm a) a_1 = e.symm (a a_1)

full_name: LocallyConstant.congrRightₗ_apply_apply
code: /-- `LocallyConstant.congrRight` as a linear equivalence. -/
@[simps!]
def congrRightₗ (R : Type*) [Semiring R] [AddCommMonoid Y] [Module R Y]
    [AddCommMonoid Z] [Module R Z] (e : Y ≃ₗ[R] Z) :
    LocallyConstant X Y ≃ₗ[R] LocallyConstant X Z 
goal: ∀ (a : X), ((LocallyConstant.congrRightₗ R e) g) a = e (g a)

full_name: LocallyConstant.congrRightRingEquiv_symm_apply_apply
code: /-- `LocallyConstant.congrRight` as a `RingEquiv`. -/
@[simps!]
def congrRightRingEquiv [Semiring Y] [Semiring Z] (e : Y ≃+* Z) :
    LocallyConstant X Y ≃+* LocallyConstant X Z 
goal: ∀ (a : X), ((LocallyConstant.congrRightRingEquiv e).symm g) a = (↑e).symm (g a)

full_name: LocallyConstant.congrRightRingEquiv_apply_apply
code: /-- `LocallyConstant.congrRight` as a `RingEquiv`. -/
@[simps!]
def congrRightRingEquiv [Semiring Y] [Semiring Z] (e : Y ≃+* Z) :
    LocallyConstant X Y ≃+* LocallyConstant X Z 
goal: ∀ (a : X), ((LocallyConstant.congrRightRingEquiv e) g) a = e (g a)

full_name: LocallyConstant.congrRightRingEquiv
code: /-- `LocallyConstant.congrRight` as a `RingEquiv`. -/
@[simps!]
def congrRightRingEquiv [Semiring Y] [Semiring Z] (e : Y ≃+* Z) :
    LocallyConstant X Y ≃+* LocallyConstant X Z 
goal: LocallyConstant X Y ≃+* LocallyConstant X Z

full_name: LocallyConstant.congrRightₐ
code: /-- `LocallyConstant.congrRight` as an `AlgEquiv`. -/
@[simps!]
def congrRightₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] [Semiring Z] [Algebra R Z]
    (e : Y ≃ₐ[R] Z) : LocallyConstant X Y ≃ₐ[R] LocallyConstant X Z 
goal: LocallyConstant X Y ≃ₐ[R] LocallyConstant X Z

full_name: LocallyConstant.congrRightₐ_apply_apply
code: /-- `LocallyConstant.congrRight` as an `AlgEquiv`. -/
@[simps!]
def congrRightₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] [Semiring Z] [Algebra R Z]
    (e : Y ≃ₐ[R] Z) : LocallyConstant X Y ≃ₐ[R] LocallyConstant X Z 
goal: ∀ (a : X), ((LocallyConstant.congrRightₐ R e) g) a = e (g a)

full_name: LocallyConstant.congrRightₐ_symm_apply_apply
code: /-- `LocallyConstant.congrRight` as an `AlgEquiv`. -/
@[simps!]
def congrRightₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] [Semiring Z] [Algebra R Z]
    (e : Y ≃ₐ[R] Z) : LocallyConstant X Y ≃ₐ[R] LocallyConstant X Z 
goal: ∀ (a : X), ((LocallyConstant.congrRightₐ R e).symm g) a = e.symm (g a)

full_name: LocallyConstant.constₗ
code: /-- `LocallyConstant.const` as a linear map. -/
@[simps!]
def constₗ (R : Type*) [Semiring R] [AddCommMonoid Y] [Module R Y] :
    Y →ₗ[R] LocallyConstant X Y 
goal: Y →ₗ[R] LocallyConstant X Y

full_name: LocallyConstant.constₗ_apply_apply
code: /-- `LocallyConstant.const` as a linear map. -/
@[simps!]
def constₗ (R : Type*) [Semiring R] [AddCommMonoid Y] [Module R Y] :
    Y →ₗ[R] LocallyConstant X Y 
goal: ∀ (a : X), ((LocallyConstant.constₗ R) y) a = y

full_name: LocallyConstant.constₐ
code: /-- `LocallyConstant.const` as an `AlgHom` -/
@[simps!]
def constₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] :
    Y →ₐ[R] LocallyConstant X Y 
goal: Y →ₐ[R] LocallyConstant X Y

full_name: LocallyConstant.constₐ_apply_apply
code: /-- `LocallyConstant.const` as an `AlgHom` -/
@[simps!]
def constₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] :
    Y →ₐ[R] LocallyConstant X Y 
goal: ∀ (a : X), ((LocallyConstant.constₐ R) y) a = y