ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- continuum_le_cardinal_of_isOpen
theorem continuum_le_cardinal_of_isOpen
    {E : Type*} (𝕜 : Type*) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [AddCommGroup E]
    [Module 𝕜 E] [Nontrivial E] [TopologicalSpace E] [ContinuousAdd E] [ContinuousSMul 𝕜 E]
    {s : Set E} (hs : IsOpen s) (h's : s.Nonempty) : 𝔠 ≤ #s 
Arguments: {E : Type u_1} (𝕜 : Type u_2) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [AddCommGroup E] [Module 𝕜 E] [Nontrivial E] [TopologicalSpace E] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {s : Set E} (hs : IsOpen s) (h's : s.Nonempty)
Goal: 𝔠 ≤ #↑s
-- Set.Countable.dense_compl
theorem Set.Countable.dense_compl
    {E : Type u} (𝕜 : Type*) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [AddCommGroup E]
    [Module 𝕜 E] [Nontrivial E] [TopologicalSpace E] [ContinuousAdd E] [ContinuousSMul 𝕜 E]
    {s : Set E} (hs : s.Countable) : Dense sᶜ 
Arguments: {E : Type u} (𝕜 : Type u_1) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [AddCommGroup E] [Module 𝕜 E] [Nontrivial E] [TopologicalSpace E] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {s : Set E} (hs : s.Countable)
Goal: Dense sᶜ
-- WeakDual.CharacterSpace.coe_coe
@[simp, norm_cast]
protected theorem coe_coe (φ : characterSpace 𝕜 A) : ⇑(φ : WeakDual 𝕜 A) = (φ : A → 𝕜) 
Arguments: {𝕜 : Type u_1} {A : Type u_2} [CommSemiring 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [ContinuousConstSMul 𝕜 𝕜] [NonUnitalNonAssocSemiring A] [TopologicalSpace A] [Module 𝕜 A] (φ : ↑(WeakDual.characterSpace 𝕜 A))
Goal: ⇑↑φ = ⇑φ
-- WeakDual.CharacterSpace.ext
@[ext]
theorem ext {φ ψ : characterSpace 𝕜 A} (h : ∀ x, φ x = ψ x) : φ = ψ 
Arguments: {𝕜 : Type u_1} {A : Type u_2} [CommSemiring 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [ContinuousConstSMul 𝕜 𝕜] [NonUnitalNonAssocSemiring A] [TopologicalSpace A] [Module 𝕜 A] {φ ψ : ↑(WeakDual.characterSpace 𝕜 A)} (h : ∀ (x : A), φ x = ψ x)
Goal: φ = ψ
-- WeakDual.CharacterSpace.coe_toCLM
@[simp]
theorem coe_toCLM (φ : characterSpace 𝕜 A) : ⇑(toCLM φ) = φ 
Arguments: {𝕜 : Type u_1} {A : Type u_2} [CommSemiring 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [ContinuousConstSMul 𝕜 𝕜] [NonUnitalNonAssocSemiring A] [TopologicalSpace A] [Module 𝕜 A] (φ : ↑(WeakDual.characterSpace 𝕜 A))
Goal: ⇑(WeakDual.CharacterSpace.toCLM φ) = ⇑φ
-- WeakDual.CharacterSpace.coe_toNonUnitalAlgHom
@[simp]
theorem coe_toNonUnitalAlgHom (φ : characterSpace 𝕜 A) : ⇑(toNonUnitalAlgHom φ) = φ 
Arguments: {𝕜 : Type u_1} {A : Type u_2} [CommSemiring 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [ContinuousConstSMul 𝕜 𝕜] [NonUnitalNonAssocSemiring A] [TopologicalSpace A] [Module 𝕜 A] (φ : ↑(WeakDual.characterSpace 𝕜 A))
Goal: ⇑(WeakDual.CharacterSpace.toNonUnitalAlgHom φ) = ⇑φ
-- WeakDual.CharacterSpace.union_zero
theorem union_zero :
    characterSpace 𝕜 A ∪ {0} = {φ : WeakDual 𝕜 A | ∀ x y : A, φ (x * y) = φ x * φ y} 
Arguments: (𝕜 : Type u_1) (A : Type u_2) [CommSemiring 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [ContinuousConstSMul 𝕜 𝕜] [NonUnitalNonAssocSemiring A] [TopologicalSpace A] [Module 𝕜 A]
Goal: WeakDual.characterSpace 𝕜 A ∪ {0} = {φ | ∀ (x y : A), φ (x * y) = φ x * φ y}
-- WeakDual.CharacterSpace.union_zero_isClosed
theorem union_zero_isClosed [T2Space 𝕜] [ContinuousMul 𝕜] :
    IsClosed (characterSpace 𝕜 A ∪ {0}) 
Arguments: (𝕜 : Type u_1) (A : Type u_2) [CommSemiring 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [ContinuousConstSMul 𝕜 𝕜] [NonUnitalNonAssocSemiring A] [TopologicalSpace A] [Module 𝕜 A] [T2Space 𝕜] [ContinuousMul 𝕜]
Goal: IsClosed (WeakDual.characterSpace 𝕜 A ∪ {0})
-- WeakDual.CharacterSpace.toAlgHom_apply
@[simps]
def toAlgHom (φ : characterSpace 𝕜 A) : A →ₐ[𝕜] 𝕜 
Arguments: {𝕜 : Type u_1} {A : Type u_2} [CommRing 𝕜] [NoZeroDivisors 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [ContinuousConstSMul 𝕜 𝕜] [TopologicalSpace A] [Semiring A] [Algebra 𝕜 A] (φ : ↑(WeakDual.characterSpace 𝕜 A))
Goal: ∀ (a : A), (WeakDual.CharacterSpace.toAlgHom φ) a = (WeakDual.CharacterSpace.toNonUnitalAlgHom φ).toFun a
-- WeakDual.CharacterSpace.eq_set_map_one_map_mul
theorem eq_set_map_one_map_mul [Nontrivial 𝕜] :
    characterSpace 𝕜 A = {φ : WeakDual 𝕜 A | φ 1 = 1 ∧ ∀ x y : A, φ (x * y) = φ x * φ y} 
Arguments: {𝕜 : Type u_1} {A : Type u_2} [CommRing 𝕜] [NoZeroDivisors 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [ContinuousConstSMul 𝕜 𝕜] [TopologicalSpace A] [Semiring A] [Algebra 𝕜 A] [Nontrivial 𝕜]
Goal: WeakDual.characterSpace 𝕜 A = {φ | φ 1 = 1 ∧ ∀ (x y : A), φ (x * y) = φ x * φ y}
-- WeakDual.CharacterSpace.isClosed
protected theorem isClosed [Nontrivial 𝕜] [T2Space 𝕜] [ContinuousMul 𝕜] :
    IsClosed (characterSpace 𝕜 A) 
Arguments: {𝕜 : Type u_1} {A : Type u_2} [CommRing 𝕜] [NoZeroDivisors 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [ContinuousConstSMul 𝕜 𝕜] [TopologicalSpace A] [Semiring A] [Algebra 𝕜 A] [Nontrivial 𝕜] [T2Space 𝕜] [ContinuousMul 𝕜]
Goal: IsClosed (WeakDual.characterSpace 𝕜 A)
-- WeakDual.CharacterSpace.apply_mem_spectrum
theorem apply_mem_spectrum [Nontrivial 𝕜] (φ : characterSpace 𝕜 A) (a : A) : φ a ∈ spectrum 𝕜 a 
Arguments: {𝕜 : Type u_1} {A : Type u_2} [CommRing 𝕜] [NoZeroDivisors 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [ContinuousConstSMul 𝕜 𝕜] [TopologicalSpace A] [Ring A] [Algebra 𝕜 A] [Nontrivial 𝕜] (φ : ↑(WeakDual.characterSpace 𝕜 A)) (a : A)
Goal: φ a ∈ spectrum 𝕜 a
-- WeakDual.CharacterSpace.ext_ker
theorem ext_ker {φ ψ : characterSpace 𝕜 A} (h : RingHom.ker φ = RingHom.ker ψ) : φ = ψ 
Arguments: {𝕜 : Type u_1} {A : Type u_2} [CommRing 𝕜] [NoZeroDivisors 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [ContinuousConstSMul 𝕜 𝕜] [TopologicalSpace A] [Ring A] [Algebra 𝕜 A] {φ ψ : ↑(WeakDual.characterSpace 𝕜 A)} (h : RingHom.ker φ = RingHom.ker ψ)
Goal: φ = ψ
-- WeakDual.gelfandTransform_apply_apply
@[simps]
def gelfandTransform : A →ₐ[𝕜] C(characterSpace 𝕜 A, 𝕜) 
Arguments: (𝕜 : Type u_1) (A : Type u_2) [CommRing 𝕜] [NoZeroDivisors 𝕜] [TopologicalSpace 𝕜] [TopologicalRing 𝕜] [TopologicalSpace A] [Semiring A] [Algebra 𝕜 A] (a : A) (φ : ↑(WeakDual.characterSpace 𝕜 A))
Goal: ((WeakDual.gelfandTransform 𝕜 A) a) φ = φ a
-- UniformContinuousConstVAdd.uniformContinuous_const_vadd
class UniformContinuousConstVAdd [VAdd M X] : Prop where
  uniformContinuous_const_vadd : ∀ c : M, UniformContinuous (c +ᵥ · : X → X)
Arguments: {M : Type v} {X : Type x} [UniformSpace X] [VAdd M X] [self : UniformContinuousConstVAdd M X] (c : M)
Goal: UniformContinuous fun x => c +ᵥ x
-- UniformContinuousConstSMul.uniformContinuous_const_smul
@[to_additive]
class UniformContinuousConstSMul [SMul M X] : Prop where
  uniformContinuous_const_smul : ∀ c : M, UniformContinuous (c • · : X → X)
Arguments: {M : Type v} {X : Type x} [UniformSpace X] [SMul M X] [self : UniformContinuousConstSMul M X] (c : M)
Goal: UniformContinuous fun x => c • x
-- uniformContinuousConstSMul_of_continuousConstSMul
theorem uniformContinuousConstSMul_of_continuousConstSMul [Monoid R] [AddCommGroup M]
    [DistribMulAction R M] [UniformSpace M] [UniformAddGroup M] [ContinuousConstSMul R M] :
    UniformContinuousConstSMul R M 
Arguments: (R : Type u) (M : Type v) [Monoid R] [AddCommGroup M] [DistribMulAction R M] [UniformSpace M] [UniformAddGroup M] [ContinuousConstSMul R M]
Goal: UniformContinuousConstSMul R M
-- UniformContinuous.const_vadd
@[to_additive]
theorem UniformContinuous.const_smul [UniformContinuousConstSMul M X] {f : Y → X}
    (hf : UniformContinuous f) (c : M) : UniformContinuous (c • f) 
Arguments: {M : Type v} {X : Type x} {Y : Type y} [UniformSpace X] [UniformSpace Y] [VAdd M X] [UniformContinuousConstVAdd M X] {f : Y → X} (hf : UniformContinuous f) (c : M)
Goal: UniformContinuous (c +ᵥ f)
-- UniformContinuous.const_smul
@[to_additive]
theorem UniformContinuous.const_smul [UniformContinuousConstSMul M X] {f : Y → X}
    (hf : UniformContinuous f) (c : M) : UniformContinuous (c • f) 
Arguments: {M : Type v} {X : Type x} {Y : Type y} [UniformSpace X] [UniformSpace Y] [SMul M X] [UniformContinuousConstSMul M X] {f : Y → X} (hf : UniformContinuous f) (c : M)
Goal: UniformContinuous (c • f)
-- UniformInducing.uniformContinuousConstSMul
@[to_additive]
lemma UniformInducing.uniformContinuousConstSMul [SMul M Y] [UniformContinuousConstSMul M Y]
    {f : X → Y} (hf : UniformInducing f) (hsmul : ∀ (c : M) x, f (c • x) = c • f x) :
    UniformContinuousConstSMul M X 
Arguments: {M : Type v} {X : Type x} {Y : Type y} [UniformSpace X] [UniformSpace Y] [SMul M X] [SMul M Y] [UniformContinuousConstSMul M Y] {f : X → Y} (hf : UniformInducing f) (hsmul : ∀ (c : M) (x : X), f (c • x) = c • f x)
Goal: UniformContinuousConstSMul M X
-- UniformInducing.uniformContinuousConstVAdd
@[to_additive]
lemma UniformInducing.uniformContinuousConstSMul [SMul M Y] [UniformContinuousConstSMul M Y]
    {f : X → Y} (hf : UniformInducing f) (hsmul : ∀ (c : M) x, f (c • x) = c • f x) :
    UniformContinuousConstSMul M X 
Arguments: {M : Type v} {X : Type x} {Y : Type y} [UniformSpace X] [UniformSpace Y] [VAdd M X] [VAdd M Y] [UniformContinuousConstVAdd M Y] {f : X → Y} (hf : UniformInducing f) (hsmul : ∀ (c : M) (x : X), f (c +ᵥ x) = c +ᵥ f x)
Goal: UniformContinuousConstVAdd M X
-- UniformSpace.Completion.vadd_def
@[to_additive]
theorem smul_def (c : M) (x : Completion X) : c • x = Completion.map (c • ·) x 
Arguments: (M : Type v) (X : Type x) [UniformSpace X] [VAdd M X] (c : M) (x : UniformSpace.Completion X)
Goal: c +ᵥ x = UniformSpace.Completion.map (fun x => c +ᵥ x) x
-- UniformSpace.Completion.smul_def
@[to_additive]
theorem smul_def (c : M) (x : Completion X) : c • x = Completion.map (c • ·) x 
Arguments: (M : Type v) (X : Type x) [UniformSpace X] [SMul M X] (c : M) (x : UniformSpace.Completion X)
Goal: c • x = UniformSpace.Completion.map (fun x => c • x) x
-- UniformSpace.Completion.coe_vadd
@[to_additive (attr := simp, norm_cast)]
theorem coe_smul (c : M) (x : X) : (↑(c • x) : Completion X) = c • (x : Completion X) 
Arguments: {M : Type v} {X : Type x} [UniformSpace X] [VAdd M X] [UniformContinuousConstVAdd M X] (c : M) (x : X)
Goal: ↑X (c +ᵥ x) = c +ᵥ ↑X x
-- UniformSpace.Completion.coe_smul
@[to_additive (attr := simp, norm_cast)]
theorem coe_smul (c : M) (x : X) : (↑(c • x) : Completion X) = c • (x : Completion X) 
Arguments: {M : Type v} {X : Type x} [UniformSpace X] [SMul M X] [UniformContinuousConstSMul M X] (c : M) (x : X)
Goal: ↑X (c • x) = c • ↑X x
-- Bornology.IsVonNBounded.image_multilinear'
theorem image_multilinear' [Nonempty ι] {s : Set (∀ i, E i)} (hs : IsVonNBounded 𝕜 s)
    (f : ContinuousMultilinearMap 𝕜 E F) : IsVonNBounded 𝕜 (f '' s) 
Arguments: {ι : Type u_1} {𝕜 : Type u_2} {F : Type u_3} {E : ι → Type u_4} [NormedField 𝕜] [(i : ι) → AddCommGroup (E i)] [(i : ι) → Module 𝕜 (E i)] [(i : ι) → TopologicalSpace (E i)] [AddCommGroup F] [Module 𝕜 F] [TopologicalSpace F] [Nonempty ι] {s : Set ((i : ι) → E i)} (hs : Bornology.IsVonNBounded 𝕜 s) (f : ContinuousMultilinearMap 𝕜 E F)
Goal: Bornology.IsVonNBounded 𝕜 (⇑f '' s)
-- Bornology.IsVonNBounded.image_multilinear
theorem image_multilinear [ContinuousSMul 𝕜 F] {s : Set (∀ i, E i)} (hs : IsVonNBounded 𝕜 s)
    (f : ContinuousMultilinearMap 𝕜 E F) : IsVonNBounded 𝕜 (f '' s) 
Arguments: {ι : Type u_1} {𝕜 : Type u_2} {F : Type u_3} {E : ι → Type u_4} [NormedField 𝕜] [(i : ι) → AddCommGroup (E i)] [(i : ι) → Module 𝕜 (E i)] [(i : ι) → TopologicalSpace (E i)] [AddCommGroup F] [Module 𝕜 F] [TopologicalSpace F] [ContinuousSMul 𝕜 F] {s : Set ((i : ι) → E i)} (hs : Bornology.IsVonNBounded 𝕜 s) (f : ContinuousMultilinearMap 𝕜 E F)
Goal: Bornology.IsVonNBounded 𝕜 (⇑f '' s)
-- ProperConstVAdd.isProperMap_vadd
class ProperConstVAdd (M X : Type*) [VAdd M X] [TopologicalSpace X] : Prop where
    isProperMap_vadd (c : M) : IsProperMap ((c +ᵥ ·) : X → X)
Arguments: {M : Type u_1} {X : Type u_2} [VAdd M X] [TopologicalSpace X] [self : ProperConstVAdd M X] (c : M)
Goal: IsProperMap fun x => c +ᵥ x
-- ProperConstSMul.isProperMap_smul
@[to_additive]
class ProperConstSMul (M X : Type*) [SMul M X] [TopologicalSpace X] : Prop where
    isProperMap_smul (c : M) : IsProperMap ((c • ·) : X → X)
Arguments: {M : Type u_1} {X : Type u_2} [SMul M X] [TopologicalSpace X] [self : ProperConstSMul M X] (c : M)
Goal: IsProperMap fun x => c • x
-- isProperMap_smul
@[to_additive "`(c +ᵥ ·)` is a proper map."]
theorem isProperMap_smul {M : Type*} (c : M) (X : Type*) [SMul M X] [TopologicalSpace X]
    [h : ProperConstSMul M X] : IsProperMap ((c • ·) : X → X) 
Arguments: {M : Type u_1} (c : M) (X : Type u_2) [SMul M X] [TopologicalSpace X] [h : ProperConstSMul M X]
Goal: IsProperMap fun x => c • x
-- isProperMap_vadd
@[to_additive "`(c +ᵥ ·)` is a proper map."]
theorem isProperMap_smul {M : Type*} (c : M) (X : Type*) [SMul M X] [TopologicalSpace X]
    [h : ProperConstSMul M X] : IsProperMap ((c • ·) : X → X) 
Arguments: {M : Type u_1} (c : M) (X : Type u_2) [VAdd M X] [TopologicalSpace X] [h : ProperConstVAdd M X]
Goal: IsProperMap fun x => c +ᵥ x
-- IsCompact.preimage_smul
@[to_additive "The preimage of a compact set under `(c +ᵥ ·)` is a compact set."]
theorem IsCompact.preimage_smul {M X : Type*} [SMul M X] [TopologicalSpace X]
    [ProperConstSMul M X] {s : Set X} (hs : IsCompact s) (c : M) : IsCompact ((c • ·) ⁻¹' s) 
Arguments: {M : Type u_1} {X : Type u_2} [SMul M X] [TopologicalSpace X] [ProperConstSMul M X] {s : Set X} (hs : IsCompact s) (c : M)
Goal: IsCompact ((fun x => c • x) ⁻¹' s)
-- IsCompact.preimage_vadd
@[to_additive "The preimage of a compact set under `(c +ᵥ ·)` is a compact set."]
theorem IsCompact.preimage_smul {M X : Type*} [SMul M X] [TopologicalSpace X]
    [ProperConstSMul M X] {s : Set X} (hs : IsCompact s) (c : M) : IsCompact ((c • ·) ⁻¹' s) 
Arguments: {M : Type u_1} {X : Type u_2} [VAdd M X] [TopologicalSpace X] [ProperConstVAdd M X] {s : Set X} (hs : IsCompact s) (c : M)
Goal: IsCompact ((fun x => c +ᵥ x) ⁻¹' s)
-- MvPolynomial.continuous_eval
theorem MvPolynomial.continuous_eval : Continuous fun x ↦ eval x p 
Arguments: {X : Type u_1} {σ : Type u_2} [TopologicalSpace X] [CommSemiring X] [TopologicalSemiring X] (p : MvPolynomial σ X)
Goal: Continuous fun x => (MvPolynomial.eval x) p
-- ContinuousStar.continuous_star
class ContinuousStar (R : Type*) [TopologicalSpace R] [Star R] : Prop where
    continuous_star : Continuous (star : R → R)
Arguments: {R : Type u_1} [TopologicalSpace R] [Star R] [self : ContinuousStar R]
Goal: Continuous star
-- continuousOn_star
theorem continuousOn_star {s : Set R} : ContinuousOn star s 
Arguments: {R : Type u_2} [TopologicalSpace R] [Star R] [ContinuousStar R] {s : Set R}
Goal: ContinuousOn star s
-- continuousWithinAt_star
theorem continuousWithinAt_star {s : Set R} {x : R} : ContinuousWithinAt star s x 
Arguments: {R : Type u_2} [TopologicalSpace R] [Star R] [ContinuousStar R] {s : Set R} {x : R}
Goal: ContinuousWithinAt star s x
-- continuousAt_star
theorem continuousAt_star {x : R} : ContinuousAt star x 
Arguments: {R : Type u_2} [TopologicalSpace R] [Star R] [ContinuousStar R] {x : R}
Goal: ContinuousAt star x
-- tendsto_star
theorem tendsto_star (a : R) : Tendsto star (𝓝 a) (𝓝 (star a)) 
Arguments: {R : Type u_2} [TopologicalSpace R] [Star R] [ContinuousStar R] (a : R)
Goal: Filter.Tendsto star (𝓝 a) (𝓝 (star a))
-- Filter.Tendsto.star
theorem Filter.Tendsto.star {f : α → R} {l : Filter α} {y : R} (h : Tendsto f l (𝓝 y)) :
    Tendsto (fun x => star (f x)) l (𝓝 (star y)) 
Arguments: {α : Type u_1} {R : Type u_2} [TopologicalSpace R] [Star R] [ContinuousStar R] {f : α → R} {l : Filter α} {y : R} (h : Filter.Tendsto f l (𝓝 y))
Goal: Filter.Tendsto (fun x => star (f x)) l (𝓝 (star y))
-- Continuous.star
@[continuity, fun_prop]
theorem Continuous.star (hf : Continuous f) : Continuous fun x => star (f x) 
Arguments: {α : Type u_1} {R : Type u_2} [TopologicalSpace R] [Star R] [ContinuousStar R] [TopologicalSpace α] {f : α → R} (hf : Continuous f)
Goal: Continuous fun x => star (f x)
-- ContinuousAt.star
@[fun_prop]
theorem ContinuousAt.star (hf : ContinuousAt f x) : ContinuousAt (fun x => star (f x)) x 
Arguments: {α : Type u_1} {R : Type u_2} [TopologicalSpace R] [Star R] [ContinuousStar R] [TopologicalSpace α] {f : α → R} {x : α} (hf : ContinuousAt f x)
Goal: ContinuousAt (fun x => star (f x)) x
-- ContinuousOn.star
@[fun_prop]
theorem ContinuousOn.star (hf : ContinuousOn f s) : ContinuousOn (fun x => star (f x)) s 
Arguments: {α : Type u_1} {R : Type u_2} [TopologicalSpace R] [Star R] [ContinuousStar R] [TopologicalSpace α] {f : α → R} {s : Set α} (hf : ContinuousOn f s)
Goal: ContinuousOn (fun x => star (f x)) s
-- ContinuousWithinAt.star
theorem ContinuousWithinAt.star (hf : ContinuousWithinAt f s x) :
    ContinuousWithinAt (fun x => star (f x)) s x 
Arguments: {α : Type u_1} {R : Type u_2} [TopologicalSpace R] [Star R] [ContinuousStar R] [TopologicalSpace α] {f : α → R} {s : Set α} {x : α} (hf : ContinuousWithinAt f s x)
Goal: ContinuousWithinAt (fun x => star (f x)) s x
-- starContinuousMap_apply
@[simps]
def starContinuousMap : C(R, R) 
Arguments: {R : Type u_2} [TopologicalSpace R] [Star R] [ContinuousStar R]
Goal: ∀ (a : R), starContinuousMap a = star a
-- TopCat.Presheaf.stalkFunctor_obj
@[simp]
theorem stalkFunctor_obj (ℱ : X.Presheaf C) (x : X) : (stalkFunctor C x).obj ℱ = ℱ.stalk x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (ℱ : TopCat.Presheaf C X) (x : ↑X)
Goal: (TopCat.Presheaf.stalkFunctor C x).obj ℱ = ℱ.stalk x
-- TopCat.Presheaf.germ_res
@[reassoc (attr := simp)]
theorem germ_res (F : X.Presheaf C) {U V : Opens X} (i : U ⟶ V) (x : U) :
    F.map i.op ≫ germ F x = germ F (i x : V) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U V : TopologicalSpace.Opens ↑X} (i : U ⟶ V) (x : ↥U)
Goal: F.map i.op ≫ F.germ x = F.germ ((fun x => ⟨↑x, ⋯⟩) x)
-- TopCat.Presheaf.map_germ_eq_Γgerm
@[reassoc]
lemma map_germ_eq_Γgerm (F : X.Presheaf C) {U : Opens X} {i : U ⟶ ⊤} (x : U) :
    F.map i.op ≫ germ F x = Γgerm F (i x) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {i : U ⟶ ⊤} (x : ↥U)
Goal: F.map i.op ≫ F.germ x = F.Γgerm ↑((fun x => ⟨↑x, ⋯⟩) x)
-- TopCat.Presheaf.germ_res_apply
theorem germ_res_apply (F : X.Presheaf C) {U V : Opens X} (i : U ⟶ V) (x : U) [ConcreteCategory C]
    (s) : germ F x (F.map i.op s) = germ F (i x) s 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U V : TopologicalSpace.Opens ↑X} (i : U ⟶ V) (x : ↥U) [CategoryTheory.ConcreteCategory C] (s : (CategoryTheory.forget C).obj (F.obj (Opposite.op V)))
Goal: (F.germ x) ((F.map i.op) s) = (F.germ ((fun x => ⟨↑x, ⋯⟩) x)) s
-- TopCat.Presheaf.Γgerm_res_apply
lemma Γgerm_res_apply (F : X.Presheaf C) {U : Opens X} {i : U ⟶ ⊤} (x : U) [ConcreteCategory C]
    (s) : germ F x (F.map i.op s) = Γgerm F x.val s 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {i : U ⟶ ⊤} (x : ↥U) [CategoryTheory.ConcreteCategory C] (s : (CategoryTheory.forget C).obj (F.obj (Opposite.op ⊤)))
Goal: (F.germ x) ((F.map i.op) s) = (F.Γgerm ↑x) s
-- TopCat.Presheaf.stalk_hom_ext
@[ext]
theorem stalk_hom_ext (F : X.Presheaf C) {x} {Y : C} {f₁ f₂ : F.stalk x ⟶ Y}
    (ih : ∀ (U : Opens X) (hxU : x ∈ U), F.germ ⟨x, hxU⟩ ≫ f₁ = F.germ ⟨x, hxU⟩ ≫ f₂) : f₁ = f₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {x : ↑X} {Y : C} {f₁ f₂ : F.stalk x ⟶ Y} (ih : ∀ (U : TopologicalSpace.Opens ↑X) (hxU : x ∈ U), F.germ ⟨x, hxU⟩ ≫ f₁ = F.germ ⟨x, hxU⟩ ≫ f₂)
Goal: f₁ = f₂
-- TopCat.Presheaf.stalkFunctor_map_germ
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem stalkFunctor_map_germ {F G : X.Presheaf C} (U : Opens X) (x : U) (f : F ⟶ G) :
    germ F x ≫ (stalkFunctor C x.1).map f = f.app (op U) ≫ germ G x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {F G : TopCat.Presheaf C X} (U : TopologicalSpace.Opens ↑X) (x : ↥U) (f : F ⟶ G)
Goal: F.germ x ≫ (TopCat.Presheaf.stalkFunctor C ↑x).map f = f.app (Opposite.op U) ≫ G.germ x
-- TopCat.Presheaf.stalkPushforward_germ
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem stalkPushforward_germ (f : X ⟶ Y) (F : X.Presheaf C) (U : Opens Y)
    (x : (Opens.map f).obj U) :
      (f _* F).germ ⟨(f : X → Y) (x : X), x.2⟩ ≫ F.stalkPushforward C f x = F.germ x 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C X) (U : TopologicalSpace.Opens ↑Y) (x : ↥((TopologicalSpace.Opens.map f).obj U))
Goal: ((TopCat.Presheaf.pushforward C f).obj F).germ ⟨f ↑x, ⋯⟩ ≫ TopCat.Presheaf.stalkPushforward C f F ↑x = F.germ x
-- TopCat.Presheaf.stalkPushforward.id
@[simp]
theorem id (ℱ : X.Presheaf C) (x : X) :
    ℱ.stalkPushforward C (𝟙 X) x = (stalkFunctor C x).map (Pushforward.id ℱ).hom 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (ℱ : TopCat.Presheaf C X) (x : ↑X)
Goal: TopCat.Presheaf.stalkPushforward C (𝟙 X) ℱ x =
  (TopCat.Presheaf.stalkFunctor C x).map (TopCat.Presheaf.Pushforward.id ℱ).hom
-- TopCat.Presheaf.stalkPushforward.comp
@[simp]
theorem comp (ℱ : X.Presheaf C) (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) :
    ℱ.stalkPushforward C (f ≫ g) x =
      (f _* ℱ).stalkPushforward C g (f x) ≫ ℱ.stalkPushforward C f x 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X Y Z : TopCat} (ℱ : TopCat.Presheaf C X) (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X)
Goal: TopCat.Presheaf.stalkPushforward C (f ≫ g) ℱ x =
  TopCat.Presheaf.stalkPushforward C g ((TopCat.Presheaf.pushforward C f).obj ℱ) (f x) ≫
    TopCat.Presheaf.stalkPushforward C f ℱ x
-- TopCat.Presheaf.stalkPushforward.stalkPushforward_iso_of_openEmbedding
theorem stalkPushforward_iso_of_openEmbedding {f : X ⟶ Y} (hf : OpenEmbedding f) (F : X.Presheaf C)
    (x : X) : IsIso (F.stalkPushforward _ f x) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X Y : TopCat} {f : X ⟶ Y} (hf : OpenEmbedding ⇑f) (F : TopCat.Presheaf C X) (x : ↑X)
Goal: CategoryTheory.IsIso (TopCat.Presheaf.stalkPushforward C f F x)
-- TopCat.Presheaf.germ_stalkPullbackHom
@[reassoc (attr := simp)]
lemma germ_stalkPullbackHom
    (f : X ⟶ Y) (F : Y.Presheaf C) (x : X) (U : Opens Y) (hU : f x ∈ U) :
    F.germ ⟨f x, hU⟩ ≫ stalkPullbackHom C f F x =
      ((pushforwardPullbackAdjunction C f).unit.app F).app _ ≫
        ((pullback C f).obj F).germ ⟨x, show x ∈ (Opens.map f).obj U from hU⟩ 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C Y) (x : ↑X) (U : TopologicalSpace.Opens ↑Y) (hU : f x ∈ U)
Goal: F.germ ⟨f x, hU⟩ ≫ TopCat.Presheaf.stalkPullbackHom C f F x =
  ((TopCat.Presheaf.pushforwardPullbackAdjunction C f).unit.app F).app (Opposite.op U) ≫
    ((TopCat.Presheaf.pullback C f).obj F).germ ⟨x, ⋯⟩
-- TopCat.Presheaf.pullback_obj_obj_ext
@[ext]
lemma pullback_obj_obj_ext {Z : C} {f : X ⟶ Y} {F : Y.Presheaf C} (U : (Opens X)ᵒᵖ)
    {φ ψ : ((pullback C f).obj F).obj U ⟶ Z}
    (h : ∀ (V : Opens Y) (hV : U.unop ≤ (Opens.map f).obj V),
      ((pushforwardPullbackAdjunction C f).unit.app F).app (op V) ≫
        ((pullback C f).obj F).map (homOfLE hV).op ≫ φ =
      ((pushforwardPullbackAdjunction C f).unit.app F).app (op V) ≫
        ((pullback C f).obj F).map (homOfLE hV).op ≫ ψ) : φ = ψ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X Y : TopCat} {Z : C} {f : X ⟶ Y} {F : TopCat.Presheaf C Y} (U : (TopologicalSpace.Opens ↑X)ᵒᵖ) {φ ψ : ((TopCat.Presheaf.pullback C f).obj F).obj U ⟶ Z} (h :
  ∀ (V : TopologicalSpace.Opens ↑Y) (hV : Opposite.unop U ≤ (TopologicalSpace.Opens.map f).obj V),
    ((TopCat.Presheaf.pushforwardPullbackAdjunction C f).unit.app F).app (Opposite.op V) ≫
        ((TopCat.Presheaf.pullback C f).obj F).map (CategoryTheory.homOfLE hV).op ≫ φ =
      ((TopCat.Presheaf.pushforwardPullbackAdjunction C f).unit.app F).app (Opposite.op V) ≫
        ((TopCat.Presheaf.pullback C f).obj F).map (CategoryTheory.homOfLE hV).op ≫ ψ)
Goal: φ = ψ