ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ContinuousMap.inf_apply
@[simp] lemma inf_apply (f g : C(α, β)) (a : α) : (f ⊓ g) a = f a ⊓ g a 
Arguments: {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] [SemilatticeInf β] [ContinuousInf β] (f g : C(α, β)) (a : α)
Goal: (f ⊓ g) a = f a ⊓ g a
-- ContinuousMap.inf'_apply
lemma inf'_apply {ι : Type*} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) (a : α) :
    s.inf' H f a = s.inf' H fun i ↦ f i a 
Arguments: {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] [SemilatticeInf β] [ContinuousInf β] {ι : Type u_4} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) (a : α)
Goal: (s.inf' H f) a = s.inf' H fun i => (f i) a
-- ContinuousMap.coe_inf'
@[simp, norm_cast]
lemma coe_inf' {ι : Type*} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) :
    ⇑(s.inf' H f) = s.inf' H fun i ↦ ⇑(f i) 
Arguments: {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] [SemilatticeInf β] [ContinuousInf β] {ι : Type u_4} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β))
Goal: ⇑(s.inf' H f) = s.inf' H fun i => ⇑(f i)
-- ContinuousMap.coe_IccExtend
@[simp]
theorem coe_IccExtend (f : C(Set.Icc a b, β)) :
    ((IccExtend h f : C(α, β)) : α → β) = Set.IccExtend h f 
Arguments: {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] [LinearOrder α] [OrderTopology α] {a b : α} (h : a ≤ b) (f : C(↑(Set.Icc a b), β))
Goal: ⇑(ContinuousMap.IccExtend h f) = Set.IccExtend h ⇑f
-- ContinuousMap.val_addUnitsLift_apply_apply
-- Porting note: `simps` made bad `simp` lemmas (LHS simplifies) so we add them manually below
@[to_additive (attr := simps apply_val_apply symm_apply_apply_val)
"Equivalence between continuous maps into the additive units of an additive monoid with continuous
addition and the additive units of the additive monoid of continuous maps."]
def unitsLift : C(X, Mˣ) ≃ C(X, M)ˣ 
Arguments: {X : Type u_1} {M : Type u_2} [TopologicalSpace X] [AddMonoid M] [TopologicalSpace M] [ContinuousAdd M] (f : C(X, AddUnits M)) (x : X)
Goal: ↑(ContinuousMap.addUnitsLift f) x = ↑(f x)
-- ContinuousMap.val_unitsLift_apply_apply
-- Porting note: `simps` made bad `simp` lemmas (LHS simplifies) so we add them manually below
@[to_additive (attr := simps apply_val_apply symm_apply_apply_val)
"Equivalence between continuous maps into the additive units of an additive monoid with continuous
addition and the additive units of the additive monoid of continuous maps."]
def unitsLift : C(X, Mˣ) ≃ C(X, M)ˣ 
Arguments: {X : Type u_1} {M : Type u_2} [TopologicalSpace X] [Monoid M] [TopologicalSpace M] [ContinuousMul M] (f : C(X, Mˣ)) (x : X)
Goal: ↑(ContinuousMap.unitsLift f) x = ↑(f x)
-- ContinuousMap.val_unitsLift_symm_apply_apply
-- Porting note: `simps` made bad `simp` lemmas (LHS simplifies) so we add them manually below
@[to_additive (attr := simps apply_val_apply symm_apply_apply_val)
"Equivalence between continuous maps into the additive units of an additive monoid with continuous
addition and the additive units of the additive monoid of continuous maps."]
def unitsLift : C(X, Mˣ) ≃ C(X, M)ˣ 
Arguments: {X : Type u_1} {M : Type u_2} [TopologicalSpace X] [Monoid M] [TopologicalSpace M] [ContinuousMul M] (f : C(X, M)ˣ) (x : X)
Goal: ↑((ContinuousMap.unitsLift.symm f) x) = ↑f x
-- ContinuousMap.val_addUnitsLift_symm_apply_apply
-- Porting note: `simps` made bad `simp` lemmas (LHS simplifies) so we add them manually below
@[to_additive (attr := simps apply_val_apply symm_apply_apply_val)
"Equivalence between continuous maps into the additive units of an additive monoid with continuous
addition and the additive units of the additive monoid of continuous maps."]
def unitsLift : C(X, Mˣ) ≃ C(X, M)ˣ 
Arguments: {X : Type u_1} {M : Type u_2} [TopologicalSpace X] [AddMonoid M] [TopologicalSpace M] [ContinuousAdd M] (f : AddUnits C(X, M)) (x : X)
Goal: ↑((ContinuousMap.addUnitsLift.symm f) x) = ↑f x
-- ContinuousMap.addUnitsLift_apply_neg_apply
@[to_additive (attr := simp)]
lemma unitsLift_apply_inv_apply (f : C(X, Mˣ)) (x : X) :
    (↑(ContinuousMap.unitsLift f)⁻¹ : C(X, M)) x = (f x)⁻¹ 
Arguments: {X : Type u_1} {M : Type u_2} [TopologicalSpace X] [AddMonoid M] [TopologicalSpace M] [ContinuousAdd M] (f : C(X, AddUnits M)) (x : X)
Goal: ↑(-ContinuousMap.addUnitsLift f) x = ↑(-f x)
-- ContinuousMap.unitsLift_apply_inv_apply
@[to_additive (attr := simp)]
lemma unitsLift_apply_inv_apply (f : C(X, Mˣ)) (x : X) :
    (↑(ContinuousMap.unitsLift f)⁻¹ : C(X, M)) x = (f x)⁻¹ 
Arguments: {X : Type u_1} {M : Type u_2} [TopologicalSpace X] [Monoid M] [TopologicalSpace M] [ContinuousMul M] (f : C(X, Mˣ)) (x : X)
Goal: ↑(ContinuousMap.unitsLift f)⁻¹ x = ↑(f x)⁻¹
-- ContinuousMap.addUnitsLift_symm_apply_apply_neg'
@[to_additive (attr := simp)]
lemma unitsLift_symm_apply_apply_inv' (f : C(X, M)ˣ) (x : X) :
    (ContinuousMap.unitsLift.symm f x)⁻¹ = (↑f⁻¹ : C(X, M)) x 
Arguments: {X : Type u_1} {M : Type u_2} [TopologicalSpace X] [AddMonoid M] [TopologicalSpace M] [ContinuousAdd M] (f : AddUnits C(X, M)) (x : X)
Goal: ↑(-(ContinuousMap.addUnitsLift.symm f) x) = ↑(-f) x
-- ContinuousMap.unitsLift_symm_apply_apply_inv'
@[to_additive (attr := simp)]
lemma unitsLift_symm_apply_apply_inv' (f : C(X, M)ˣ) (x : X) :
    (ContinuousMap.unitsLift.symm f x)⁻¹ = (↑f⁻¹ : C(X, M)) x 
Arguments: {X : Type u_1} {M : Type u_2} [TopologicalSpace X] [Monoid M] [TopologicalSpace M] [ContinuousMul M] (f : C(X, M)ˣ) (x : X)
Goal: ↑((ContinuousMap.unitsLift.symm f) x)⁻¹ = ↑f⁻¹ x
-- ContinuousMap.continuous_isUnit_unit
theorem continuous_isUnit_unit {f : C(X, R)} (h : ∀ x, IsUnit (f x)) :
    Continuous fun x => (h x).unit 
Arguments: {X : Type u_1} {R : Type u_3} [TopologicalSpace X] [NormedRing R] [CompleteSpace R] {f : C(X, R)} (h : ∀ (x : X), IsUnit (f x))
Goal: Continuous fun x => ⋯.unit
-- ContinuousMap.unitsOfForallIsUnit_apply
@[simps]
noncomputable def unitsOfForallIsUnit {f : C(X, R)} (h : ∀ x, IsUnit (f x)) : C(X, Rˣ) 
Arguments: {X : Type u_1} {R : Type u_3} [TopologicalSpace X] [NormedRing R] [CompleteSpace R] {f : C(X, R)} (h : ∀ (x : X), IsUnit (f x)) (x : X)
Goal: (ContinuousMap.unitsOfForallIsUnit h) x = ⋯.unit
-- ContinuousMap.isUnit_iff_forall_isUnit
theorem isUnit_iff_forall_isUnit (f : C(X, R)) : IsUnit f ↔ ∀ x, IsUnit (f x) 
Arguments: {X : Type u_1} {R : Type u_3} [TopologicalSpace X] [NormedRing R] [CompleteSpace R] (f : C(X, R))
Goal: IsUnit f ↔ ∀ (x : X), IsUnit (f x)
-- ContinuousMap.isUnit_iff_forall_ne_zero
theorem isUnit_iff_forall_ne_zero (f : C(X, R)) : IsUnit f ↔ ∀ x, f x ≠ 0 
Arguments: {X : Type u_1} {R : Type u_3} [TopologicalSpace X] [NormedDivisionRing R] [CompleteSpace R] (f : C(X, R))
Goal: IsUnit f ↔ ∀ (x : X), f x ≠ 0
-- ContinuousMap.spectrum_eq_preimage_range
theorem spectrum_eq_preimage_range (f : C(X, R)) :
    spectrum 𝕜 f = algebraMap _ _ ⁻¹' Set.range f 
Arguments: {X : Type u_1} {R : Type u_3} {𝕜 : Type u_4} [TopologicalSpace X] [NormedField 𝕜] [NormedDivisionRing R] [Algebra 𝕜 R] [CompleteSpace R] (f : C(X, R))
Goal: spectrum 𝕜 f = ⇑(algebraMap 𝕜 R) ⁻¹' Set.range ⇑f
-- ContinuousMap.spectrum_eq_range
theorem spectrum_eq_range [CompleteSpace 𝕜] (f : C(X, 𝕜)) : spectrum 𝕜 f = Set.range f 
Arguments: {X : Type u_1} {𝕜 : Type u_4} [TopologicalSpace X] [NormedField 𝕜] [CompleteSpace 𝕜] (f : C(X, 𝕜))
Goal: spectrum 𝕜 f = Set.range ⇑f
-- TopCat.PrelocalPredicate.res
structure PrelocalPredicate where
    pred : ∀ {U : Opens X}, (∀ x : U, T x) → Prop
    res : ∀ {U V : Opens X} (i : U ⟶ V) (f : ∀ x : V, T x) (_ : pred f), pred fun x : U => f (i x)
Arguments: {X : TopCat} {T : ↑X → Type v} (self : TopCat.PrelocalPredicate T) {U V : TopologicalSpace.Opens ↑X} (i : U ⟶ V) (f : (x : ↥V) → T ↑x)
Goal: self.pred f → self.pred fun x => f ((fun x => ⟨↑x, ⋯⟩) x)
-- TopCat.continuousPrelocal_pred
@[simps!]
def continuousPrelocal (T : TopCat.{v}) : PrelocalPredicate fun _ : X => T 
Arguments: (X T : TopCat)
Goal: ∀ {x : TopologicalSpace.Opens ↑X} (f : ↥x → ↑T), (X.continuousPrelocal T).pred f = Continuous f
-- TopCat.LocalPredicate.locality
structure LocalPredicate extends PrelocalPredicate T where
    locality :
    ∀ {U : Opens X} (f : ∀ x : U, T x)
      (_ : ∀ x : U, ∃ (V : Opens X) (_ : x.1 ∈ V) (i : V ⟶ U),
        pred fun x : V => f (i x : U)), pred f
Arguments: {X : TopCat} {T : ↑X → Type v} (self : TopCat.LocalPredicate T) {U : TopologicalSpace.Opens ↑X} (f : (x : ↥U) → T ↑x)
Goal: (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ i, self.pred fun x => f ((fun x => ⟨↑x, ⋯⟩) x)) → self.pred f
-- TopCat.PrelocalPredicate.sheafifyOf
theorem PrelocalPredicate.sheafifyOf {T : X → Type v} {P : PrelocalPredicate T} {U : Opens X}
    {f : ∀ x : U, T x} (h : P.pred f) : P.sheafify.pred f 
Arguments: {X : TopCat} {T : ↑X → Type v} {P : TopCat.PrelocalPredicate T} {U : TopologicalSpace.Opens ↑X} {f : (x : ↥U) → T ↑x} (h : P.pred f)
Goal: P.sheafify.pred f
-- TopCat.subpresheafToTypes_map_coe
@[simps!]
def subpresheafToTypes (P : PrelocalPredicate T) : Presheaf (Type v) X 
Arguments: {X : TopCat} {T : ↑X → Type v} (P : TopCat.PrelocalPredicate T) {U V : (TopologicalSpace.Opens ↑X)ᵒᵖ} (i : U ⟶ V) (f : { f // P.pred f }) (x : ↥(Opposite.unop V))
Goal: ↑((TopCat.subpresheafToTypes P).map i f) x = ↑f ⟨↑x, ⋯⟩
-- TopCat.subpresheafToTypes_obj
@[simps!]
def subpresheafToTypes (P : PrelocalPredicate T) : Presheaf (Type v) X 
Arguments: {X : TopCat} {T : ↑X → Type v} (P : TopCat.PrelocalPredicate T) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ)
Goal: (TopCat.subpresheafToTypes P).obj U = { f // P.pred f }
-- TopCat.subpresheafToTypes.isSheaf
theorem isSheaf (P : LocalPredicate T) : (subpresheafToTypes P.toPrelocalPredicate).IsSheaf 
Arguments: {X : TopCat} {T : ↑X → Type v} (P : TopCat.LocalPredicate T)
Goal: (TopCat.subpresheafToTypes P.toPrelocalPredicate).IsSheaf
-- TopCat.subsheafToTypes_val
@[simps]
def subsheafToTypes (P : LocalPredicate T) : Sheaf (Type v) X 
Arguments: {X : TopCat} {T : ↑X → Type v} (P : TopCat.LocalPredicate T)
Goal: (TopCat.subsheafToTypes P).val = TopCat.subpresheafToTypes P.toPrelocalPredicate
-- TopCat.stalkToFiber_germ
theorem stalkToFiber_germ (P : LocalPredicate T) (U : Opens X) (x : U) (f) :
    stalkToFiber P x ((subsheafToTypes P).presheaf.germ x f) = f.1 x 
Arguments: {X : TopCat} {T : ↑X → Type v} (P : TopCat.LocalPredicate T) (U : TopologicalSpace.Opens ↑X) (x : ↥U) (f : (TopCat.subsheafToTypes P).presheaf.obj (Opposite.op U))
Goal: TopCat.stalkToFiber P (↑x) ((TopCat.subsheafToTypes P).presheaf.germ x f) = ↑f x
-- TopCat.stalkToFiber_surjective
theorem stalkToFiber_surjective (P : LocalPredicate T) (x : X)
    (w : ∀ t : T x, ∃ (U : OpenNhds x) (f : ∀ y : U.1, T y) (_ : P.pred f), f ⟨x, U.2⟩ = t) :
    Function.Surjective (stalkToFiber P x) 
Arguments: {X : TopCat} {T : ↑X → Type v} (P : TopCat.LocalPredicate T) (x : ↑X) (w : ∀ (t : T x), ∃ U f, ∃ (_ : P.pred f), f ⟨x, ⋯⟩ = t)
Goal: Function.Surjective (TopCat.stalkToFiber P x)
-- TopCat.stalkToFiber_injective
theorem stalkToFiber_injective (P : LocalPredicate T) (x : X)
    (w :
      ∀ (U V : OpenNhds x) (fU : ∀ y : U.1, T y) (_ : P.pred fU) (fV : ∀ y : V.1, T y)
        (_ : P.pred fV) (_ : fU ⟨x, U.2⟩ = fV ⟨x, V.2⟩),
        ∃ (W : OpenNhds x) (iU : W ⟶ U) (iV : W ⟶ V), ∀ w : W.1,
          fU (iU w : U.1) = fV (iV w : V.1)) :
    Function.Injective (stalkToFiber P x) 
Arguments: {X : TopCat} {T : ↑X → Type v} (P : TopCat.LocalPredicate T) (x : ↑X) (w :
  ∀ (U V : TopologicalSpace.OpenNhds x) (fU : (y : ↥U.obj) → T ↑y),
    P.pred fU →
      ∀ (fV : (y : ↥V.obj) → T ↑y),
        P.pred fV →
          fU ⟨x, ⋯⟩ = fV ⟨x, ⋯⟩ →
            ∃ W iU iV, ∀ (w : ↥W.obj), fU ((fun x_4 => ⟨↑x_4, ⋯⟩) w) = fV ((fun x_4 => ⟨↑x_4, ⋯⟩) w))
Goal: Function.Injective (TopCat.stalkToFiber P x)
-- TopologicalSpace.eq_induced_by_maps_to_sierpinski
theorem eq_induced_by_maps_to_sierpinski (X : Type*) [t : TopologicalSpace X] :
    t = ⨅ u : Opens X, sierpinskiSpace.induced (· ∈ u) 
Arguments: (X : Type u_1) [t : TopologicalSpace X]
Goal: t = ⨅ u, TopologicalSpace.induced (fun x => x ∈ u) sierpinskiSpace
-- TopologicalSpace.productOfMemOpens_inducing
theorem productOfMemOpens_inducing : Inducing (productOfMemOpens X) 
Arguments: (X : Type u_1) [TopologicalSpace X]
Goal: Inducing ⇑(TopologicalSpace.productOfMemOpens X)
-- TopologicalSpace.productOfMemOpens_injective
theorem productOfMemOpens_injective [T0Space X] : Function.Injective (productOfMemOpens X) 
Arguments: (X : Type u_1) [TopologicalSpace X] [T0Space X]
Goal: Function.Injective ⇑(TopologicalSpace.productOfMemOpens X)
-- TopologicalSpace.productOfMemOpens_embedding
theorem productOfMemOpens_embedding [T0Space X] : Embedding (productOfMemOpens X) 
Arguments: (X : Type u_1) [TopologicalSpace X] [T0Space X]
Goal: Embedding ⇑(TopologicalSpace.productOfMemOpens X)
-- TopCat.Presheaf.coveringOfPresieve_apply
@[simp]
theorem coveringOfPresieve_apply (U : Opens X) (R : Presieve U) (f : ΣV, { f : V ⟶ U // R f }) :
    coveringOfPresieve U R f = f.1 
Arguments: {X : TopCat} (U : TopologicalSpace.Opens ↑X) (R : CategoryTheory.Presieve U) (f : (V : TopologicalSpace.Opens ↑X) × { f // R f })
Goal: TopCat.Presheaf.coveringOfPresieve U R f = f.fst
-- TopCat.Presheaf.coveringOfPresieve.iSup_eq_of_mem_grothendieck
theorem iSup_eq_of_mem_grothendieck (hR : Sieve.generate R ∈ Opens.grothendieckTopology X U) :
    iSup (coveringOfPresieve U R) = U 
Arguments: {X : TopCat} (U : TopologicalSpace.Opens ↑X) (R : CategoryTheory.Presieve U) (hR : CategoryTheory.Sieve.generate R ∈ (Opens.grothendieckTopology ↑X).sieves U)
Goal: iSup (TopCat.Presheaf.coveringOfPresieve U R) = U
-- TopCat.Presheaf.covering_presieve_eq_self
@[simp]
theorem covering_presieve_eq_self {Y : Opens X} (R : Presieve Y) :
    presieveOfCoveringAux (coveringOfPresieve Y R) Y = R 
Arguments: {X : TopCat} {Y : TopologicalSpace.Opens ↑X} (R : CategoryTheory.Presieve Y)
Goal: TopCat.Presheaf.presieveOfCoveringAux (TopCat.Presheaf.coveringOfPresieve Y R) Y = R
-- TopCat.Presheaf.presieveOfCovering.mem_grothendieckTopology
theorem mem_grothendieckTopology :
    Sieve.generate (presieveOfCovering U) ∈ Opens.grothendieckTopology X (iSup U) 
Arguments: {X : TopCat} {ι : Type v} (U : ι → TopologicalSpace.Opens ↑X)
Goal: CategoryTheory.Sieve.generate (TopCat.Presheaf.presieveOfCovering U) ∈ (Opens.grothendieckTopology ↑X).sieves (iSup U)
-- TopCat.Presheaf.presieveOfCovering.indexOfHom_spec
theorem indexOfHom_spec (f : ΣV, { f : V ⟶ iSup U // presieveOfCovering U f }) :
    f.1 = U (indexOfHom U f) 
Arguments: {X : TopCat} {ι : Type v} (U : ι → TopologicalSpace.Opens ↑X) (f : (V : TopologicalSpace.Opens ↑X) × { f // TopCat.Presheaf.presieveOfCovering U f })
Goal: f.fst = U (TopCat.Presheaf.presieveOfCovering.indexOfHom U f)
-- TopCat.Opens.coverDense_iff_isBasis
theorem coverDense_iff_isBasis [Category ι] (B : ι ⥤ Opens X) :
    B.IsCoverDense (Opens.grothendieckTopology X) ↔ Opens.IsBasis (Set.range B.obj) 
Arguments: {X : TopCat} {ι : Type u_1} [CategoryTheory.Category.{u_2, u_1} ι] (B : ι ⥤ TopologicalSpace.Opens ↑X)
Goal: B.IsCoverDense (Opens.grothendieckTopology ↑X) ↔ TopologicalSpace.Opens.IsBasis (Set.range B.obj)
-- TopCat.Opens.coverDense_inducedFunctor
theorem coverDense_inducedFunctor {B : ι → Opens X} (h : Opens.IsBasis (Set.range B)) :
    (inducedFunctor B).IsCoverDense (Opens.grothendieckTopology X)  
Arguments: {X : TopCat} {ι : Type u_1} {B : ι → TopologicalSpace.Opens ↑X} (h : TopologicalSpace.Opens.IsBasis (Set.range B))
Goal: (CategoryTheory.inducedFunctor B).IsCoverDense (Opens.grothendieckTopology ↑X)
-- OpenEmbedding.compatiblePreserving
theorem OpenEmbedding.compatiblePreserving (hf : OpenEmbedding f) :
    CompatiblePreserving (Opens.grothendieckTopology Y) hf.isOpenMap.functor 
Arguments: {X Y : TopCat} {f : X ⟶ Y} (hf : OpenEmbedding ⇑f)
Goal: CategoryTheory.CompatiblePreserving (Opens.grothendieckTopology ↑Y) ⋯.functor
-- IsOpenMap.coverPreserving
theorem IsOpenMap.coverPreserving (hf : IsOpenMap f) :
    CoverPreserving (Opens.grothendieckTopology X) (Opens.grothendieckTopology Y) hf.functor 
Arguments: {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap ⇑f)
Goal: CategoryTheory.CoverPreserving (Opens.grothendieckTopology ↑X) (Opens.grothendieckTopology ↑Y) hf.functor
-- OpenEmbedding.functor_isContinuous
lemma OpenEmbedding.functor_isContinuous (h : OpenEmbedding f) :
    h.isOpenMap.functor.IsContinuous (Opens.grothendieckTopology X)
      (Opens.grothendieckTopology Y) 
Arguments: {X Y : TopCat} {f : X ⟶ Y} (h : OpenEmbedding ⇑f)
Goal: ⋯.functor.IsContinuous (Opens.grothendieckTopology ↑X) (Opens.grothendieckTopology ↑Y)
-- TopCat.Presheaf.isSheaf_of_openEmbedding
theorem TopCat.Presheaf.isSheaf_of_openEmbedding (h : OpenEmbedding f) (hF : F.IsSheaf) :
    IsSheaf (h.isOpenMap.functor.op ⋙ F) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : TopCat} {f : X ⟶ Y} {F : TopCat.Presheaf C Y} (h : OpenEmbedding ⇑f) (hF : F.IsSheaf)
Goal: TopCat.Presheaf.IsSheaf (⋯.functor.op ⋙ F)
-- compatiblePreserving_opens_map
theorem compatiblePreserving_opens_map :
    CompatiblePreserving (Opens.grothendieckTopology X) (Opens.map f) 
Arguments: {X Y : TopCat} (f : X ⟶ Y)
Goal: CategoryTheory.CompatiblePreserving (Opens.grothendieckTopology ↑X) (TopologicalSpace.Opens.map f)
-- coverPreserving_opens_map
theorem coverPreserving_opens_map : CoverPreserving (Opens.grothendieckTopology Y)
    (Opens.grothendieckTopology X) (Opens.map f) 
Arguments: {X Y : TopCat} (f : X ⟶ Y)
Goal: CategoryTheory.CoverPreserving (Opens.grothendieckTopology ↑Y) (Opens.grothendieckTopology ↑X)
  (TopologicalSpace.Opens.map f)
-- TopCat.Sheaf.extend_hom_app
@[simp]
theorem extend_hom_app (α : (inducedFunctor B).op ⋙ F ⟶ (inducedFunctor B).op ⋙ F'.1) (i : ι) :
    (restrictHomEquivHom F F' h α).app (op (B i)) = α.app (op i) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : TopCat} {ι : Type u_1} {B : ι → TopologicalSpace.Opens ↑X} (F : TopCat.Presheaf C X) (F' : TopCat.Sheaf C X) (h : TopologicalSpace.Opens.IsBasis (Set.range B)) (α : (CategoryTheory.inducedFunctor B).op ⋙ F ⟶ (CategoryTheory.inducedFunctor B).op ⋙ F'.val) (i : ι)
Goal: ((TopCat.Sheaf.restrictHomEquivHom F F' h) α).app (Opposite.op (B i)) = α.app (Opposite.op i)
-- TopCat.Sheaf.hom_ext
theorem hom_ext {α β : F ⟶ F'.1} (he : ∀ i, α.app (op (B i)) = β.app (op (B i))) : α = β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : TopCat} {ι : Type u_1} {B : ι → TopologicalSpace.Opens ↑X} (F : TopCat.Presheaf C X) (F' : TopCat.Sheaf C X) (h : TopologicalSpace.Opens.IsBasis (Set.range B)) {α β : F ⟶ F'.val} (he : ∀ (i : ι), α.app (Opposite.op (B i)) = β.app (Opposite.op (B i)))
Goal: α = β
-- TopCat.Presheaf.SubmonoidPresheaf.map
structure SubmonoidPresheaf [∀ X : C, MulOneClass X] [∀ X Y : C, MonoidHomClass (X ⟶ Y) X Y]
    (F : X.Presheaf C) where
  obj : ∀ U, Submonoid (F.obj U)
  map : ∀ {U V : (Opens X)ᵒᵖ} (i : U ⟶ V), obj U ≤ (obj V).comap (F.map i)
Arguments: {X : TopCat} {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] [(X : C) → MulOneClass ((CategoryTheory.forget C).obj X)] [∀ (X Y : C), MonoidHomClass (X ⟶ Y) ((CategoryTheory.forget C).obj X) ((CategoryTheory.forget C).obj Y)] {F : TopCat.Presheaf C X} (self : F.SubmonoidPresheaf) {U V : (TopologicalSpace.Opens ↑X)ᵒᵖ} (i : U ⟶ V)
Goal: self.obj U ≤ Submonoid.comap (F.map i) (self.obj V)
-- TopCat.Presheaf.SubmonoidPresheaf.toLocalizationPresheaf_app
@[simps app]
def SubmonoidPresheaf.toLocalizationPresheaf : F ⟶ G.localizationPresheaf 
Arguments: {X : TopCat} {F : TopCat.Presheaf CommRingCat X} (G : F.SubmonoidPresheaf) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ)
Goal: G.toLocalizationPresheaf.app U = CommRingCat.ofHom (algebraMap (↑(F.obj U)) (Localization (G.obj U)))
-- TopCat.Presheaf.submonoidPresheafOfStalk_obj
@[simps]
noncomputable def submonoidPresheafOfStalk (S : ∀ x : X, Submonoid (F.stalk x)) :
    F.SubmonoidPresheaf 
Arguments: {X : TopCat} (F : TopCat.Presheaf CommRingCat X) (S : (x : ↑X) → Submonoid ↑(F.stalk x)) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ)
Goal: (F.submonoidPresheafOfStalk S).obj U = ⨅ x, Submonoid.comap (F.germ x) (S ↑x)
-- PiNat.firstDiff_def
irreducible_def firstDiff (x y : ∀ n, E n) : ℕ 
Arguments: {E : ℕ → Type u_2} (x y : (n : ℕ) → E n)
Goal: PiNat.firstDiff x y = if h : x ≠ y then Nat.find ⋯ else 0
-- PiNat.apply_firstDiff_ne
theorem apply_firstDiff_ne {x y : ∀ n, E n} (h : x ≠ y) :
    x (firstDiff x y) ≠ y (firstDiff x y) 
Arguments: {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} (h : x ≠ y)
Goal: x (PiNat.firstDiff x y) ≠ y (PiNat.firstDiff x y)
-- PiNat.apply_eq_of_lt_firstDiff
theorem apply_eq_of_lt_firstDiff {x y : ∀ n, E n} {n : ℕ} (hn : n < firstDiff x y) : x n = y n 
Arguments: {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} {n : ℕ} (hn : n < PiNat.firstDiff x y)
Goal: x n = y n
-- PiNat.firstDiff_comm
theorem firstDiff_comm (x y : ∀ n, E n) : firstDiff x y = firstDiff y x 
Arguments: {E : ℕ → Type u_1} (x y : (n : ℕ) → E n)
Goal: PiNat.firstDiff x y = PiNat.firstDiff y x
-- PiNat.min_firstDiff_le
theorem min_firstDiff_le (x y z : ∀ n, E n) (h : x ≠ z) :
    min (firstDiff x y) (firstDiff y z) ≤ firstDiff x z 
Arguments: {E : ℕ → Type u_1} (x y z : (n : ℕ) → E n) (h : x ≠ z)
Goal: min (PiNat.firstDiff x y) (PiNat.firstDiff y z) ≤ PiNat.firstDiff x z
-- PiNat.cylinder_eq_pi
theorem cylinder_eq_pi (x : ∀ n, E n) (n : ℕ) :
    cylinder x n = Set.pi (Finset.range n : Set ℕ) fun i : ℕ => {x i} 
Arguments: {E : ℕ → Type u_1} (x : (n : ℕ) → E n) (n : ℕ)
Goal: PiNat.cylinder x n = (↑(Finset.range n)).pi fun i => {x i}
-- PiNat.cylinder_zero
@[simp]
theorem cylinder_zero (x : ∀ n, E n) : cylinder x 0 = univ 
Arguments: {E : ℕ → Type u_1} (x : (n : ℕ) → E n)
Goal: PiNat.cylinder x 0 = Set.univ
-- PiNat.cylinder_anti
theorem cylinder_anti (x : ∀ n, E n) {m n : ℕ} (h : m ≤ n) : cylinder x n ⊆ cylinder x m 
Arguments: {E : ℕ → Type u_1} (x : (n : ℕ) → E n) {m n : ℕ} (h : m ≤ n)
Goal: PiNat.cylinder x n ⊆ PiNat.cylinder x m
-- PiNat.mem_cylinder_iff
@[simp]
theorem mem_cylinder_iff {x y : ∀ n, E n} {n : ℕ} : y ∈ cylinder x n ↔ ∀ i < n, y i = x i 
Arguments: {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} {n : ℕ}
Goal: y ∈ PiNat.cylinder x n ↔ ∀ i < n, y i = x i
-- PiNat.self_mem_cylinder
theorem self_mem_cylinder (x : ∀ n, E n) (n : ℕ) : x ∈ cylinder x n 
Arguments: {E : ℕ → Type u_1} (x : (n : ℕ) → E n) (n : ℕ)
Goal: x ∈ PiNat.cylinder x n
-- PiNat.mem_cylinder_iff_eq
theorem mem_cylinder_iff_eq {x y : ∀ n, E n} {n : ℕ} :
    y ∈ cylinder x n ↔ cylinder y n = cylinder x n 
Arguments: {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} {n : ℕ}
Goal: y ∈ PiNat.cylinder x n ↔ PiNat.cylinder y n = PiNat.cylinder x n
-- PiNat.mem_cylinder_comm
theorem mem_cylinder_comm (x y : ∀ n, E n) (n : ℕ) : y ∈ cylinder x n ↔ x ∈ cylinder y n 
Arguments: {E : ℕ → Type u_1} (x y : (n : ℕ) → E n) (n : ℕ)
Goal: y ∈ PiNat.cylinder x n ↔ x ∈ PiNat.cylinder y n
-- PiNat.mem_cylinder_iff_le_firstDiff
theorem mem_cylinder_iff_le_firstDiff {x y : ∀ n, E n} (hne : x ≠ y) (i : ℕ) :
    x ∈ cylinder y i ↔ i ≤ firstDiff x y 
Arguments: {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} (hne : x ≠ y) (i : ℕ)
Goal: x ∈ PiNat.cylinder y i ↔ i ≤ PiNat.firstDiff x y
-- PiNat.mem_cylinder_firstDiff
theorem mem_cylinder_firstDiff (x y : ∀ n, E n) : x ∈ cylinder y (firstDiff x y) 
Arguments: {E : ℕ → Type u_1} (x y : (n : ℕ) → E n)
Goal: x ∈ PiNat.cylinder y (PiNat.firstDiff x y)
-- PiNat.cylinder_eq_cylinder_of_le_firstDiff
theorem cylinder_eq_cylinder_of_le_firstDiff (x y : ∀ n, E n) {n : ℕ} (hn : n ≤ firstDiff x y) :
    cylinder x n = cylinder y n 
Arguments: {E : ℕ → Type u_1} (x y : (n : ℕ) → E n) {n : ℕ} (hn : n ≤ PiNat.firstDiff x y)
Goal: PiNat.cylinder x n = PiNat.cylinder y n
-- PiNat.iUnion_cylinder_update
theorem iUnion_cylinder_update (x : ∀ n, E n) (n : ℕ) :
    ⋃ k, cylinder (update x n k) (n + 1) = cylinder x n 
Arguments: {E : ℕ → Type u_1} (x : (n : ℕ) → E n) (n : ℕ)
Goal: ⋃ k, PiNat.cylinder (Function.update x n k) (n + 1) = PiNat.cylinder x n
-- PiNat.update_mem_cylinder
theorem update_mem_cylinder (x : ∀ n, E n) (n : ℕ) (y : E n) : update x n y ∈ cylinder x n 
Arguments: {E : ℕ → Type u_1} (x : (n : ℕ) → E n) (n : ℕ) (y : E n)
Goal: Function.update x n y ∈ PiNat.cylinder x n
-- PiNat.res_zero
@[simp]
theorem res_zero (x : ℕ → α) : res x 0 = @nil α 
Arguments: {α : Type u_2} (x : ℕ → α)
Goal: PiNat.res x 0 = []
-- PiNat.res_succ
@[simp]
theorem res_succ (x : ℕ → α) (n : ℕ) : res x n.succ = x n :: res x n 
Arguments: {α : Type u_2} (x : ℕ → α) (n : ℕ)
Goal: PiNat.res x n.succ = x n :: PiNat.res x n