ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Lean/Meta/Basic.lean

full_name: Lean.Meta.preservingMCtx
code: /--
Restore the metavariable context after execution.
-/
def Lean.Meta.preservingMCtx {α : Type} (x : MetaM α) : MetaM α 
goal: Lean.MetaM α

full_name: Lean.Meta.forallMetaTelescopeReducingUntilDefEq
code: /--
This function is similar to `forallMetaTelescopeReducing`: Given `e` of the
form `forall ..xs, A`, this combinator will create a new metavariable for
each `x` in `xs` until it reaches an `x` whose type is defeq to `t`,
and instantiate `A` with these, while also reducing `A` if needed.
It uses `forallMetaTelescopeReducing`.

This function returns a triple `(mvs, bis, out)` where
- `mvs` is an array containing the new metavariables.
- `bis` is an array containing the binder infos for the `mvs`.
- `out` is `e` but instantiated with the `mvs`.
-/
def Lean.Meta.forallMetaTelescopeReducingUntilDefEq
    (e t : Expr) (kind : MetavarKind := MetavarKind.natural) :
    MetaM (Array Expr × Array BinderInfo × Expr) 
goal: Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr)

full_name: Lean.Meta.pureIsDefEq
code: /-- `pureIsDefEq e₁ e₂` is short for `withNewMCtxDepth <| isDefEq e₁ e₂`.
Determines whether two expressions are definitionally equal to each other
when metavariables are not assignable. -/
@[inline]
def Lean.Meta.pureIsDefEq (e₁ e₂ : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.mkRel
code: /-- `mkRel n lhs rhs` is `mkAppM n #[lhs, rhs]`, but with optimizations for `Eq` and `Iff`. -/
def Lean.Meta.mkRel (n : Name) (lhs rhs : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr
File: Mathlib/Lean/Elab/Term.lean

full_name: Lean.Elab.Term.elabPattern
code: /-- Fully elaborates the term `patt`, allowing typeclass inference failure,
but while setting `errToSorry` to false.
Typeclass failures result in plain metavariables.
Instantiates all assigned metavariables. -/
def elabPattern (patt : Term) (expectedType? : Option Expr) : TermElabM Expr 
goal: Lean.Elab.TermElabM Lean.Expr
File: Mathlib/Lean/GoalsLocation.lean

full_name: Lean.SubExpr.GoalsLocation.rootExpr
code: /-- The root expression of the position specified by the `GoalsLocation`. -/
def rootExpr : GoalsLocation → MetaM Expr
  
goal: Lean.SubExpr.GoalsLocation → Lean.MetaM Lean.Expr

full_name: Lean.SubExpr.GoalsLocation.pos
code: /-- The `SubExpr.Pos` specified by the `GoalsLocation`. -/
def pos : GoalsLocation → Pos
  
goal: Lean.SubExpr.GoalsLocation → Lean.SubExpr.Pos

full_name: Lean.SubExpr.GoalsLocation.location
code: /-- The hypothesis specified by the `GoalsLocation`. -/
def location : GoalsLocation → MetaM (Option Name)
  
goal: Lean.SubExpr.GoalsLocation → Lean.MetaM (Option Lean.Name)
File: Mathlib/Lean/Elab/Tactic/Basic.lean

full_name: Lean.Elab.Tactic.getMainTarget''
code: /-- Return expected type for the main goal, cleaning up annotations, using `Lean.MVarId.getType''`.
Remark: note that `MVarId.getType'` uses `whnf` instead of `cleanupAnnotations`, and
`MVarId.getType''` also uses `cleanupAnnotations` -/
def getMainTarget'' : TacticM Expr 
goal: Lean.Elab.Tactic.TacticM Lean.Expr

full_name: Lean.Elab.Tactic.doneWithScope
code: /--
Like `done` but takes a scope (e.g. a tactic name) as an argument
to produce more detailed error messages.
-/
def doneWithScope (scope : MessageData) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.focusAndDoneWithScope
code: /--
Like `focusAndDone` but takes a scope (e.g. tactic name) as an argument to
produce more detailed error messages.
-/
def focusAndDoneWithScope {α : Type} (scope : MessageData) (tactic : TacticM α) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α
File: Mathlib/Lean/Meta/KAbstractPositions.lean

full_name: Lean.Meta.kabstractPositions
code: /-- Return the positions that `kabstract` would abstract for pattern `p` in expression `e`.
i.e. the positions that unify with `p`. -/
def kabstractPositions (p e : Expr) : MetaM (Array SubExpr.Pos) 
goal: Lean.MetaM (Array Lean.SubExpr.Pos)

full_name: Lean.Meta.kabstractPositions.visit
code: /-- Return the positions that `kabstract` would abstract for pattern `p` in expression `e`.
i.e. the positions that unify with `p`. -/
def kabstractPositions (p e : Expr) : MetaM (Array SubExpr.Pos) 
goal: Lean.MetaM (Array Lean.SubExpr.Pos)

full_name: Lean.Meta.viewKAbstractSubExpr
code: /-- Return the subexpression at position `pos` in `e` together with an occurrence number
that allows the expression to be found by `kabstract`.
Return `none` when the subexpression contains loose bound variables. -/
def viewKAbstractSubExpr (e : Expr) (pos : SubExpr.Pos) : MetaM (Option (Expr × Option Nat)) 
goal: Lean.MetaM (Option (Lean.Expr × Option Nat))

full_name: Lean.Meta.kabstractIsTypeCorrect
code: /-- Determine whether the result of abstracting `subExpr` from `e` at position `pos` results
in a well typed expression. This is important if you want to rewrite at this position.

Here is an example of what goes wrong with an ill-typed kabstract result:

```
example (h : [5] ≠ []) : List.getLast [5] h = 5 := by
  rw [show [5] = [5] from rfl] -- tactic 'rewrite' failed, motive is not type correct
```
-/
def kabstractIsTypeCorrect (e subExpr : Expr) (pos : SubExpr.Pos) : MetaM Bool 
goal: Lean.MetaM Bool
File: Mathlib/Lean/Meta/DiscrTree.lean

full_name: Lean.Meta.DiscrTree.getSubexpressionMatches
code: /--
Find keys which match the expression, or some subexpression.

Note that repeated subexpressions will be visited each time they appear,
making this operation potentially very expensive.
It would be good to solve this problem!

Implementation: we reverse the results from `getMatch`,
so that we return lemmas matching larger subexpressions first,
and amongst those we return more specific lemmas first.
-/
partial def getSubexpressionMatches {α : Type}
    (d : DiscrTree α) (e : Expr) (config : WhnfCoreConfig) : MetaM (Array α) 
goal: Lean.MetaM (Array α)

full_name: Lean.Meta.DiscrTree.keysSpecific
code: /--
Check if a `keys : Array DiscTree.Key` is "specific",
i.e. something other than `[*]` or `[=, *, *, *]`.
-/
def keysSpecific (keys : Array DiscrTree.Key) : Bool 
goal: Bool
File: Mathlib/AlgebraicGeometry/Modules/Sheaf.lean

full_name: AlgebraicGeometry.Scheme.Modules
code: /-- The category of sheaves of modules over a scheme. -/
abbrev Modules 
goal: Type (u + 1)

full_name: AlgebraicGeometry.Scheme.instAbelianModules
code: noncomputable instance : Abelian X.Modules 
goal: CategoryTheory.Abelian X.Modules
File: Mathlib/AlgebraicGeometry/Modules/Presheaf.lean

full_name: AlgebraicGeometry.Scheme.ringCatSheaf
code: /-- The underlying sheaf of rings of a scheme. -/
abbrev ringCatSheaf : TopCat.Sheaf RingCat.{u} X 
goal: TopCat.Sheaf RingCat ↑X.toPresheafedSpace

full_name: AlgebraicGeometry.Scheme.PresheafOfModules
code: /-- The category of presheaves of modules over a scheme. -/
nonrec abbrev PresheafOfModules 
goal: Type (u + 1)
File: Mathlib/AlgebraicGeometry/Sites/BigZariski.lean

full_name: AlgebraicGeometry.Scheme.zariskiPretopology
code: /-- The Zariski pretopology on the category of schemes. -/
def zariskiPretopology : Pretopology (Scheme.{u}) 
goal: CategoryTheory.Pretopology AlgebraicGeometry.Scheme

full_name: AlgebraicGeometry.Scheme.zariskiTopology
code: /-- The Zariski topology on the category of schemes. -/
abbrev zariskiTopology : GrothendieckTopology (Scheme.{u}) 
goal: CategoryTheory.GrothendieckTopology AlgebraicGeometry.Scheme

full_name: AlgebraicGeometry.Scheme.zariskiPretopology_openCover
code: lemma zariskiPretopology_openCover {Y : Scheme.{u}} (U : OpenCover.{u} Y) :
    zariskiPretopology Y (Presieve.ofArrows U.obj U.map) 
goal: AlgebraicGeometry.Scheme.zariskiPretopology.coverings Y (CategoryTheory.Presieve.ofArrows U.obj U.map)

full_name: AlgebraicGeometry.Scheme.zariskiTopology_openCover
code: lemma zariskiTopology_openCover {Y : Scheme.{u}} (U : OpenCover.{v} Y) :
    zariskiTopology Y (Sieve.generate (Presieve.ofArrows U.obj U.map)) 
goal: AlgebraicGeometry.Scheme.zariskiTopology.sieves Y
  (CategoryTheory.Sieve.generate (CategoryTheory.Presieve.ofArrows U.obj U.map))

full_name: AlgebraicGeometry.Scheme.subcanonical_zariskiTopology
code: lemma subcanonical_zariskiTopology : Sheaf.Subcanonical zariskiTopology 
goal: CategoryTheory.Sheaf.Subcanonical AlgebraicGeometry.Scheme.zariskiTopology
File: Mathlib/AlgebraicGeometry/Morphisms/OpenImmersion.lean

full_name: AlgebraicGeometry.isOpenImmersion_iff_stalk
code: theorem isOpenImmersion_iff_stalk {f : X ⟶ Y} : IsOpenImmersion f ↔
    OpenEmbedding f.1.base ∧ ∀ x, IsIso (f.stalkMap x) 
goal: AlgebraicGeometry.IsOpenImmersion f ↔
  OpenEmbedding ⇑f.val.base ∧
    ∀ (x : ↑↑X.toPresheafedSpace), CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.stalkMap f x)

full_name: AlgebraicGeometry.isOpenImmersion_eq_inf
code: theorem isOpenImmersion_eq_inf :
    @IsOpenImmersion = (topologically OpenEmbedding) ⊓
      stalkwise (fun f ↦ Function.Bijective f) 
goal: @AlgebraicGeometry.IsOpenImmersion =
  (AlgebraicGeometry.topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => OpenEmbedding) ⊓
    AlgebraicGeometry.stalkwise fun {R S} [CommRing R] [CommRing S] f => Function.Bijective ⇑f

full_name: AlgebraicGeometry.isOpenImmersion_isStableUnderComposition
code: instance isOpenImmersion_isStableUnderComposition :
    MorphismProperty.IsStableUnderComposition @IsOpenImmersion 
goal: CategoryTheory.MorphismProperty.IsStableUnderComposition @AlgebraicGeometry.IsOpenImmersion

full_name: AlgebraicGeometry.isOpenImmersion_respectsIso
code: instance isOpenImmersion_respectsIso : MorphismProperty.RespectsIso @IsOpenImmersion 
goal: CategoryTheory.MorphismProperty.RespectsIso @AlgebraicGeometry.IsOpenImmersion

full_name: AlgebraicGeometry.instIsLocalAtTargetStalkwiseBijectiveCoeRingHom
code: instance : IsLocalAtTarget (stalkwise (fun f ↦ Function.Bijective f)) 
goal: AlgebraicGeometry.IsLocalAtTarget
  (AlgebraicGeometry.stalkwise fun {R S} [CommRing R] [CommRing S] f => Function.Bijective ⇑f)

full_name: AlgebraicGeometry.isOpenImmersion_isLocalAtTarget
code: instance isOpenImmersion_isLocalAtTarget : IsLocalAtTarget @IsOpenImmersion 
goal: AlgebraicGeometry.IsLocalAtTarget @AlgebraicGeometry.IsOpenImmersion

full_name: AlgebraicGeometry.isOpenImmersion_stableUnderBaseChange
code: theorem isOpenImmersion_stableUnderBaseChange :
    MorphismProperty.StableUnderBaseChange @IsOpenImmersion 
goal: CategoryTheory.MorphismProperty.StableUnderBaseChange @AlgebraicGeometry.IsOpenImmersion
File: Mathlib/AlgebraicGeometry/Stalk.lean

full_name: AlgebraicGeometry.IsAffineOpen.fromSpecStalk
code: /--
A morphism from `Spec(O_x)` to `X`, which is defined with the help of an affine open
neighborhood `U` of `x`.
-/
noncomputable def IsAffineOpen.fromSpecStalk
    {X : Scheme} {U : X.Opens} (hU : IsAffineOpen U) {x : X} (hxU : x ∈ U) :
    Spec (X.presheaf.stalk x) ⟶ X 
goal: AlgebraicGeometry.Spec (X.presheaf.stalk x) ⟶ X

full_name: AlgebraicGeometry.IsAffineOpen.fromSpecStalk_eq
code: /--
The morphism from `Spec(O_x)` to `X` given by `IsAffineOpen.fromSpec` does not depend on the affine
open neighborhood of `x` we choose.
-/
theorem IsAffineOpen.fromSpecStalk_eq {X : Scheme} (x : X) {U V : X.Opens}
    (hU : IsAffineOpen U) (hV : IsAffineOpen V) (hxU : x ∈ U) (hxV : x ∈ V) :
    hU.fromSpecStalk hxU = hV.fromSpecStalk hxV 
goal: hU.fromSpecStalk hxU = hV.fromSpecStalk hxV

full_name: AlgebraicGeometry.Scheme.fromSpecStalk
code: /--
If `x` is a point of `X`, this is the canonical morphism from `Spec(O_x)` to `X`.
-/
noncomputable def Scheme.fromSpecStalk (X : Scheme) (x : X) :
    Scheme.Spec.obj (op (X.presheaf.stalk x)) ⟶ X 
goal: AlgebraicGeometry.Scheme.Spec.obj (Opposite.op (X.presheaf.stalk x)) ⟶ X

full_name: AlgebraicGeometry.IsAffineOpen.fromSpecStalk_eq_fromSpecStalk
code: @[simp]
theorem IsAffineOpen.fromSpecStalk_eq_fromSpecStalk
    {X : Scheme} {U : X.Opens} (hU : IsAffineOpen U) {x : X} (hxU : x ∈ U) :
    hU.fromSpecStalk hxU = X.fromSpecStalk x 
goal: hU.fromSpecStalk hxU = X.fromSpecStalk x
File: Mathlib/AlgebraicGeometry/Morphisms/FiniteType.lean

full_name: AlgebraicGeometry.locallyOfFiniteType_iff
code: /-- A morphism of schemes `f : X ⟶ Y` is locally of finite type if for each affine `U ⊆ Y` and
`V ⊆ f ⁻¹' U`, The induced map `Γ(Y, U) ⟶ Γ(X, V)` is of finite type.
-/
@[mk_iff]
class LocallyOfFiniteType (f : X ⟶ Y) : Prop where
  finiteType_of_affine_subset :
    ∀ (U : Y.affineOpens) (V : X.affineOpens) (e : V.1 ≤ f ⁻¹ᵁ U.1), (f.appLE U V e).FiniteType
goal: AlgebraicGeometry.LocallyOfFiniteType f ↔
  ∀ (U : ↑Y.affineOpens) (V : ↑X.affineOpens) (e : ↑V ≤ (TopologicalSpace.Opens.map f.val.base).obj ↑U),
    RingHom.FiniteType (AlgebraicGeometry.Scheme.Hom.appLE f (↑U) (↑V) e)

full_name: AlgebraicGeometry.LocallyOfFiniteType
code: /-- A morphism of schemes `f : X ⟶ Y` is locally of finite type if for each affine `U ⊆ Y` and
`V ⊆ f ⁻¹' U`, The induced map `Γ(Y, U) ⟶ Γ(X, V)` is of finite type.
-/
@[mk_iff]
class LocallyOfFiniteType (f : X ⟶ Y) : Prop where
  finiteType_of_affine_subset :
    ∀ (U : Y.affineOpens) (V : X.affineOpens) (e : V.1 ≤ f ⁻¹ᵁ U.1), (f.appLE U V e).FiniteType
goal: Prop

full_name: AlgebraicGeometry.LocallyOfFiniteType.finiteType_of_affine_subset
code: /-- A morphism of schemes `f : X ⟶ Y` is locally of finite type if for each affine `U ⊆ Y` and
`V ⊆ f ⁻¹' U`, The induced map `Γ(Y, U) ⟶ Γ(X, V)` is of finite type.
-/
@[mk_iff]
class LocallyOfFiniteType (f : X ⟶ Y) : Prop where
  finiteType_of_affine_subset :
    ∀ (U : Y.affineOpens) (V : X.affineOpens) (e : V.1 ≤ f ⁻¹ᵁ U.1), (f.appLE U V e).FiniteType
goal: RingHom.FiniteType (AlgebraicGeometry.Scheme.Hom.appLE f (↑U) (↑V) e)

full_name: AlgebraicGeometry.instHasRingHomPropertyLocallyOfFiniteTypeFiniteType
code: instance : HasRingHomProperty @LocallyOfFiniteType RingHom.FiniteType 
goal: AlgebraicGeometry.HasRingHomProperty @AlgebraicGeometry.LocallyOfFiniteType fun {R S} [CommRing R] [CommRing S] =>
  RingHom.FiniteType

full_name: AlgebraicGeometry.locallyOfFiniteType_of_isOpenImmersion
code: instance (priority := 900) locallyOfFiniteType_of_isOpenImmersion [IsOpenImmersion f] :
    LocallyOfFiniteType f 
goal: AlgebraicGeometry.LocallyOfFiniteType f

full_name: AlgebraicGeometry.locallyOfFiniteType_comp
code: instance locallyOfFiniteType_comp {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z)
    [hf : LocallyOfFiniteType f] [hg : LocallyOfFiniteType g] : LocallyOfFiniteType (f ≫ g) 
goal: AlgebraicGeometry.LocallyOfFiniteType (f ≫ g)

full_name: AlgebraicGeometry.locallyOfFiniteType_of_comp
code: theorem locallyOfFiniteType_of_comp {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z)
    [LocallyOfFiniteType (f ≫ g)] : LocallyOfFiniteType f 
goal: AlgebraicGeometry.LocallyOfFiniteType f

full_name: AlgebraicGeometry.locallyOfFiniteType_stableUnderBaseChange
code: lemma locallyOfFiniteType_stableUnderBaseChange :
    MorphismProperty.StableUnderBaseChange @LocallyOfFiniteType 
goal: CategoryTheory.MorphismProperty.StableUnderBaseChange @AlgebraicGeometry.LocallyOfFiniteType
File: Mathlib/AlgebraicGeometry/Morphisms/IsIso.lean

full_name: AlgebraicGeometry.isomorphisms_eq_isOpenImmersion_inf_surjective
code: lemma isomorphisms_eq_isOpenImmersion_inf_surjective :
    isomorphisms Scheme = (@IsOpenImmersion ⊓ @Surjective : MorphismProperty Scheme) 
goal: CategoryTheory.MorphismProperty.isomorphisms AlgebraicGeometry.Scheme =
  @AlgebraicGeometry.IsOpenImmersion ⊓ @AlgebraicGeometry.Surjective

full_name: AlgebraicGeometry.isomorphisms_eq_stalkwise
code: lemma isomorphisms_eq_stalkwise :
    isomorphisms Scheme = (isomorphisms TopCat).inverseImage Scheme.forgetToTop ⊓
      stalkwise (fun f ↦ Function.Bijective f) 
goal: CategoryTheory.MorphismProperty.isomorphisms AlgebraicGeometry.Scheme =
  (CategoryTheory.MorphismProperty.isomorphisms TopCat).inverseImage AlgebraicGeometry.Scheme.forgetToTop ⊓
    AlgebraicGeometry.stalkwise fun {R S} [CommRing R] [CommRing S] f => Function.Bijective ⇑f

full_name: AlgebraicGeometry.instIsLocalAtTargetIsomorphismsScheme
code: instance : IsLocalAtTarget (isomorphisms Scheme) 
goal: AlgebraicGeometry.IsLocalAtTarget (CategoryTheory.MorphismProperty.isomorphisms AlgebraicGeometry.Scheme)

full_name: AlgebraicGeometry.instHasAffinePropertyIsomorphismsSchemeAndIsAffineIsIsoCommRingCatAppTopOpens
code: instance : HasAffineProperty (isomorphisms Scheme) fun X Y f _ ↦ IsAffine X ∧ IsIso (f.app ⊤) 
goal: AlgebraicGeometry.HasAffineProperty (CategoryTheory.MorphismProperty.isomorphisms AlgebraicGeometry.Scheme)
  fun X Y f x => AlgebraicGeometry.IsAffine X ∧ CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.app f ⊤)
File: Mathlib/AlgebraicGeometry/Morphisms/Separated.lean

full_name: AlgebraicGeometry.isSeparated_iff
code: /-- A morphism is separated if the diagonal map is a closed immersion. -/
@[mk_iff]
class IsSeparated : Prop where
  /-- A morphism is separated if the diagonal map is a closed immersion. -/
  diagonal_isClosedImmersion : IsClosedImmersion (pullback.diagonal f) := by infer_instance
goal: AlgebraicGeometry.IsSeparated f ↔
  autoParam (AlgebraicGeometry.IsClosedImmersion (CategoryTheory.Limits.pullback.diagonal f)) _auto✝

full_name: AlgebraicGeometry.IsSeparated
code: /-- A morphism is separated if the diagonal map is a closed immersion. -/
@[mk_iff]
class IsSeparated : Prop where
  /-- A morphism is separated if the diagonal map is a closed immersion. -/
  diagonal_isClosedImmersion : IsClosedImmersion (pullback.diagonal f) := by infer_instance
goal: Prop

full_name: AlgebraicGeometry.IsSeparated.diagonal_isClosedImmersion
code: /-- A morphism is separated if the diagonal map is a closed immersion. -/
@[mk_iff]
class IsSeparated : Prop where
  /-- A morphism is separated if the diagonal map is a closed immersion. -/
  diagonal_isClosedImmersion : IsClosedImmersion (pullback.diagonal f) := by infer_instance
goal: AlgebraicGeometry.IsClosedImmersion (CategoryTheory.Limits.pullback.diagonal f)

full_name: AlgebraicGeometry.IsSeparated.isSeparated_eq_diagonal_isClosedImmersion
code: theorem isSeparated_eq_diagonal_isClosedImmersion :
    @IsSeparated = MorphismProperty.diagonal @IsClosedImmersion 
goal: @AlgebraicGeometry.IsSeparated = CategoryTheory.MorphismProperty.diagonal @AlgebraicGeometry.IsClosedImmersion

full_name: AlgebraicGeometry.IsSeparated.isSeparated_of_mono
code: /-- Monomorphisms are separated. -/
instance (priority := 900) isSeparated_of_mono [Mono f] : IsSeparated f 
goal: AlgebraicGeometry.IsSeparated f

full_name: AlgebraicGeometry.IsSeparated.instRespectsIsoScheme
code: instance : MorphismProperty.RespectsIso @IsSeparated 
goal: CategoryTheory.MorphismProperty.RespectsIso @AlgebraicGeometry.IsSeparated

full_name: AlgebraicGeometry.IsSeparated.instQuasiSeparated
code: instance (priority := 900) [IsSeparated f] : QuasiSeparated f 
goal: AlgebraicGeometry.QuasiSeparated f
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Noetherian.lean

full_name: PrimeSpectrum.instNoetherianSpace
code: instance : NoetherianSpace (PrimeSpectrum R) 
goal: TopologicalSpace.NoetherianSpace (PrimeSpectrum R)

full_name: minimalPrimes.finite_of_isNoetherianRing
code: lemma _root_.minimalPrimes.finite_of_isNoetherianRing : (minimalPrimes R).Finite 
goal: (minimalPrimes R).Finite
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Maximal.lean

full_name: MaximalSpectrum.toPrimeSpectrum_range
code: theorem toPrimeSpectrum_range :
    Set.range (@toPrimeSpectrum R _) = { x | IsClosed ({x} : Set <| PrimeSpectrum R) } 
goal: Set.range MaximalSpectrum.toPrimeSpectrum = {x | IsClosed {x}}

full_name: MaximalSpectrum.zariskiTopology
code: /-- The Zariski topology on the maximal spectrum of a commutative ring is defined as the subspace
topology induced by the natural inclusion into the prime spectrum. -/
instance zariskiTopology : TopologicalSpace <| MaximalSpectrum R 
goal: TopologicalSpace (MaximalSpectrum R)

full_name: MaximalSpectrum.instT1Space
code: instance : T1Space <| MaximalSpectrum R 
goal: T1Space (MaximalSpectrum R)

full_name: MaximalSpectrum.toPrimeSpectrum_continuous
code: theorem toPrimeSpectrum_continuous : Continuous <| @toPrimeSpectrum R _ 
goal: Continuous MaximalSpectrum.toPrimeSpectrum
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Module.lean

full_name: LocalizedModule.subsingleton_iff_disjoint
code: /-- `M[1/f] = 0` if and only if `D(f) ∩ Supp M = 0`. -/
lemma LocalizedModule.subsingleton_iff_disjoint {f : R} :
    Subsingleton (LocalizedModule (.powers f) M) ↔
      Disjoint ↑(PrimeSpectrum.basicOpen f) (Module.support R M) 
goal: Subsingleton (LocalizedModule (Submonoid.powers f) M) ↔ Disjoint (↑(PrimeSpectrum.basicOpen f)) (Module.support R M)

full_name: Module.stableUnderSpecialization_support
code: lemma Module.stableUnderSpecialization_support :
    StableUnderSpecialization (Module.support R M) 
goal: StableUnderSpecialization (Module.support R M)

full_name: Module.isClosed_support
code: lemma Module.isClosed_support [Module.Finite R M] :
    IsClosed (Module.support R M) 
goal: IsClosed (Module.support R M)

full_name: Module.support_subset_preimage_comap
code: lemma Module.support_subset_preimage_comap [IsScalarTower R A M] :
    Module.support A M ⊆ PrimeSpectrum.comap (algebraMap R A) ⁻¹' Module.support R M 
goal: Module.support A M ⊆ ⇑(PrimeSpectrum.comap (algebraMap R A)) ⁻¹' Module.support R M
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/IsOpenComapC.lean

full_name: AlgebraicGeometry.Polynomial.imageOfDf
code: /-- Given a polynomial `f ∈ R[x]`, `imageOfDf` is the subset of `Spec R` where at least one
of the coefficients of `f` does not vanish.  Lemma `imageOfDf_eq_comap_C_compl_zeroLocus`
proves that `imageOfDf` is the image of `(zeroLocus {f})ᶜ` under the morphism
`comap C : Spec R[x] → Spec R`. -/
def imageOfDf (f : R[X]) : Set (PrimeSpectrum R) 
goal: Set (PrimeSpectrum R)

full_name: AlgebraicGeometry.Polynomial.isOpen_imageOfDf
code: theorem isOpen_imageOfDf : IsOpen (imageOfDf f) 
goal: IsOpen (AlgebraicGeometry.Polynomial.imageOfDf f)

full_name: AlgebraicGeometry.Polynomial.comap_C_mem_imageOfDf
code: /-- If a point of `Spec R[x]` is not contained in the vanishing set of `f`, then its image in
`Spec R` is contained in the open set where at least one of the coefficients of `f` is non-zero.
This lemma is a reformulation of `exists_C_coeff_not_mem`. -/
theorem comap_C_mem_imageOfDf {I : PrimeSpectrum R[X]}
    (H : I ∈ (zeroLocus {f} : Set (PrimeSpectrum R[X]))ᶜ) :
    PrimeSpectrum.comap (Polynomial.C : R →+* R[X]) I ∈ imageOfDf f 
goal: (PrimeSpectrum.comap Polynomial.C) I ∈ AlgebraicGeometry.Polynomial.imageOfDf f

full_name: AlgebraicGeometry.Polynomial.imageOfDf_eq_comap_C_compl_zeroLocus
code: /-- The open set `imageOfDf f` coincides with the image of `basicOpen f` under the
morphism `C⁺ : Spec R[x] → Spec R`. -/
theorem imageOfDf_eq_comap_C_compl_zeroLocus :
    imageOfDf f = PrimeSpectrum.comap (C : R →+* R[X]) '' (zeroLocus {f})ᶜ 
goal: AlgebraicGeometry.Polynomial.imageOfDf f = ⇑(PrimeSpectrum.comap Polynomial.C) '' (PrimeSpectrum.zeroLocus {f})ᶜ

full_name: AlgebraicGeometry.Polynomial.isOpenMap_comap_C
code: /-- The morphism `C⁺ : Spec R[x] → Spec R` is open.
Stacks Project "Lemma 00FB", first part.

https://stacks.math.columbia.edu/tag/00FB
-/
theorem isOpenMap_comap_C : IsOpenMap (PrimeSpectrum.comap (C : R →+* R[X])) 
goal: IsOpenMap ⇑(PrimeSpectrum.comap Polynomial.C)