ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- IsArtinianRing.maximal_ideals_finite
lemma maximal_ideals_finite : {I : Ideal R | I.IsMaximal}.Finite 
Arguments: (R : Type u_1) [CommRing R] [IsArtinianRing R]
Goal: {I | I.IsMaximal}.Finite
-- IsArtinianRing.subtype_isMaximal_finite
@[local instance] lemma subtype_isMaximal_finite : Finite {I : Ideal R | I.IsMaximal} 
Arguments: (R : Type u_1) [CommRing R] [IsArtinianRing R]
Goal: Finite ↑{I | I.IsMaximal}
-- IsArtinianRing.isSemisimpleRing_of_isReduced
theorem isSemisimpleRing_of_isReduced [IsReduced R] : IsSemisimpleRing R 
Arguments: (R : Type u_1) [CommRing R] [IsArtinianRing R] [IsReduced R]
Goal: IsSemisimpleRing R
-- HahnSeries.isPWO_iUnion_support_powers
theorem isPWO_iUnion_support_powers [LinearOrderedCancelAddCommMonoid Γ] [Ring R] [IsDomain R]
    {x : HahnSeries Γ R} (hx : 0 < x.orderTop) : (⋃ n : ℕ, (x ^ n).support).IsPWO 
Arguments: {Γ : Type u_1} {R : Type u_2} [LinearOrderedCancelAddCommMonoid Γ] [Ring R] [IsDomain R] {x : HahnSeries Γ R} (hx : 0 < x.orderTop)
Goal: (⋃ n, (x ^ n).support).IsPWO
-- HahnSeries.SummableFamily.isPWO_iUnion_support'
structure SummableFamily (α : Type*) where
    toFun : α → HahnSeries Γ R
  isPWO_iUnion_support' : Set.IsPWO (⋃ a : α, (toFun a).support)
  finite_co_support' : ∀ g : Γ, { a | (toFun a).coeff g ≠ 0 }.Finite
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} (self : HahnSeries.SummableFamily Γ R α)
Goal: (⋃ a, (self.toFun a).support).IsPWO
-- HahnSeries.SummableFamily.finite_co_support'
structure SummableFamily (α : Type*) where
    toFun : α → HahnSeries Γ R
  isPWO_iUnion_support' : Set.IsPWO (⋃ a : α, (toFun a).support)
  finite_co_support' : ∀ g : Γ, { a | (toFun a).coeff g ≠ 0 }.Finite
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} (self : HahnSeries.SummableFamily Γ R α) (g : Γ)
Goal: {a | (self.toFun a).coeff g ≠ 0}.Finite
-- HahnSeries.SummableFamily.isPWO_iUnion_support
theorem isPWO_iUnion_support (s : SummableFamily Γ R α) : Set.IsPWO (⋃ a : α, (s a).support) 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} (s : HahnSeries.SummableFamily Γ R α)
Goal: (⋃ a, (s a).support).IsPWO
-- HahnSeries.SummableFamily.finite_co_support
theorem finite_co_support (s : SummableFamily Γ R α) (g : Γ) :
    (Function.support fun a => (s a).coeff g).Finite 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} (s : HahnSeries.SummableFamily Γ R α) (g : Γ)
Goal: (Function.support fun a => (s a).coeff g).Finite
-- HahnSeries.SummableFamily.coe_injective
theorem coe_injective : @Function.Injective (SummableFamily Γ R α) (α → HahnSeries Γ R) (⇑) 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3}
Goal: Function.Injective DFunLike.coe
-- HahnSeries.SummableFamily.ext
@[ext]
theorem ext {s t : SummableFamily Γ R α} (h : ∀ a : α, s a = t a) : s = t 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {s t : HahnSeries.SummableFamily Γ R α} (h : ∀ (a : α), s a = t a)
Goal: s = t
-- HahnSeries.SummableFamily.coe_add
@[simp]
theorem coe_add {s t : SummableFamily Γ R α} : ⇑(s + t) = s + t 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {s t : HahnSeries.SummableFamily Γ R α}
Goal: ⇑(s + t) = ⇑s + ⇑t
-- HahnSeries.SummableFamily.add_apply
theorem add_apply {s t : SummableFamily Γ R α} {a : α} : (s + t) a = s a + t a 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {s t : HahnSeries.SummableFamily Γ R α} {a : α}
Goal: (s + t) a = s a + t a
-- HahnSeries.SummableFamily.coe_zero
@[simp]
theorem coe_zero : ((0 : SummableFamily Γ R α) : α → HahnSeries Γ R) = 0 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3}
Goal: ⇑0 = 0
-- HahnSeries.SummableFamily.zero_apply
theorem zero_apply {a : α} : (0 : SummableFamily Γ R α) a = 0 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {a : α}
Goal: 0 a = 0
-- HahnSeries.SummableFamily.hsum_coeff
@[simp]
theorem hsum_coeff {s : SummableFamily Γ R α} {g : Γ} : s.hsum.coeff g = ∑ᶠ i, (s i).coeff g 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {s : HahnSeries.SummableFamily Γ R α} {g : Γ}
Goal: s.hsum.coeff g = ∑ᶠ (i : α), (s i).coeff g
-- HahnSeries.SummableFamily.support_hsum_subset
theorem support_hsum_subset {s : SummableFamily Γ R α} : s.hsum.support ⊆ ⋃ a : α, (s a).support 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {s : HahnSeries.SummableFamily Γ R α}
Goal: s.hsum.support ⊆ ⋃ a, (s a).support
-- HahnSeries.SummableFamily.hsum_add
@[simp]
theorem hsum_add {s t : SummableFamily Γ R α} : (s + t).hsum = s.hsum + t.hsum 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {s t : HahnSeries.SummableFamily Γ R α}
Goal: (s + t).hsum = s.hsum + t.hsum
-- HahnSeries.SummableFamily.coe_neg
@[simp]
theorem coe_neg : ⇑(-s) = -s 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommGroup R] {α : Type u_3} {s : HahnSeries.SummableFamily Γ R α}
Goal: ⇑(-s) = -⇑s
-- HahnSeries.SummableFamily.neg_apply
theorem neg_apply : (-s) a = -s a 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommGroup R] {α : Type u_3} {s : HahnSeries.SummableFamily Γ R α} {a : α}
Goal: (-s) a = -s a
-- HahnSeries.SummableFamily.coe_sub
@[simp]
theorem coe_sub : ⇑(s - t) = s - t 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommGroup R] {α : Type u_3} {s t : HahnSeries.SummableFamily Γ R α}
Goal: ⇑(s - t) = ⇑s - ⇑t
-- HahnSeries.SummableFamily.sub_apply
theorem sub_apply : (s - t) a = s a - t a 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommGroup R] {α : Type u_3} {s t : HahnSeries.SummableFamily Γ R α} {a : α}
Goal: (s - t) a = s a - t a
-- HahnSeries.SummableFamily.smul_apply
@[simp]
theorem smul_apply {x : HahnSeries Γ R} {s : SummableFamily Γ R α} {a : α} : (x • s) a = x * s a 
Arguments: {Γ : Type u_1} {R : Type u_2} [OrderedCancelAddCommMonoid Γ] [Semiring R] {α : Type u_3} {x : HahnSeries Γ R} {s : HahnSeries.SummableFamily Γ R α} {a : α}
Goal: (x • s) a = x * s a
-- HahnSeries.SummableFamily.hsum_smul
@[simp]
theorem hsum_smul {x : HahnSeries Γ R} {s : SummableFamily Γ R α} : (x • s).hsum = x * s.hsum 
Arguments: {Γ : Type u_1} {R : Type u_2} [OrderedCancelAddCommMonoid Γ] [Semiring R] {α : Type u_3} {x : HahnSeries Γ R} {s : HahnSeries.SummableFamily Γ R α}
Goal: (x • s).hsum = x * s.hsum
-- HahnSeries.SummableFamily.lsum_apply
@[simps]
def lsum : SummableFamily Γ R α →ₗ[HahnSeries Γ R] HahnSeries Γ R 
Arguments: {Γ : Type u_1} {R : Type u_2} [OrderedCancelAddCommMonoid Γ] [Semiring R] {α : Type u_3} (s : HahnSeries.SummableFamily Γ R α)
Goal: HahnSeries.SummableFamily.lsum s = s.hsum
-- HahnSeries.SummableFamily.hsum_sub
@[simp]
theorem hsum_sub {R : Type*} [Ring R] {s t : SummableFamily Γ R α} :
    (s - t).hsum = s.hsum - t.hsum 
Arguments: {Γ : Type u_1} [OrderedCancelAddCommMonoid Γ] {α : Type u_3} {R : Type u_4} [Ring R] {s t : HahnSeries.SummableFamily Γ R α}
Goal: (s - t).hsum = s.hsum - t.hsum
-- HahnSeries.SummableFamily.coe_ofFinsupp
@[simp]
theorem coe_ofFinsupp {f : α →₀ HahnSeries Γ R} : ⇑(SummableFamily.ofFinsupp f) = f 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {f : α →₀ HahnSeries Γ R}
Goal: ⇑(HahnSeries.SummableFamily.ofFinsupp f) = ⇑f
-- HahnSeries.SummableFamily.hsum_ofFinsupp
@[simp]
theorem hsum_ofFinsupp {f : α →₀ HahnSeries Γ R} : (ofFinsupp f).hsum = f.sum fun _ => id 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {f : α →₀ HahnSeries Γ R}
Goal: (HahnSeries.SummableFamily.ofFinsupp f).hsum = f.sum fun x => id
-- HahnSeries.SummableFamily.embDomain_apply
theorem embDomain_apply :
    s.embDomain f b = if h : b ∈ Set.range f then s (Classical.choose h) else 0 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {β : Type u_4} (s : HahnSeries.SummableFamily Γ R α) (f : α ↪ β) {b : β}
Goal: (s.embDomain f) b = if h : b ∈ Set.range ⇑f then s (Classical.choose h) else 0
-- HahnSeries.SummableFamily.embDomain_image
@[simp]
theorem embDomain_image : s.embDomain f (f a) = s a 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {β : Type u_4} (s : HahnSeries.SummableFamily Γ R α) (f : α ↪ β) {a : α}
Goal: (s.embDomain f) (f a) = s a
-- HahnSeries.SummableFamily.embDomain_notin_range
@[simp]
theorem embDomain_notin_range (h : b ∉ Set.range f) : s.embDomain f b = 0 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {β : Type u_4} (s : HahnSeries.SummableFamily Γ R α) (f : α ↪ β) {b : β} (h : b ∉ Set.range ⇑f)
Goal: (s.embDomain f) b = 0
-- HahnSeries.SummableFamily.hsum_embDomain
@[simp]
theorem hsum_embDomain : (s.embDomain f).hsum = s.hsum 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddCommMonoid R] {α : Type u_3} {β : Type u_4} (s : HahnSeries.SummableFamily Γ R α) (f : α ↪ β)
Goal: (s.embDomain f).hsum = s.hsum
-- HahnSeries.SummableFamily.coe_powers
@[simp]
theorem coe_powers : ⇑(powers x hx) = HPow.hPow x 
Arguments: {Γ : Type u_1} {R : Type u_2} [LinearOrderedCancelAddCommMonoid Γ] [CommRing R] [IsDomain R] {x : HahnSeries Γ R} (hx : 0 < x.orderTop)
Goal: ⇑(HahnSeries.SummableFamily.powers x hx) = HPow.hPow x
-- HahnSeries.SummableFamily.embDomain_succ_smul_powers
theorem embDomain_succ_smul_powers :
    (x • powers x hx).embDomain ⟨Nat.succ, Nat.succ_injective⟩ =
      powers x hx - ofFinsupp (Finsupp.single 0 1) 
Arguments: {Γ : Type u_1} {R : Type u_2} [LinearOrderedCancelAddCommMonoid Γ] [CommRing R] [IsDomain R] {x : HahnSeries Γ R} (hx : 0 < x.orderTop)
Goal: (x • HahnSeries.SummableFamily.powers x hx).embDomain { toFun := Nat.succ, inj' := Nat.succ_injective } =
  HahnSeries.SummableFamily.powers x hx - HahnSeries.SummableFamily.ofFinsupp (Finsupp.single 0 1)
-- HahnSeries.SummableFamily.one_sub_self_mul_hsum_powers
theorem one_sub_self_mul_hsum_powers : (1 - x) * (powers x hx).hsum = 1 
Arguments: {Γ : Type u_1} {R : Type u_2} [LinearOrderedCancelAddCommMonoid Γ] [CommRing R] [IsDomain R] {x : HahnSeries Γ R} (hx : 0 < x.orderTop)
Goal: (1 - x) * (HahnSeries.SummableFamily.powers x hx).hsum = 1
-- HahnSeries.unit_aux
theorem unit_aux (x : HahnSeries Γ R) {r : R} (hr : r * x.leadingCoeff = 1) :
    0 < (1 - single (-x.order) r * x).orderTop 
Arguments: {Γ : Type u_1} {R : Type u_2} [LinearOrderedAddCommGroup Γ] [CommRing R] [IsDomain R] (x : HahnSeries Γ R) {r : R} (hr : r * x.leadingCoeff = 1)
Goal: 0 < (1 - (HahnSeries.single (-x.order)) r * x).orderTop
-- HahnSeries.isUnit_iff
theorem isUnit_iff {x : HahnSeries Γ R} : IsUnit x ↔ IsUnit (x.leadingCoeff) 
Arguments: {Γ : Type u_1} {R : Type u_2} [LinearOrderedAddCommGroup Γ] [CommRing R] [IsDomain R] {x : HahnSeries Γ R}
Goal: IsUnit x ↔ IsUnit x.leadingCoeff
-- _private.Mathlib.RingTheory.Flat.Stability.0.Module.Flat.auxLTensor_eq
private lemma auxLTensor_eq [Module.Flat R S] {I : Ideal R} :
    (auxLTensor R S M I : M ⊗[R] I →ₗ[R] M) =
    TensorProduct.rid R M ∘ₗ lTensor M (I.subtype) 
Arguments: (R : Type u) (S : Type v) (M : Type w) [CommRing R] [CommRing S] [Algebra R S] [AddCommGroup M] [Module R M] [Module S M] [IsScalarTower R S M] [Module.Flat R S] {I : Ideal R}
Goal: ↑R (Module.Flat.auxLTensor R S M I) = ↑(TensorProduct.rid R M) ∘ₗ LinearMap.lTensor M (Submodule.subtype I)
-- Module.Flat.comp
theorem comp [Module.Flat R S] [Module.Flat S M] : Module.Flat R M 
Arguments: (R : Type u) (S : Type v) (M : Type w) [CommRing R] [CommRing S] [Algebra R S] [AddCommGroup M] [Module R M] [Module S M] [IsScalarTower R S M] [Module.Flat R S] [Module.Flat S M]
Goal: Module.Flat R M
-- _private.Mathlib.RingTheory.Flat.Stability.0.Module.Flat.auxRTensorBaseChange_eq
private lemma auxRTensorBaseChange_eq (I : Ideal S) :
    auxRTensorBaseChange R S M I = rTensor (S ⊗[R] M) (Submodule.subtype I) 
Arguments: (R : Type u) (S : Type v) (M : Type w) [CommRing R] [CommRing S] [Algebra R S] [AddCommGroup M] [Module R M] (I : Ideal S)
Goal: Module.Flat.auxRTensorBaseChange R S M I = LinearMap.rTensor (S ⊗[R] M) (Submodule.subtype I)
-- Module.Flat.isBaseChange
theorem isBaseChange [Module.Flat R M] (N : Type t) [AddCommGroup N] [Module R N] [Module S N]
    [IsScalarTower R S N] {f : M →ₗ[R] N} (h : IsBaseChange S f) :
    Module.Flat S N 
Arguments: (R : Type u) (S : Type v) (M : Type w) [CommRing R] [CommRing S] [Algebra R S] [AddCommGroup M] [Module R M] [Module.Flat R M] (N : Type t) [AddCommGroup N] [Module R N] [Module S N] [IsScalarTower R S N] {f : M →ₗ[R] N} (h : IsBaseChange S f)
Goal: Module.Flat S N
-- Module.Flat.of_isLocalizedModule
theorem of_isLocalizedModule [Module.Flat R M] (S : Submonoid R) [IsLocalization S Rp]
    (f : M →ₗ[R] Mp) [h : IsLocalizedModule S f] : Module.Flat Rp Mp 
Arguments: {R : Type u} {M : Type u_1} {Mp : Type u_2} (Rp : Type v) [CommRing R] [AddCommGroup M] [Module R M] [CommRing Rp] [Algebra R Rp] [AddCommGroup Mp] [Module R Mp] [Module Rp Mp] [IsScalarTower R Rp Mp] [Module.Flat R M] (S : Submonoid R) [IsLocalization S Rp] (f : M →ₗ[R] Mp) [h : IsLocalizedModule S f]
Goal: Module.Flat Rp Mp
-- MvPolynomial.mem_zeroLocus_iff
@[simp]
theorem mem_zeroLocus_iff {I : Ideal (MvPolynomial σ k)} {x : σ → k} :
    x ∈ zeroLocus I ↔ ∀ p ∈ I, eval x p = 0 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} {I : Ideal (MvPolynomial σ k)} {x : σ → k}
Goal: x ∈ MvPolynomial.zeroLocus I ↔ ∀ p ∈ I, (MvPolynomial.eval x) p = 0
-- MvPolynomial.zeroLocus_anti_mono
theorem zeroLocus_anti_mono {I J : Ideal (MvPolynomial σ k)} (h : I ≤ J) :
    zeroLocus J ≤ zeroLocus I 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} {I J : Ideal (MvPolynomial σ k)} (h : I ≤ J)
Goal: MvPolynomial.zeroLocus J ≤ MvPolynomial.zeroLocus I
-- MvPolynomial.zeroLocus_bot
@[simp]
theorem zeroLocus_bot : zeroLocus (⊥ : Ideal (MvPolynomial σ k)) = ⊤ 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2}
Goal: MvPolynomial.zeroLocus ⊥ = ⊤
-- MvPolynomial.zeroLocus_top
@[simp]
theorem zeroLocus_top : zeroLocus (⊤ : Ideal (MvPolynomial σ k)) = ⊥ 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2}
Goal: MvPolynomial.zeroLocus ⊤ = ⊥
-- MvPolynomial.mem_vanishingIdeal_iff
@[simp]
theorem mem_vanishingIdeal_iff {V : Set (σ → k)} {p : MvPolynomial σ k} :
    p ∈ vanishingIdeal V ↔ ∀ x ∈ V, eval x p = 0 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} {V : Set (σ → k)} {p : MvPolynomial σ k}
Goal: p ∈ MvPolynomial.vanishingIdeal V ↔ ∀ x ∈ V, (MvPolynomial.eval x) p = 0
-- MvPolynomial.vanishingIdeal_anti_mono
theorem vanishingIdeal_anti_mono {A B : Set (σ → k)} (h : A ≤ B) :
    vanishingIdeal B ≤ vanishingIdeal A 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} {A B : Set (σ → k)} (h : A ≤ B)
Goal: MvPolynomial.vanishingIdeal B ≤ MvPolynomial.vanishingIdeal A
-- MvPolynomial.vanishingIdeal_empty
theorem vanishingIdeal_empty : vanishingIdeal (∅ : Set (σ → k)) = ⊤ 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2}
Goal: MvPolynomial.vanishingIdeal ∅ = ⊤
-- MvPolynomial.le_vanishingIdeal_zeroLocus
theorem le_vanishingIdeal_zeroLocus (I : Ideal (MvPolynomial σ k)) :
    I ≤ vanishingIdeal (zeroLocus I) 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} (I : Ideal (MvPolynomial σ k))
Goal: I ≤ MvPolynomial.vanishingIdeal (MvPolynomial.zeroLocus I)
-- MvPolynomial.zeroLocus_vanishingIdeal_le
theorem zeroLocus_vanishingIdeal_le (V : Set (σ → k)) : V ≤ zeroLocus (vanishingIdeal V) 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} (V : Set (σ → k))
Goal: V ≤ MvPolynomial.zeroLocus (MvPolynomial.vanishingIdeal V)
-- MvPolynomial.zeroLocus_vanishingIdeal_galoisConnection
theorem zeroLocus_vanishingIdeal_galoisConnection :
    @GaloisConnection (Ideal (MvPolynomial σ k)) (Set (σ → k))ᵒᵈ _ _ zeroLocus vanishingIdeal 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2}
Goal: GaloisConnection MvPolynomial.zeroLocus MvPolynomial.vanishingIdeal
-- MvPolynomial.le_zeroLocus_iff_le_vanishingIdeal
theorem le_zeroLocus_iff_le_vanishingIdeal {V : Set (σ → k)} {I : Ideal (MvPolynomial σ k)} :
    V ≤ zeroLocus I ↔ I ≤ vanishingIdeal V 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} {V : Set (σ → k)} {I : Ideal (MvPolynomial σ k)}
Goal: V ≤ MvPolynomial.zeroLocus I ↔ I ≤ MvPolynomial.vanishingIdeal V
-- MvPolynomial.zeroLocus_span
theorem zeroLocus_span (S : Set (MvPolynomial σ k)) :
    zeroLocus (Ideal.span S) = { x | ∀ p ∈ S, eval x p = 0 } 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} (S : Set (MvPolynomial σ k))
Goal: MvPolynomial.zeroLocus (Ideal.span S) = {x | ∀ p ∈ S, (MvPolynomial.eval x) p = 0}
-- MvPolynomial.mem_vanishingIdeal_singleton_iff
theorem mem_vanishingIdeal_singleton_iff (x : σ → k) (p : MvPolynomial σ k) :
    p ∈ (vanishingIdeal {x} : Ideal (MvPolynomial σ k)) ↔ eval x p = 0 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} (x : σ → k) (p : MvPolynomial σ k)
Goal: p ∈ MvPolynomial.vanishingIdeal {x} ↔ (MvPolynomial.eval x) p = 0
-- MvPolynomial.radical_le_vanishingIdeal_zeroLocus
theorem radical_le_vanishingIdeal_zeroLocus (I : Ideal (MvPolynomial σ k)) :
    I.radical ≤ vanishingIdeal (zeroLocus I) 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} (I : Ideal (MvPolynomial σ k))
Goal: I.radical ≤ MvPolynomial.vanishingIdeal (MvPolynomial.zeroLocus I)
-- MvPolynomial.vanishingIdeal_pointToPoint
@[simp]
theorem vanishingIdeal_pointToPoint (V : Set (σ → k)) :
    PrimeSpectrum.vanishingIdeal (pointToPoint '' V) = MvPolynomial.vanishingIdeal V 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} (V : Set (σ → k))
Goal: PrimeSpectrum.vanishingIdeal (MvPolynomial.pointToPoint '' V) = MvPolynomial.vanishingIdeal V
-- MvPolynomial.pointToPoint_zeroLocus_le
theorem pointToPoint_zeroLocus_le (I : Ideal (MvPolynomial σ k)) :
    pointToPoint '' MvPolynomial.zeroLocus I ≤ PrimeSpectrum.zeroLocus ↑I 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} (I : Ideal (MvPolynomial σ k))
Goal: MvPolynomial.pointToPoint '' MvPolynomial.zeroLocus I ≤ PrimeSpectrum.zeroLocus ↑I
-- MvPolynomial.isMaximal_iff_eq_vanishingIdeal_singleton
theorem isMaximal_iff_eq_vanishingIdeal_singleton (I : Ideal (MvPolynomial σ k)) :
    I.IsMaximal ↔ ∃ x : σ → k, I = vanishingIdeal {x} 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} [IsAlgClosed k] [Finite σ] (I : Ideal (MvPolynomial σ k))
Goal: I.IsMaximal ↔ ∃ x, I = MvPolynomial.vanishingIdeal {x}
-- MvPolynomial.vanishingIdeal_zeroLocus_eq_radical
@[simp]
theorem vanishingIdeal_zeroLocus_eq_radical (I : Ideal (MvPolynomial σ k)) :
    vanishingIdeal (zeroLocus I) = I.radical 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} [IsAlgClosed k] [Finite σ] (I : Ideal (MvPolynomial σ k))
Goal: MvPolynomial.vanishingIdeal (MvPolynomial.zeroLocus I) = I.radical
-- MvPolynomial.IsPrime.vanishingIdeal_zeroLocus
@[simp (high)]
theorem IsPrime.vanishingIdeal_zeroLocus (P : Ideal (MvPolynomial σ k)) [h : P.IsPrime] :
    vanishingIdeal (zeroLocus P) = P 
Arguments: {k : Type u_1} [Field k] {σ : Type u_2} [IsAlgClosed k] [Finite σ] (P : Ideal (MvPolynomial σ k)) [h : P.IsPrime]
Goal: MvPolynomial.vanishingIdeal (MvPolynomial.zeroLocus P) = P
-- Ideal.le_jacobson
theorem le_jacobson : I ≤ jacobson I 
Arguments: {R : Type u} [Ring R] {I : Ideal R}
Goal: I ≤ I.jacobson
-- Ideal.jacobson_idem
@[simp]
theorem jacobson_idem : jacobson (jacobson I) = jacobson I 
Arguments: {R : Type u} [Ring R] {I : Ideal R}
Goal: I.jacobson.jacobson = I.jacobson
-- Ideal.jacobson_top
@[simp]
theorem jacobson_top : jacobson (⊤ : Ideal R) = ⊤ 
Arguments: {R : Type u} [Ring R]
Goal: ⊤.jacobson = ⊤
-- Ideal.jacobson_eq_top_iff
@[simp]
theorem jacobson_eq_top_iff : jacobson I = ⊤ ↔ I = ⊤ 
Arguments: {R : Type u} [Ring R] {I : Ideal R}
Goal: I.jacobson = ⊤ ↔ I = ⊤
-- Ideal.jacobson_eq_bot
theorem jacobson_eq_bot : jacobson I = ⊥ → I = ⊥ 
Arguments: {R : Type u} [Ring R] {I : Ideal R}
Goal: I.jacobson = ⊥ → I = ⊥
-- Ideal.jacobson_eq_self_of_isMaximal
theorem jacobson_eq_self_of_isMaximal [H : IsMaximal I] : I.jacobson = I 
Arguments: {R : Type u} [Ring R] {I : Ideal R} [H : I.IsMaximal]
Goal: I.jacobson = I
-- Ideal.mem_jacobson_iff
theorem mem_jacobson_iff {x : R} : x ∈ jacobson I ↔ ∀ y, ∃ z, z * y * x + z - 1 ∈ I 
Arguments: {R : Type u} [Ring R] {I : Ideal R} {x : R}
Goal: x ∈ I.jacobson ↔ ∀ (y : R), ∃ z, z * y * x + z - 1 ∈ I
-- Ideal.exists_mul_sub_mem_of_sub_one_mem_jacobson
theorem exists_mul_sub_mem_of_sub_one_mem_jacobson {I : Ideal R} (r : R) (h : r - 1 ∈ jacobson I) :
    ∃ s, s * r - 1 ∈ I 
Arguments: {R : Type u} [Ring R] {I : Ideal R} (r : R) (h : r - 1 ∈ I.jacobson)
Goal: ∃ s, s * r - 1 ∈ I
-- Ideal.eq_jacobson_iff_sInf_maximal
theorem eq_jacobson_iff_sInf_maximal :
    I.jacobson = I ↔ ∃ M : Set (Ideal R), (∀ J ∈ M, IsMaximal J ∨ J = ⊤) ∧ I = sInf M 
Arguments: {R : Type u} [Ring R] {I : Ideal R}
Goal: I.jacobson = I ↔ ∃ M, (∀ J ∈ M, J.IsMaximal ∨ J = ⊤) ∧ I = sInf M
-- Ideal.eq_jacobson_iff_sInf_maximal'
theorem eq_jacobson_iff_sInf_maximal' :
    I.jacobson = I ↔ ∃ M : Set (Ideal R), (∀ J ∈ M, ∀ (K : Ideal R), J < K → K = ⊤) ∧ I = sInf M 
Arguments: {R : Type u} [Ring R] {I : Ideal R}
Goal: I.jacobson = I ↔ ∃ M, (∀ J ∈ M, ∀ (K : Ideal R), J < K → K = ⊤) ∧ I = sInf M
-- Ideal.eq_jacobson_iff_not_mem
theorem eq_jacobson_iff_not_mem :
    I.jacobson = I ↔ ∀ (x) (_ : x ∉ I), ∃ M : Ideal R, (I ≤ M ∧ M.IsMaximal) ∧ x ∉ M 
Arguments: {R : Type u} [Ring R] {I : Ideal R}
Goal: I.jacobson = I ↔ ∀ x ∉ I, ∃ M, (I ≤ M ∧ M.IsMaximal) ∧ x ∉ M
-- Ideal.map_jacobson_of_surjective
theorem map_jacobson_of_surjective {f : R →+* S} (hf : Function.Surjective f) :
    RingHom.ker f ≤ I → map f I.jacobson = (map f I).jacobson 
Arguments: {R : Type u} {S : Type v} [Ring R] [Ring S] {I : Ideal R} {f : R →+* S} (hf : Function.Surjective ⇑f)
Goal: RingHom.ker f ≤ I → Ideal.map f I.jacobson = (Ideal.map f I).jacobson
-- Ideal.map_jacobson_of_bijective
theorem map_jacobson_of_bijective {f : R →+* S} (hf : Function.Bijective f) :
    map f I.jacobson = (map f I).jacobson 
Arguments: {R : Type u} {S : Type v} [Ring R] [Ring S] {I : Ideal R} {f : R →+* S} (hf : Function.Bijective ⇑f)
Goal: Ideal.map f I.jacobson = (Ideal.map f I).jacobson
-- Ideal.comap_jacobson
theorem comap_jacobson {f : R →+* S} {K : Ideal S} :
    comap f K.jacobson = sInf (comap f '' { J : Ideal S | K ≤ J ∧ J.IsMaximal }) 
Arguments: {R : Type u} {S : Type v} [Ring R] [Ring S] {f : R →+* S} {K : Ideal S}
Goal: Ideal.comap f K.jacobson = sInf (Ideal.comap f '' {J | K ≤ J ∧ J.IsMaximal})
-- Ideal.comap_jacobson_of_surjective
theorem comap_jacobson_of_surjective {f : R →+* S} (hf : Function.Surjective f) {K : Ideal S} :
    comap f K.jacobson = (comap f K).jacobson 
Arguments: {R : Type u} {S : Type v} [Ring R] [Ring S] {f : R →+* S} (hf : Function.Surjective ⇑f) {K : Ideal S}
Goal: Ideal.comap f K.jacobson = (Ideal.comap f K).jacobson
-- Ideal.jacobson_mono
@[mono]
theorem jacobson_mono {I J : Ideal R} : I ≤ J → I.jacobson ≤ J.jacobson 
Arguments: {R : Type u} [Ring R] {I J : Ideal R}
Goal: I ≤ J → I.jacobson ≤ J.jacobson
-- Ideal.radical_le_jacobson
theorem radical_le_jacobson : radical I ≤ jacobson I 
Arguments: {R : Type u} [CommRing R] {I : Ideal R}
Goal: I.radical ≤ I.jacobson
-- Ideal.isRadical_of_eq_jacobson
theorem isRadical_of_eq_jacobson (h : jacobson I = I) : I.IsRadical 
Arguments: {R : Type u} [CommRing R] {I : Ideal R} (h : I.jacobson = I)
Goal: I.IsRadical
-- Ideal.isUnit_of_sub_one_mem_jacobson_bot
theorem isUnit_of_sub_one_mem_jacobson_bot (r : R) (h : r - 1 ∈ jacobson (⊥ : Ideal R)) :
    IsUnit r 
Arguments: {R : Type u} [CommRing R] (r : R) (h : r - 1 ∈ ⊥.jacobson)
Goal: IsUnit r
-- Ideal.mem_jacobson_bot
theorem mem_jacobson_bot {x : R} : x ∈ jacobson (⊥ : Ideal R) ↔ ∀ y, IsUnit (x * y + 1) 
Arguments: {R : Type u} [CommRing R] {x : R}
Goal: x ∈ ⊥.jacobson ↔ ∀ (y : R), IsUnit (x * y + 1)
-- Ideal.jacobson_eq_iff_jacobson_quotient_eq_bot
-- Porting note: changed `Quotient.mk'` to ``
theorem jacobson_eq_iff_jacobson_quotient_eq_bot :
    I.jacobson = I ↔ jacobson (⊥ : Ideal (R ⧸ I)) = ⊥ 
Arguments: {R : Type u} [CommRing R] {I : Ideal R}
Goal: I.jacobson = I ↔ ⊥.jacobson = ⊥