fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
noncomputable charFn (hU : IsClopen U) : LocallyConstant X Y :=
indicator 1 hU | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | charFn | Characteristic functions are locally constant functions taking `x : X` to `1` if `x ∈ U`,
where `U` is a clopen set, and `0` otherwise. |
coe_charFn (hU : IsClopen U) : (charFn Y hU : X → Y) = Set.indicator U 1 :=
rfl | theorem | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | coe_charFn | null |
charFn_eq_one [Nontrivial Y] (x : X) (hU : IsClopen U) : charFn Y hU x = (1 : Y) ↔ x ∈ U :=
Set.indicator_eq_one_iff_mem _ | theorem | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | charFn_eq_one | null |
charFn_eq_zero [Nontrivial Y] (x : X) (hU : IsClopen U) : charFn Y hU x = (0 : Y) ↔ x ∉ U :=
Set.indicator_eq_zero_iff_notMem _ | theorem | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | charFn_eq_zero | null |
charFn_inj [Nontrivial Y] (hU : IsClopen U) (hV : IsClopen V)
(h : charFn Y hU = charFn Y hV) : U = V :=
Set.indicator_one_inj Y <| coe_inj.mpr h | theorem | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | charFn_inj | null |
@[to_additive]
coe_div [Div Y] (f g : LocallyConstant X Y) : ⇑(f / g) = f / g :=
rfl
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | coe_div | null |
div_apply [Div Y] (f g : LocallyConstant X Y) (x : X) : (f / g) x = f x / g x :=
rfl
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | div_apply | null |
@[to_additive]
smul [SMul α Y] : SMul α (LocallyConstant X Y) where
smul n f := f.map (n • ·)
@[to_additive (attr := simp)] | instance | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | smul | null |
coe_smul [SMul R Y] (r : R) (f : LocallyConstant X Y) : ⇑(r • f) = r • (f : X → Y) :=
rfl
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | coe_smul | null |
smul_apply [SMul R Y] (r : R) (f : LocallyConstant X Y) (x : X) : (r • f) x = r • f x :=
rfl
@[to_additive existing LocallyConstant.smul] | theorem | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | smul_apply | null |
@[simps]
constRingHom [NonAssocSemiring Y] : Y →+* LocallyConstant X Y :=
{ constMonoidHom, constAddMonoidHom with toFun := const X } | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | constRingHom | The constant-function embedding, as a ring hom. |
@[simp]
coe_algebraMap (r : R) : ⇑(algebraMap R (LocallyConstant X Y) r) = algebraMap R (X → Y) r :=
rfl | theorem | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | coe_algebraMap | null |
@[simps!] coeFnRingHom [Semiring Y] : LocallyConstant X Y →+* X → Y where
toMonoidHom := coeFnMonoidHom
__ := coeFnAddMonoidHom | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | coeFnRingHom | `DFunLike.coe` as a `RingHom`. |
@[simps!] coeFnₗ (R : Type*) [Semiring R] [AddCommMonoid Y]
[Module R Y] : LocallyConstant X Y →ₗ[R] X → Y where
toAddHom := coeFnAddMonoidHom.toAddHom
map_smul' _ _ := rfl | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | coeFnₗ | `DFunLike.coe` as a linear map. |
@[simps!] coeFnAlgHom (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] :
LocallyConstant X Y →ₐ[R] X → Y where
toRingHom := coeFnRingHom
commutes' _ := rfl | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | coeFnAlgHom | `DFunLike.coe` as an `AlgHom`. |
@[to_additive (attr := simps!) /-- Evaluation as an `AddMonoidHom` -/]
evalMonoidHom [MulOneClass Y] (x : X) : LocallyConstant X Y →* Y :=
(Pi.evalMonoidHom _ x).comp coeFnMonoidHom | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | evalMonoidHom | Evaluation as a `MonoidHom` |
@[simps!] evalₗ (R : Type*) [Semiring R] [AddCommMonoid Y]
[Module R Y] (x : X) : LocallyConstant X Y →ₗ[R] Y :=
(LinearMap.proj x).comp (coeFnₗ R) | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | evalₗ | Evaluation as a linear map |
@[simps!] evalRingHom [Semiring Y] (x : X) : LocallyConstant X Y →+* Y :=
(Pi.evalRingHom _ x).comp coeFnRingHom | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | evalRingHom | Evaluation as a `RingHom` |
@[simps!]
evalₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] (x : X) :
LocallyConstant X Y →ₐ[R] Y :=
(Pi.evalAlgHom _ _ x).comp (coeFnAlgHom R) | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | evalₐ | Evaluation as an `AlgHom` |
@[to_additive (attr := simps) /-- `LocallyConstant.comap` as an `AddMonoidHom`. -/]
comapMonoidHom [MulOneClass Z] (f : C(X, Y)) :
LocallyConstant Y Z →* LocallyConstant X Z where
toFun := comap f
map_one' := rfl
map_mul' _ _ := rfl | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | comapMonoidHom | `LocallyConstant.comap` as a `MonoidHom`. |
@[simps!]
comapₗ (R : Type*) [Semiring R] [AddCommMonoid Z] [Module R Z] (f : C(X, Y)) :
LocallyConstant Y Z →ₗ[R] LocallyConstant X Z where
toFun := comap f
map_add' := map_add (comapAddMonoidHom f)
map_smul' _ _ := rfl | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | comapₗ | `LocallyConstant.comap` as a linear map. |
@[simps!]
comapRingHom [Semiring Z] (f : C(X, Y)) :
LocallyConstant Y Z →+* LocallyConstant X Z where
toMonoidHom := comapMonoidHom f
__ := (comapAddMonoidHom f) | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | comapRingHom | `LocallyConstant.comap` as a `RingHom`. |
@[simps!]
comapₐ (R : Type*) [CommSemiring R] [Semiring Z] [Algebra R Z]
(f : C(X, Y)) : LocallyConstant Y Z →ₐ[R] LocallyConstant X Z where
toRingHom := comapRingHom f
commutes' _ := rfl | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | comapₐ | `LocallyConstant.comap` as an `AlgHom` |
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) = ⊥ :=
LinearMap.ker_eq_bot_of_injective <| comap_injective _ hfs | lemma | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | ker_comapₗ | null |
@[simps!]
congrLeftₗ (R : Type*) [Semiring R] [AddCommMonoid Z] [Module R Z] (e : X ≃ₜ Y) :
LocallyConstant X Z ≃ₗ[R] LocallyConstant Y Z where
toLinearMap := comapₗ R ⟨_, e.symm.continuous⟩
__ := congrLeft e | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | congrLeftₗ | `LocallyConstant.congrLeft` as a linear equivalence. |
@[simps!]
congrLeftRingEquiv [Semiring Z] (e : X ≃ₜ Y) :
LocallyConstant X Z ≃+* LocallyConstant Y Z where
toEquiv := congrLeft e
__ := comapMonoidHom ⟨_, e.symm.continuous⟩
__ := comapAddMonoidHom ⟨_, e.symm.continuous⟩ | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | congrLeftRingEquiv | `LocallyConstant.congrLeft` as a `RingEquiv`. |
@[simps!]
congrLeftₐ (R : Type*) [CommSemiring R] [Semiring Z] [Algebra R Z] (e : X ≃ₜ Y) :
LocallyConstant X Z ≃ₐ[R] LocallyConstant Y Z where
toEquiv := congrLeft e
__ := comapₐ R ⟨_, e.symm.continuous⟩ | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | congrLeftₐ | `LocallyConstant.congrLeft` as an `AlgEquiv`. |
@[to_additive (attr := simps) /-- `LocallyConstant.map` as an `AddMonoidHom`. -/]
mapMonoidHom [MulOneClass Y] [MulOneClass Z] (f : Y →* Z) :
LocallyConstant X Y →* LocallyConstant X Z where
toFun := map f
map_one' := by aesop
map_mul' := by aesop | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | mapMonoidHom | `LocallyConstant.map` as a `MonoidHom`. |
@[simps!]
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 where
toFun := map f
map_add' := by aesop
map_smul' := by aesop | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | mapₗ | `LocallyConstant.map` as a linear map. |
@[simps!]
mapRingHom [Semiring Y] [Semiring Z] (f : Y →+* Z) :
LocallyConstant X Y →+* LocallyConstant X Z where
toMonoidHom := mapMonoidHom f
__ := (mapAddMonoidHom f.toAddMonoidHom) | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | mapRingHom | `LocallyConstant.map` as a `RingHom`. |
@[simps!]
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 where
toRingHom := mapRingHom f
commutes' _ := by aesop | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | mapₐ | `LocallyConstant.map` as an `AlgHom` |
@[simps!]
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 where
toLinearMap := mapₗ R e
__ := congrRight e.toEquiv | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | congrRightₗ | `LocallyConstant.congrRight` as a linear equivalence. |
@[simps!]
congrRightRingEquiv [Semiring Y] [Semiring Z] (e : Y ≃+* Z) :
LocallyConstant X Y ≃+* LocallyConstant X Z where
toEquiv := congrRight e
__ := mapMonoidHom e.toMonoidHom
__ := mapAddMonoidHom e.toAddMonoidHom | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | congrRightRingEquiv | `LocallyConstant.congrRight` as a `RingEquiv`. |
@[simps!]
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 where
toEquiv := congrRight e
__ := mapₐ R e.toAlgHom | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | congrRightₐ | `LocallyConstant.congrRight` as an `AlgEquiv`. |
@[simps!]
constₗ (R : Type*) [Semiring R] [AddCommMonoid Y] [Module R Y] :
Y →ₗ[R] LocallyConstant X Y where
toFun := const X
map_add' _ _ := rfl
map_smul' _ _ := rfl | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | constₗ | `LocallyConstant.const` as a linear map. |
@[simps!]
constₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] :
Y →ₐ[R] LocallyConstant X Y where
toRingHom := constRingHom
commutes' _ := rfl | def | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.GroupWithZero.Indicator",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.Topology.LocallyConstant.Basic"
] | Mathlib/Topology/LocallyConstant/Algebra.lean | constₐ | `LocallyConstant.const` as an `AlgHom` |
IsLocallyConstant (f : X → Y) : Prop :=
∀ s : Set Y, IsOpen (f ⁻¹' s) | def | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | IsLocallyConstant | A function between topological spaces is locally constant if the preimage of any set is open. |
protected tfae (f : X → Y) :
TFAE [IsLocallyConstant f,
∀ x, ∀ᶠ x' in 𝓝 x, f x' = f x,
∀ x, IsOpen { x' | f x' = f x },
∀ y, IsOpen (f ⁻¹' {y}),
∀ x, ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ ∀ x' ∈ U, f x' = f x] := by
tfae_have 1 → 4 := fun h y => h {y}
tfae_have 4 → 3 := fun h x => h (f x)
tfae_have 3 → 2 := fun h x => IsOpen.mem_nhds (h x) rfl
tfae_have 2 → 5
| h, x => by
rcases mem_nhds_iff.1 (h x) with ⟨U, eq, hU, hx⟩
exact ⟨U, hU, hx, eq⟩
tfae_have 5 → 1
| h, s => by
refine isOpen_iff_forall_mem_open.2 fun x hx ↦ ?_
rcases h x with ⟨U, hU, hxU, eq⟩
exact ⟨U, fun x' hx' => mem_preimage.2 <| (eq x' hx').symm ▸ hx, hU, hxU⟩
tfae_finish
@[nontriviality] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | tfae | null |
of_discrete [DiscreteTopology X] (f : X → Y) : IsLocallyConstant f := fun _ =>
isOpen_discrete _ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | of_discrete | null |
isOpen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsOpen { x | f x = y } :=
hf {y} | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | isOpen_fiber | null |
isClosed_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClosed { x | f x = y } :=
⟨hf {y}ᶜ⟩ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | isClosed_fiber | null |
isClopen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClopen { x | f x = y } :=
⟨isClosed_fiber hf _, isOpen_fiber hf _⟩ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | isClopen_fiber | null |
iff_exists_open (f : X → Y) :
IsLocallyConstant f ↔ ∀ x, ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ ∀ x' ∈ U, f x' = f x :=
(IsLocallyConstant.tfae f).out 0 4 | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | iff_exists_open | null |
iff_eventually_eq (f : X → Y) : IsLocallyConstant f ↔ ∀ x, ∀ᶠ y in 𝓝 x, f y = f x :=
(IsLocallyConstant.tfae f).out 0 1 | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | iff_eventually_eq | null |
exists_open {f : X → Y} (hf : IsLocallyConstant f) (x : X) :
∃ U : Set X, IsOpen U ∧ x ∈ U ∧ ∀ x' ∈ U, f x' = f x :=
(iff_exists_open f).1 hf x | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | exists_open | null |
protected eventually_eq {f : X → Y} (hf : IsLocallyConstant f) (x : X) :
∀ᶠ y in 𝓝 x, f y = f x :=
(iff_eventually_eq f).1 hf x | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | eventually_eq | null |
iff_isOpen_fiber_apply {f : X → Y} : IsLocallyConstant f ↔ ∀ x, IsOpen (f ⁻¹' {f x}) :=
(IsLocallyConstant.tfae f).out 0 2 | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | iff_isOpen_fiber_apply | null |
iff_isOpen_fiber {f : X → Y} : IsLocallyConstant f ↔ ∀ y, IsOpen (f ⁻¹' {y}) :=
(IsLocallyConstant.tfae f).out 0 3 | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | iff_isOpen_fiber | null |
protected continuous [TopologicalSpace Y] {f : X → Y} (hf : IsLocallyConstant f) :
Continuous f :=
⟨fun _ _ => hf _⟩ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | continuous | null |
iff_continuous {_ : TopologicalSpace Y} [DiscreteTopology Y] (f : X → Y) :
IsLocallyConstant f ↔ Continuous f :=
⟨IsLocallyConstant.continuous, fun h s => h.isOpen_preimage s (isOpen_discrete _)⟩ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | iff_continuous | null |
of_constant (f : X → Y) (h : ∀ x y, f x = f y) : IsLocallyConstant f :=
(iff_eventually_eq f).2 fun _ => Eventually.of_forall fun _ => h _ _ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | of_constant | null |
protected const (y : Y) : IsLocallyConstant (Function.const X y) :=
of_constant _ fun _ _ => rfl | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | const | null |
protected comp {f : X → Y} (hf : IsLocallyConstant f) (g : Y → Z) :
IsLocallyConstant (g ∘ f) := fun s => by
rw [Set.preimage_comp]
exact hf _ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | comp | null |
prodMk {Y'} {f : X → Y} {f' : X → Y'} (hf : IsLocallyConstant f)
(hf' : IsLocallyConstant f') : IsLocallyConstant fun x => (f x, f' x) :=
(iff_eventually_eq _).2 fun x =>
(hf.eventually_eq x).mp <| (hf'.eventually_eq x).mono fun _ hf' hf => Prod.ext hf hf'
@[deprecated (since := "2025-03-10")]
alias prod_mk := prodMk | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | prodMk | null |
comp₂ {Y₁ Y₂ Z : Type*} {f : X → Y₁} {g : X → Y₂} (hf : IsLocallyConstant f)
(hg : IsLocallyConstant g) (h : Y₁ → Y₂ → Z) : IsLocallyConstant fun x => h (f x) (g x) :=
(hf.prodMk hg).comp fun x : Y₁ × Y₂ => h x.1 x.2 | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | comp₂ | null |
comp_continuous [TopologicalSpace Y] {g : Y → Z} {f : X → Y} (hg : IsLocallyConstant g)
(hf : Continuous f) : IsLocallyConstant (g ∘ f) := fun s => by
rw [Set.preimage_comp]
exact hf.isOpen_preimage _ (hg _) | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | comp_continuous | null |
apply_eq_of_isPreconnected {f : X → Y} (hf : IsLocallyConstant f) {s : Set X}
(hs : IsPreconnected s) {x y : X} (hx : x ∈ s) (hy : y ∈ s) : f x = f y := by
let U := f ⁻¹' {f y}
suffices x ∉ Uᶜ from Classical.not_not.1 this
intro hxV
specialize hs U Uᶜ (hf {f y}) (hf {f y}ᶜ) _ ⟨y, ⟨hy, rfl⟩⟩ ⟨x, ⟨hx, hxV⟩⟩
· simp only [union_compl_self, subset_univ]
· simp only [inter_empty, Set.not_nonempty_empty, inter_compl_self] at hs | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | apply_eq_of_isPreconnected | A locally constant function is constant on any preconnected set. |
apply_eq_of_preconnectedSpace [PreconnectedSpace X] {f : X → Y} (hf : IsLocallyConstant f)
(x y : X) : f x = f y :=
hf.apply_eq_of_isPreconnected isPreconnected_univ trivial trivial | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | apply_eq_of_preconnectedSpace | null |
eq_const [PreconnectedSpace X] {f : X → Y} (hf : IsLocallyConstant f) (x : X) :
f = Function.const X (f x) :=
funext fun y => hf.apply_eq_of_preconnectedSpace y x | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | eq_const | null |
exists_eq_const [PreconnectedSpace X] [Nonempty Y] {f : X → Y} (hf : IsLocallyConstant f) :
∃ y, f = Function.const X y := by
rcases isEmpty_or_nonempty X with h | h
· exact ⟨Classical.arbitrary Y, funext <| h.elim⟩
· exact ⟨f (Classical.arbitrary X), hf.eq_const _⟩ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | exists_eq_const | null |
iff_is_const [PreconnectedSpace X] {f : X → Y} : IsLocallyConstant f ↔ ∀ x y, f x = f y :=
⟨fun h _ _ => h.apply_eq_of_isPreconnected isPreconnected_univ trivial trivial, of_constant _⟩ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | iff_is_const | null |
range_finite [CompactSpace X] {f : X → Y} (hf : IsLocallyConstant f) :
(Set.range f).Finite := by
letI : TopologicalSpace Y := ⊥; haveI := discreteTopology_bot Y
exact (isCompact_range hf.continuous).finite_of_discrete
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | range_finite | null |
one [One Y] : IsLocallyConstant (1 : X → Y) := IsLocallyConstant.const 1
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | one | null |
inv [Inv Y] ⦃f : X → Y⦄ (hf : IsLocallyConstant f) : IsLocallyConstant f⁻¹ :=
hf.comp fun x => x⁻¹
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | inv | null |
mul [Mul Y] ⦃f g : X → Y⦄ (hf : IsLocallyConstant f) (hg : IsLocallyConstant g) :
IsLocallyConstant (f * g) :=
hf.comp₂ hg (· * ·)
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | mul | null |
div [Div Y] ⦃f g : X → Y⦄ (hf : IsLocallyConstant f) (hg : IsLocallyConstant g) :
IsLocallyConstant (f / g) :=
hf.comp₂ hg (· / ·) | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | div | null |
desc {α β : Type*} (f : X → α) (g : α → β) (h : IsLocallyConstant (g ∘ f))
(inj : Function.Injective g) : IsLocallyConstant f := fun s => by
rw [← preimage_image_eq s inj, preimage_preimage]
exact h (g '' s) | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | desc | If a composition of a function `f` followed by an injection `g` is locally
constant, then the locally constant property descends to `f`. |
of_constant_on_connected_components [LocallyConnectedSpace X] {f : X → Y}
(h : ∀ x, ∀ y ∈ connectedComponent x, f y = f x) : IsLocallyConstant f :=
(iff_exists_open _).2 fun x =>
⟨connectedComponent x, isOpen_connectedComponent, mem_connectedComponent, h x⟩ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | of_constant_on_connected_components | null |
of_constant_on_connected_clopens [LocallyConnectedSpace X] {f : X → Y}
(h : ∀ U : Set X, IsConnected U → IsClopen U → ∀ x ∈ U, ∀ y ∈ U, f y = f x) :
IsLocallyConstant f :=
of_constant_on_connected_components fun x =>
h (connectedComponent x) isConnected_connectedComponent isClopen_connectedComponent x
mem_connectedComponent | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | of_constant_on_connected_clopens | null |
of_constant_on_preconnected_clopens [LocallyConnectedSpace X] {f : X → Y}
(h : ∀ U : Set X, IsPreconnected U → IsClopen U → ∀ x ∈ U, ∀ y ∈ U, f y = f x) :
IsLocallyConstant f :=
of_constant_on_connected_clopens fun U hU ↦ h U hU.isPreconnected | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | of_constant_on_preconnected_clopens | null |
LocallyConstant (X Y : Type*) [TopologicalSpace X] where
/-- The underlying function. -/
protected toFun : X → Y
/-- The map is locally constant. -/
protected isLocallyConstant : IsLocallyConstant toFun | structure | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | LocallyConstant | A (bundled) locally constant function from a topological space `X` to a type `Y`. |
Simps.apply (f : LocallyConstant X Y) : X → Y := f
initialize_simps_projections LocallyConstant (toFun → apply)
@[simp] | def | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | Simps.apply | See Note [custom simps projections]. |
toFun_eq_coe (f : LocallyConstant X Y) : f.toFun = f :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | toFun_eq_coe | null |
coe_mk (f : X → Y) (h) : ⇑(⟨f, h⟩ : LocallyConstant X Y) = f :=
rfl | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | coe_mk | null |
protected congr_fun {f g : LocallyConstant X Y} (h : f = g) (x : X) : f x = g x :=
DFunLike.congr_fun h x | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | congr_fun | null |
protected congr_arg (f : LocallyConstant X Y) {x y : X} (h : x = y) : f x = f y :=
DFunLike.congr_arg f h | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | congr_arg | null |
coe_injective : @Function.Injective (LocallyConstant X Y) (X → Y) (↑) := fun _ _ =>
DFunLike.ext'
@[norm_cast] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | coe_injective | null |
coe_inj {f g : LocallyConstant X Y} : (f : X → Y) = g ↔ f = g :=
coe_injective.eq_iff
@[ext] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | coe_inj | null |
ext ⦃f g : LocallyConstant X Y⦄ (h : ∀ x, f x = g x) : f = g :=
DFunLike.ext _ _ h | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | ext | null |
protected continuous : Continuous f :=
f.isLocallyConstant.continuous | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | continuous | null |
@[coe] toContinuousMap : C(X, Y) :=
⟨f, f.continuous⟩ | def | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | toContinuousMap | We can turn a locally-constant function into a bundled `ContinuousMap`. |
const (X : Type*) {Y : Type*} [TopologicalSpace X] (y : Y) : LocallyConstant X Y :=
⟨Function.const X y, IsLocallyConstant.const _⟩
@[simp] | def | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | const | As a shorthand, `LocallyConstant.toContinuousMap` is available as a coercion -/
instance : Coe (LocallyConstant X Y) C(X, Y) := ⟨toContinuousMap⟩
@[simp] theorem coe_continuousMap : ((f : C(X, Y)) : X → Y) = (f : X → Y) := rfl
theorem toContinuousMap_injective :
Function.Injective (toContinuousMap : LocallyConstant X Y → C(X, Y)) := fun _ _ h =>
ext (ContinuousMap.congr_fun h)
end CodomainTopologicalSpace
/-- The constant locally constant function on `X` with value `y : Y`. |
coe_const (y : Y) : (const X y : X → Y) = Function.const X y :=
rfl | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | coe_const | null |
@[simps]
eval {ι : Type*} {X : ι → Type*}
[∀ i, TopologicalSpace (X i)] (i : ι) [DiscreteTopology (X i)] :
LocallyConstant (Π i, X i) (X i) where
toFun := fun f ↦ f i
isLocallyConstant := (IsLocallyConstant.iff_continuous _).mpr <| continuous_apply i | def | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | eval | Evaluation/projection as a locally constant function. |
ofIsClopen {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
(hU : IsClopen U) : LocallyConstant X (Fin 2) where
toFun x := if x ∈ U then 0 else 1
isLocallyConstant := by
refine IsLocallyConstant.iff_isOpen_fiber.2 <| Fin.forall_fin_two.2 ⟨?_, ?_⟩
· convert hU.2 using 1
ext
simp only [mem_singleton_iff, Fin.one_eq_zero_iff, mem_preimage, ite_eq_left_iff,
Nat.succ_succ_ne_one]
tauto
· rw [← isClosed_compl_iff]
convert hU.1
ext
simp
@[simp] | def | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | ofIsClopen | The locally constant function to `Fin 2` associated to a clopen set. |
ofIsClopen_fiber_zero {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
(hU : IsClopen U) : ofIsClopen hU ⁻¹' ({0} : Set (Fin 2)) = U := by
ext
simp only [ofIsClopen, mem_singleton_iff, Fin.one_eq_zero_iff, coe_mk, mem_preimage,
ite_eq_left_iff, Nat.succ_succ_ne_one]
tauto
@[simp] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | ofIsClopen_fiber_zero | null |
ofIsClopen_fiber_one {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
(hU : IsClopen U) : ofIsClopen hU ⁻¹' ({1} : Set (Fin 2)) = Uᶜ := by
ext
simp only [ofIsClopen, mem_singleton_iff, coe_mk, Fin.zero_eq_one_iff, mem_preimage,
ite_eq_right_iff, mem_compl_iff, Nat.succ_succ_ne_one] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | ofIsClopen_fiber_one | null |
locallyConstant_eq_of_fiber_zero_eq {X : Type*} [TopologicalSpace X]
(f g : LocallyConstant X (Fin 2)) (h : f ⁻¹' ({0} : Set (Fin 2)) = g ⁻¹' {0}) : f = g := by
simp only [Set.ext_iff, mem_singleton_iff, mem_preimage] at h
ext1 x
exact Fin.fin_two_eq_of_eq_zero_iff (h x) | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | locallyConstant_eq_of_fiber_zero_eq | null |
range_finite [CompactSpace X] (f : LocallyConstant X Y) : (Set.range f).Finite :=
f.isLocallyConstant.range_finite | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | range_finite | null |
apply_eq_of_isPreconnected (f : LocallyConstant X Y) {s : Set X} (hs : IsPreconnected s)
{x y : X} (hx : x ∈ s) (hy : y ∈ s) : f x = f y :=
f.isLocallyConstant.apply_eq_of_isPreconnected hs hx hy | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | apply_eq_of_isPreconnected | null |
apply_eq_of_preconnectedSpace [PreconnectedSpace X] (f : LocallyConstant X Y) (x y : X) :
f x = f y :=
f.isLocallyConstant.apply_eq_of_isPreconnected isPreconnected_univ trivial trivial | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | apply_eq_of_preconnectedSpace | null |
eq_const [PreconnectedSpace X] (f : LocallyConstant X Y) (x : X) : f = const X (f x) :=
ext fun _ => apply_eq_of_preconnectedSpace f _ _ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | eq_const | null |
exists_eq_const [PreconnectedSpace X] [Nonempty Y] (f : LocallyConstant X Y) :
∃ y, f = const X y := by
rcases Classical.em (Nonempty X) with (⟨⟨x⟩⟩ | hX)
· exact ⟨f x, f.eq_const x⟩
· exact ⟨Classical.arbitrary Y, ext fun x => (hX ⟨x⟩).elim⟩ | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | exists_eq_const | null |
map (f : Y → Z) (g : LocallyConstant X Y) : LocallyConstant X Z :=
⟨f ∘ g, g.isLocallyConstant.comp f⟩
@[simp] | def | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | map | Push forward of locally constant maps under any map, by post-composition. |
map_apply (f : Y → Z) (g : LocallyConstant X Y) : ⇑(map f g) = f ∘ g :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | map_apply | null |
map_id : @map X Y Y _ id = id := rfl
@[simp] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | map_id | null |
map_comp {Y₁ Y₂ Y₃ : Type*} (g : Y₂ → Y₃) (f : Y₁ → Y₂) :
@map X _ _ _ g ∘ map f = map (g ∘ f) := rfl | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | map_comp | null |
flip {X α β : Type*} [TopologicalSpace X] (f : LocallyConstant X (α → β)) (a : α) :
LocallyConstant X β :=
f.map fun f => f a | def | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | flip | Given a locally constant function to `α → β`, construct a family of locally constant
functions with values in β indexed by α. |
unflip {X α β : Type*} [Finite α] [TopologicalSpace X] (f : α → LocallyConstant X β) :
LocallyConstant X (α → β) where
toFun x a := f a x
isLocallyConstant := IsLocallyConstant.iff_isOpen_fiber.2 fun g => by
have : (fun (x : X) (a : α) => f a x) ⁻¹' {g} = ⋂ a : α, f a ⁻¹' {g a} := by
ext; simp [funext_iff]
rw [this]
exact isOpen_iInter_of_finite fun a => (f a).isLocallyConstant _
@[simp] | def | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | unflip | If α is finite, this constructs a locally constant function to `α → β` given a
family of locally constant functions with values in β indexed by α. |
unflip_flip {X α β : Type*} [Finite α] [TopologicalSpace X]
(f : LocallyConstant X (α → β)) : unflip f.flip = f := rfl
@[simp] | theorem | Topology | [
"Mathlib.Algebra.Notation.Indicator",
"Mathlib.Tactic.FinCases",
"Mathlib.Topology.Connected.LocallyConnected",
"Mathlib.Topology.Sets.Closeds"
] | Mathlib/Topology/LocallyConstant/Basic.lean | unflip_flip | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.