ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- KaehlerDifferential.polynomialEquiv_symm
@[simp]
lemma KaehlerDifferential.polynomialEquiv_symm (P) :
    (polynomialEquiv R).symm P = P • D R R[X] X 
Arguments: (R : Type u) [CommRing R] (P : Polynomial R)
Goal: (KaehlerDifferential.polynomialEquiv R).symm P = P • (KaehlerDifferential.D R (Polynomial R)) Polynomial.X
-- LocalRing.ker_residue
lemma ker_residue : RingHom.ker (residue R) = maximalIdeal R 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R]
Goal: RingHom.ker (LocalRing.residue R) = LocalRing.maximalIdeal R
-- LocalRing.residue_eq_zero_iff
@[simp]
lemma residue_eq_zero_iff (x : R) : residue R x = 0 ↔ x ∈ maximalIdeal R 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R] (x : R)
Goal: (LocalRing.residue R) x = 0 ↔ x ∈ LocalRing.maximalIdeal R
-- LocalRing.residue_ne_zero_iff_isUnit
lemma residue_ne_zero_iff_isUnit (x : R) : residue R x ≠ 0 ↔ IsUnit x 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R] (x : R)
Goal: (LocalRing.residue R) x ≠ 0 ↔ IsUnit x
-- LocalRing.ResidueField.algebraMap_eq
theorem ResidueField.algebraMap_eq : algebraMap R (ResidueField R) = residue R 
Arguments: (R : Type u_1) [CommRing R] [LocalRing R]
Goal: algebraMap R (LocalRing.ResidueField R) = LocalRing.residue R
-- LocalRing.ResidueField.lift_comp_residue
theorem lift_comp_residue {R S : Type*} [CommRing R] [LocalRing R] [Field S] (f : R →+* S)
    [IsLocalRingHom f] : (lift f).comp (residue R) = f 
Arguments: {R : Type u_4} {S : Type u_5} [CommRing R] [LocalRing R] [Field S] (f : R →+* S) [IsLocalRingHom f]
Goal: (LocalRing.ResidueField.lift f).comp (LocalRing.residue R) = f
-- LocalRing.ResidueField.lift_residue_apply
@[simp]
theorem lift_residue_apply {R S : Type*} [CommRing R] [LocalRing R] [Field S] (f : R →+* S)
    [IsLocalRingHom f] (x) : lift f (residue R x) = f x 
Arguments: {R : Type u_4} {S : Type u_5} [CommRing R] [LocalRing R] [Field S] (f : R →+* S) [IsLocalRingHom f] (x : R)
Goal: (LocalRing.ResidueField.lift f) ((LocalRing.residue R) x) = f x
-- LocalRing.ResidueField.map_id
@[simp]
theorem map_id :
    LocalRing.ResidueField.map (RingHom.id R) = RingHom.id (LocalRing.ResidueField R) 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R]
Goal: LocalRing.ResidueField.map (RingHom.id R) = RingHom.id (LocalRing.ResidueField R)
-- LocalRing.ResidueField.map_comp
theorem map_comp (f : T →+* R) (g : R →+* S) [IsLocalRingHom f] [IsLocalRingHom g] :
    LocalRing.ResidueField.map (g.comp f) =
      (LocalRing.ResidueField.map g).comp (LocalRing.ResidueField.map f) 
Arguments: {R : Type u_1} {S : Type u_2} {T : Type u_3} [CommRing R] [LocalRing R] [CommRing S] [LocalRing S] [CommRing T] [LocalRing T] (f : T →+* R) (g : R →+* S) [IsLocalRingHom f] [IsLocalRingHom g]
Goal: LocalRing.ResidueField.map (g.comp f) = (LocalRing.ResidueField.map g).comp (LocalRing.ResidueField.map f)
-- LocalRing.ResidueField.map_comp_residue
theorem map_comp_residue (f : R →+* S) [IsLocalRingHom f] :
    (ResidueField.map f).comp (residue R) = (residue S).comp f 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [LocalRing R] [CommRing S] [LocalRing S] (f : R →+* S) [IsLocalRingHom f]
Goal: (LocalRing.ResidueField.map f).comp (LocalRing.residue R) = (LocalRing.residue S).comp f
-- LocalRing.ResidueField.map_residue
theorem map_residue (f : R →+* S) [IsLocalRingHom f] (r : R) :
    ResidueField.map f (residue R r) = residue S (f r) 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [LocalRing R] [CommRing S] [LocalRing S] (f : R →+* S) [IsLocalRingHom f] (r : R)
Goal: (LocalRing.ResidueField.map f) ((LocalRing.residue R) r) = (LocalRing.residue S) (f r)
-- LocalRing.ResidueField.map_id_apply
theorem map_id_apply (x : ResidueField R) : map (RingHom.id R) x = x 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R] (x : LocalRing.ResidueField R)
Goal: (LocalRing.ResidueField.map (RingHom.id R)) x = x
-- LocalRing.ResidueField.map_map
@[simp]
theorem map_map (f : R →+* S) (g : S →+* T) (x : ResidueField R) [IsLocalRingHom f]
    [IsLocalRingHom g] : map g (map f x) = map (g.comp f) x 
Arguments: {R : Type u_1} {S : Type u_2} {T : Type u_3} [CommRing R] [LocalRing R] [CommRing S] [LocalRing S] [CommRing T] [LocalRing T] (f : R →+* S) (g : S →+* T) (x : LocalRing.ResidueField R) [IsLocalRingHom f] [IsLocalRingHom g]
Goal: (LocalRing.ResidueField.map g) ((LocalRing.ResidueField.map f) x) = (LocalRing.ResidueField.map (g.comp f)) x
-- LocalRing.ResidueField.mapEquiv_apply
@[simps apply]
def mapEquiv (f : R ≃+* S) : LocalRing.ResidueField R ≃+* LocalRing.ResidueField S 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [LocalRing R] [CommRing S] [LocalRing S] (f : R ≃+* S) (a : LocalRing.ResidueField R)
Goal: (LocalRing.ResidueField.mapEquiv f) a = (LocalRing.ResidueField.map ↑f) a
-- LocalRing.ResidueField.mapEquiv.symm
@[simp]
theorem mapEquiv.symm (f : R ≃+* S) : (mapEquiv f).symm = mapEquiv f.symm 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [LocalRing R] [CommRing S] [LocalRing S] (f : R ≃+* S)
Goal: (LocalRing.ResidueField.mapEquiv f).symm = LocalRing.ResidueField.mapEquiv f.symm
-- LocalRing.ResidueField.mapEquiv_trans
@[simp]
theorem mapEquiv_trans (e₁ : R ≃+* S) (e₂ : S ≃+* T) :
    mapEquiv (e₁.trans e₂) = (mapEquiv e₁).trans (mapEquiv e₂) 
Arguments: {R : Type u_1} {S : Type u_2} {T : Type u_3} [CommRing R] [LocalRing R] [CommRing S] [LocalRing S] [CommRing T] [LocalRing T] (e₁ : R ≃+* S) (e₂ : S ≃+* T)
Goal: LocalRing.ResidueField.mapEquiv (e₁.trans e₂) =
  (LocalRing.ResidueField.mapEquiv e₁).trans (LocalRing.ResidueField.mapEquiv e₂)
-- LocalRing.ResidueField.mapEquiv_refl
@[simp]
theorem mapEquiv_refl : mapEquiv (RingEquiv.refl R) = RingEquiv.refl _ 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R]
Goal: LocalRing.ResidueField.mapEquiv (RingEquiv.refl R) = RingEquiv.refl (LocalRing.ResidueField R)
-- LocalRing.ResidueField.mapAut_apply
@[simps]
def mapAut : RingAut R →* RingAut (LocalRing.ResidueField R) 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R] (f : R ≃+* R)
Goal: LocalRing.ResidueField.mapAut f = LocalRing.ResidueField.mapEquiv f
-- LocalRing.ResidueField.residue_smul
@[simp]
theorem residue_smul (g : G) (r : R) : residue R (g • r) = g • residue R r 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R] (G : Type u_4) [Group G] [MulSemiringAction G R] (g : G) (r : R)
Goal: (LocalRing.residue R) (g • r) = g • (LocalRing.residue R) r
-- LocalRing.isLocalRingHom_residue
theorem isLocalRingHom_residue : IsLocalRingHom (LocalRing.residue R) 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R]
Goal: IsLocalRingHom (LocalRing.residue R)
-- Ideal.Filtration.mono
@[ext]
structure Ideal.Filtration (M : Type u) [AddCommGroup M] [Module R M] where
  N : ℕ → Submodule R M
  mono : ∀ i, N (i + 1) ≤ N i
  smul_le : ∀ i, I • N i ≤ N (i + 1)
Arguments: {R : Type u} [CommRing R] {I : Ideal R} {M : Type u} [AddCommGroup M] [Module R M] (self : I.Filtration M) (i : ℕ)
Goal: self.N (i + 1) ≤ self.N i
-- Ideal.Filtration.smul_le
@[ext]
structure Ideal.Filtration (M : Type u) [AddCommGroup M] [Module R M] where
  N : ℕ → Submodule R M
  mono : ∀ i, N (i + 1) ≤ N i
  smul_le : ∀ i, I • N i ≤ N (i + 1)
Arguments: {R : Type u} [CommRing R] {I : Ideal R} {M : Type u} [AddCommGroup M] [Module R M] (self : I.Filtration M) (i : ℕ)
Goal: I • self.N i ≤ self.N (i + 1)
-- Ideal.Filtration.pow_smul_le
theorem pow_smul_le (i j : ℕ) : I ^ i • F.N j ≤ F.N (i + j) 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (F : I.Filtration M) (i j : ℕ)
Goal: I ^ i • F.N j ≤ F.N (i + j)
-- Ideal.Filtration.pow_smul_le_pow_smul
theorem pow_smul_le_pow_smul (i j k : ℕ) : I ^ (i + k) • F.N j ≤ I ^ k • F.N (i + j) 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (F : I.Filtration M) (i j k : ℕ)
Goal: I ^ (i + k) • F.N j ≤ I ^ k • F.N (i + j)
-- Ideal.Filtration.antitone
protected theorem antitone : Antitone F.N 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (F : I.Filtration M)
Goal: Antitone F.N
-- Ideal.trivialFiltration_N
@[simps]
def _root_.Ideal.trivialFiltration (I : Ideal R) (N : Submodule R M) : I.Filtration M 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] (I : Ideal R) (N : Submodule R M)
Goal: ∀ (x : ℕ), (I.trivialFiltration N).N x = N
-- Ideal.Filtration.sup_N
@[simp]
theorem sup_N : (F ⊔ F').N = F.N ⊔ F'.N 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (F F' : I.Filtration M)
Goal: (F ⊔ F').N = F.N ⊔ F'.N
-- Ideal.Filtration.sSup_N
@[simp]
theorem sSup_N (S : Set (I.Filtration M)) : (sSup S).N = sSup (Ideal.Filtration.N '' S) 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (S : Set (I.Filtration M))
Goal: (sSup S).N = sSup (Ideal.Filtration.N '' S)
-- Ideal.Filtration.inf_N
@[simp]
theorem inf_N : (F ⊓ F').N = F.N ⊓ F'.N 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (F F' : I.Filtration M)
Goal: (F ⊓ F').N = F.N ⊓ F'.N
-- Ideal.Filtration.sInf_N
@[simp]
theorem sInf_N (S : Set (I.Filtration M)) : (sInf S).N = sInf (Ideal.Filtration.N '' S) 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (S : Set (I.Filtration M))
Goal: (sInf S).N = sInf (Ideal.Filtration.N '' S)
-- Ideal.Filtration.top_N
@[simp]
theorem top_N : (⊤ : I.Filtration M).N = ⊤ 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R}
Goal: ⊤.N = ⊤
-- Ideal.Filtration.bot_N
@[simp]
theorem bot_N : (⊥ : I.Filtration M).N = ⊥ 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R}
Goal: ⊥.N = ⊥
-- Ideal.Filtration.iSup_N
@[simp]
theorem iSup_N {ι : Sort*} (f : ι → I.Filtration M) : (iSup f).N = ⨆ i, (f i).N 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} {ι : Sort u_1} (f : ι → I.Filtration M)
Goal: (iSup f).N = ⨆ i, (f i).N
-- Ideal.Filtration.iInf_N
@[simp]
theorem iInf_N {ι : Sort*} (f : ι → I.Filtration M) : (iInf f).N = ⨅ i, (f i).N 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} {ι : Sort u_1} (f : ι → I.Filtration M)
Goal: (iInf f).N = ⨅ i, (f i).N
-- Ideal.stableFiltration_N
@[simps]
def _root_.Ideal.stableFiltration (I : Ideal R) (N : Submodule R M) : I.Filtration M 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] (I : Ideal R) (N : Submodule R M) (i : ℕ)
Goal: (I.stableFiltration N).N i = I ^ i • N
-- Ideal.stableFiltration_stable
theorem _root_.Ideal.stableFiltration_stable (I : Ideal R) (N : Submodule R M) :
    (I.stableFiltration N).Stable 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] (I : Ideal R) (N : Submodule R M)
Goal: (I.stableFiltration N).Stable
-- Ideal.Filtration.Stable.exists_pow_smul_eq
theorem Stable.exists_pow_smul_eq : ∃ n₀, ∀ k, F.N (n₀ + k) = I ^ k • F.N n₀ 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} {F : I.Filtration M} (h : F.Stable)
Goal: ∃ n₀, ∀ (k : ℕ), F.N (n₀ + k) = I ^ k • F.N n₀
-- Ideal.Filtration.Stable.exists_pow_smul_eq_of_ge
theorem Stable.exists_pow_smul_eq_of_ge : ∃ n₀, ∀ n ≥ n₀, F.N n = I ^ (n - n₀) • F.N n₀ 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} {F : I.Filtration M} (h : F.Stable)
Goal: ∃ n₀, ∀ n ≥ n₀, F.N n = I ^ (n - n₀) • F.N n₀
-- Ideal.Filtration.stable_iff_exists_pow_smul_eq_of_ge
theorem stable_iff_exists_pow_smul_eq_of_ge :
    F.Stable ↔ ∃ n₀, ∀ n ≥ n₀, F.N n = I ^ (n - n₀) • F.N n₀ 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} {F : I.Filtration M}
Goal: F.Stable ↔ ∃ n₀, ∀ n ≥ n₀, F.N n = I ^ (n - n₀) • F.N n₀
-- Ideal.Filtration.Stable.exists_forall_le
theorem Stable.exists_forall_le (h : F.Stable) (e : F.N 0 ≤ F'.N 0) :
    ∃ n₀, ∀ n, F.N (n + n₀) ≤ F'.N n 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} {F F' : I.Filtration M} (h : F.Stable) (e : F.N 0 ≤ F'.N 0)
Goal: ∃ n₀, ∀ (n : ℕ), F.N (n + n₀) ≤ F'.N n
-- Ideal.Filtration.Stable.bounded_difference
theorem Stable.bounded_difference (h : F.Stable) (h' : F'.Stable) (e : F.N 0 = F'.N 0) :
    ∃ n₀, ∀ n, F.N (n + n₀) ≤ F'.N n ∧ F'.N (n + n₀) ≤ F.N n 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} {F F' : I.Filtration M} (h : F.Stable) (h' : F'.Stable) (e : F.N 0 = F'.N 0)
Goal: ∃ n₀, ∀ (n : ℕ), F.N (n + n₀) ≤ F'.N n ∧ F'.N (n + n₀) ≤ F.N n
-- Ideal.Filtration.mem_submodule
@[simp]
theorem mem_submodule (f : PolynomialModule R M) : f ∈ F.submodule ↔ ∀ i, f i ∈ F.N i 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (F : I.Filtration M) (f : PolynomialModule R M)
Goal: f ∈ F.submodule ↔ ∀ (i : ℕ), f i ∈ F.N i
-- Ideal.Filtration.inf_submodule
theorem inf_submodule : (F ⊓ F').submodule = F.submodule ⊓ F'.submodule 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (F F' : I.Filtration M)
Goal: (F ⊓ F').submodule = F.submodule ⊓ F'.submodule
-- Ideal.Filtration.submodule_closure_single
theorem submodule_closure_single :
    AddSubmonoid.closure (⋃ i, single R i '' (F.N i : Set M)) = F.submodule.toAddSubmonoid 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (F : I.Filtration M)
Goal: AddSubmonoid.closure (⋃ i, ⇑(PolynomialModule.single R i) '' ↑(F.N i)) = F.submodule.toAddSubmonoid
-- Ideal.Filtration.submodule_span_single
theorem submodule_span_single :
    Submodule.span (reesAlgebra I) (⋃ i, single R i '' (F.N i : Set M)) = F.submodule 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (F : I.Filtration M)
Goal: Submodule.span (↥(reesAlgebra I)) (⋃ i, ⇑(PolynomialModule.single R i) '' ↑(F.N i)) = F.submodule
-- Ideal.Filtration.submodule_eq_span_le_iff_stable_ge
theorem submodule_eq_span_le_iff_stable_ge (n₀ : ℕ) :
    F.submodule = Submodule.span _ (⋃ i ≤ n₀, single R i '' (F.N i : Set M)) ↔
      ∀ n ≥ n₀, I • F.N n = F.N (n + 1) 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (F : I.Filtration M) (n₀ : ℕ)
Goal: F.submodule = Submodule.span (↥(reesAlgebra I)) (⋃ i, ⋃ (_ : i ≤ n₀), ⇑(PolynomialModule.single R i) '' ↑(F.N i)) ↔
  ∀ n ≥ n₀, I • F.N n = F.N (n + 1)
-- Ideal.Filtration.submodule_fg_iff_stable
theorem submodule_fg_iff_stable (hF' : ∀ i, (F.N i).FG) : F.submodule.FG ↔ F.Stable 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} (F : I.Filtration M) (hF' : ∀ (i : ℕ), (F.N i).FG)
Goal: F.submodule.FG ↔ F.Stable
-- Ideal.Filtration.Stable.of_le
theorem Stable.of_le [IsNoetherianRing R] [Module.Finite R M] (hF : F.Stable)
    {F' : I.Filtration M} (hf : F' ≤ F) : F'.Stable 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} {F : I.Filtration M} [IsNoetherianRing R] [Module.Finite R M] (hF : F.Stable) {F' : I.Filtration M} (hf : F' ≤ F)
Goal: F'.Stable
-- Ideal.Filtration.Stable.inter_right
theorem Stable.inter_right [IsNoetherianRing R] [Module.Finite R M] (hF : F.Stable) :
    (F ⊓ F').Stable 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} {F : I.Filtration M} (F' : I.Filtration M) [IsNoetherianRing R] [Module.Finite R M] (hF : F.Stable)
Goal: (F ⊓ F').Stable
-- Ideal.Filtration.Stable.inter_left
theorem Stable.inter_left [IsNoetherianRing R] [Module.Finite R M] (hF : F.Stable) :
    (F' ⊓ F).Stable 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] {I : Ideal R} {F : I.Filtration M} (F' : I.Filtration M) [IsNoetherianRing R] [Module.Finite R M] (hF : F.Stable)
Goal: (F' ⊓ F).Stable
-- Ideal.exists_pow_inf_eq_pow_smul
theorem Ideal.exists_pow_inf_eq_pow_smul [IsNoetherianRing R] [Module.Finite R M]
    (N : Submodule R M) : ∃ k : ℕ, ∀ n ≥ k, I ^ n • ⊤ ⊓ N = I ^ (n - k) • (I ^ k • ⊤ ⊓ N) 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] (I : Ideal R) [IsNoetherianRing R] [Module.Finite R M] (N : Submodule R M)
Goal: ∃ k, ∀ n ≥ k, I ^ n • ⊤ ⊓ N = I ^ (n - k) • (I ^ k • ⊤ ⊓ N)
-- Ideal.mem_iInf_smul_pow_eq_bot_iff
theorem Ideal.mem_iInf_smul_pow_eq_bot_iff [IsNoetherianRing R] [Module.Finite R M] (x : M) :
    x ∈ (⨅ i : ℕ, I ^ i • ⊤ : Submodule R M) ↔ ∃ r : I, (r : R) • x = x 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] (I : Ideal R) [IsNoetherianRing R] [Module.Finite R M] (x : M)
Goal: x ∈ ⨅ i, I ^ i • ⊤ ↔ ∃ r, ↑r • x = x
-- Ideal.iInf_pow_smul_eq_bot_of_localRing
theorem Ideal.iInf_pow_smul_eq_bot_of_localRing [IsNoetherianRing R] [LocalRing R]
    [Module.Finite R M] (h : I ≠ ⊤) : (⨅ i : ℕ, I ^ i • ⊤ : Submodule R M) = ⊥ 
Arguments: {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] (I : Ideal R) [IsNoetherianRing R] [LocalRing R] [Module.Finite R M] (h : I ≠ ⊤)
Goal: ⨅ i, I ^ i • ⊤ = ⊥
-- Ideal.iInf_pow_eq_bot_of_localRing
theorem Ideal.iInf_pow_eq_bot_of_localRing [IsNoetherianRing R] [LocalRing R] (h : I ≠ ⊤) :
    ⨅ i : ℕ, I ^ i = ⊥ 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) [IsNoetherianRing R] [LocalRing R] (h : I ≠ ⊤)
Goal: ⨅ i, I ^ i = ⊥
-- Ideal.isIdempotentElem_iff_eq_bot_or_top_of_localRing
theorem Ideal.isIdempotentElem_iff_eq_bot_or_top_of_localRing {R} [CommRing R]
    [IsNoetherianRing R] [LocalRing R] (I : Ideal R) :
    IsIdempotentElem I ↔ I = ⊥ ∨ I = ⊤ 
Arguments: {R : Type u_1} [CommRing R] [IsNoetherianRing R] [LocalRing R] (I : Ideal R)
Goal: IsIdempotentElem I ↔ I = ⊥ ∨ I = ⊤
-- Ideal.iInf_pow_eq_bot_of_isDomain
theorem Ideal.iInf_pow_eq_bot_of_isDomain [IsNoetherianRing R] [IsDomain R] (h : I ≠ ⊤) :
    ⨅ i : ℕ, I ^ i = ⊥ 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) [IsNoetherianRing R] [IsDomain R] (h : I ≠ ⊤)
Goal: ⨅ i, I ^ i = ⊥
-- Ideal.ofList_nil
@[simp] lemma ofList_nil : (ofList [] : Ideal R) = ⊥ 
Arguments: {R : Type u_1} [Semiring R]
Goal: Ideal.ofList [] = ⊥
-- Ideal.ofList_append
@[simp] lemma ofList_append (rs₁ rs₂ : List R) :
    ofList (rs₁ ++ rs₂) = ofList rs₁ ⊔ ofList rs₂ 
Arguments: {R : Type u_1} [Semiring R] (rs₁ rs₂ : List R)
Goal: Ideal.ofList (rs₁ ++ rs₂) = Ideal.ofList rs₁ ⊔ Ideal.ofList rs₂
-- Ideal.ofList_singleton
@[simp] lemma ofList_singleton (r : R) : ofList [r] = span {r} 
Arguments: {R : Type u_1} [Semiring R] (r : R)
Goal: Ideal.ofList [r] = Ideal.span {r}
-- Ideal.ofList_cons
@[simp] lemma ofList_cons (r : R) (rs : List R) :
    ofList (r::rs) = span {r} ⊔ ofList rs 
Arguments: {R : Type u_1} [Semiring R] (r : R) (rs : List R)
Goal: Ideal.ofList (r :: rs) = Ideal.span {r} ⊔ Ideal.ofList rs
-- Ideal.map_ofList
@[simp] lemma map_ofList (f : R →+* S) (rs : List R) :
    map f (ofList rs) = ofList (rs.map f) 
Arguments: {R : Type u_1} {S : Type u_2} [Semiring R] [Semiring S] (f : R →+* S) (rs : List R)
Goal: Ideal.map f (Ideal.ofList rs) = Ideal.ofList (List.map (⇑f) rs)
-- Ideal.ofList_cons_smul
lemma ofList_cons_smul {R} [CommSemiring R] (r : R) (rs : List R) {M}
    [AddCommMonoid M] [Module R M] (N : Submodule R M) :
    ofList (r :: rs) • N = r • N ⊔ ofList rs • N 
Arguments: {R : Type u_7} [CommSemiring R] (r : R) (rs : List R) {M : Type u_8} [AddCommMonoid M] [Module R M] (N : Submodule R M)
Goal: Ideal.ofList (r :: rs) • N = r • N ⊔ Ideal.ofList rs • N
-- Submodule.smul_top_le_comap_smul_top
lemma smul_top_le_comap_smul_top [CommSemiring R] [AddCommMonoid M]
    [AddCommMonoid M₂] [Module R M] [Module R M₂] (I : Ideal R)
    (f : M →ₗ[R] M₂) : I • ⊤ ≤ comap f (I • ⊤) 
Arguments: {R : Type u_1} {M : Type u_3} {M₂ : Type u_4} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] (I : Ideal R) (f : M →ₗ[R] M₂)
Goal: I • ⊤ ≤ Submodule.comap f (I • ⊤)
-- Submodule.quotOfListConsSMulTopEquivQuotSMulTopInner_naturality
lemma quotOfListConsSMulTopEquivQuotSMulTopInner_naturality (f : M →ₗ[R] M₂) :
    (quotOfListConsSMulTopEquivQuotSMulTopInner M₂ r rs).toLinearMap ∘ₗ
        mapQ _ _ _ (smul_top_le_comap_smul_top (Ideal.ofList (r :: rs)) f) =
      mapQ _ _ _ (smul_top_le_comap_smul_top _ (QuotSMulTop.map r f)) ∘ₗ
        (quotOfListConsSMulTopEquivQuotSMulTopInner M r rs).toLinearMap 
Arguments: {R : Type u_1} {M : Type u_3} {M₂ : Type u_4} [CommRing R] [AddCommGroup M] [AddCommGroup M₂] [Module R M] [Module R M₂] (r : R) (rs : List R) (f : M →ₗ[R] M₂)
Goal: ↑(Submodule.quotOfListConsSMulTopEquivQuotSMulTopInner M₂ r rs) ∘ₗ
    (Ideal.ofList (r :: rs) • ⊤).mapQ (Ideal.ofList (r :: rs) • ⊤) f ⋯ =
  (Ideal.ofList rs • ⊤).mapQ (Ideal.ofList rs • ⊤) ((QuotSMulTop.map r) f) ⋯ ∘ₗ
    ↑(Submodule.quotOfListConsSMulTopEquivQuotSMulTopInner M r rs)
-- Submodule.top_eq_ofList_cons_smul_iff
lemma top_eq_ofList_cons_smul_iff :
    (⊤ : Submodule R M) = Ideal.ofList (r :: rs) • ⊤ ↔
      (⊤ : Submodule R (QuotSMulTop r M)) = Ideal.ofList rs • ⊤ 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] (r : R) (rs : List R)
Goal: ⊤ = Ideal.ofList (r :: rs) • ⊤ ↔ ⊤ = Ideal.ofList rs • ⊤
-- RingTheory.Sequence.IsWeaklyRegular.regular_mod_prev
@[mk_iff]
structure IsWeaklyRegular (rs : List R) : Prop where
  regular_mod_prev : ∀ i (h : i < rs.length),
    IsSMulRegular (M ⧸ (ofList (rs.take i) • ⊤ : Submodule R M)) rs[i]
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {rs : List R} (self : RingTheory.Sequence.IsWeaklyRegular M rs) (i : ℕ) (h : i < rs.length)
Goal: IsSMulRegular (M ⧸ Ideal.ofList (List.take i rs) • ⊤) rs[i]
-- RingTheory.Sequence.isWeaklyRegular_iff
@[mk_iff]
structure IsWeaklyRegular (rs : List R) : Prop where
  regular_mod_prev : ∀ i (h : i < rs.length),
    IsSMulRegular (M ⧸ (ofList (rs.take i) • ⊤ : Submodule R M)) rs[i]
Arguments: {R : Type u_1} (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M] (rs : List R)
Goal: RingTheory.Sequence.IsWeaklyRegular M rs ↔
  ∀ (i : ℕ) (h : i < rs.length), IsSMulRegular (M ⧸ Ideal.ofList (List.take i rs) • ⊤) rs[i]
-- RingTheory.Sequence.isWeaklyRegular_iff_Fin
lemma isWeaklyRegular_iff_Fin (rs : List R) :
    IsWeaklyRegular M rs ↔ ∀ (i : Fin rs.length),
      IsSMulRegular (M ⧸ (ofList (rs.take i) • ⊤ : Submodule R M)) (rs.get i) 
Arguments: {R : Type u_1} (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M] (rs : List R)
Goal: RingTheory.Sequence.IsWeaklyRegular M rs ↔
  ∀ (i : Fin rs.length), IsSMulRegular (M ⧸ Ideal.ofList (List.take (↑i) rs) • ⊤) (rs.get i)
-- RingTheory.Sequence.IsRegular.top_ne_smul
@[mk_iff]
structure IsRegular (rs : List R) extends IsWeaklyRegular M rs : Prop where
  top_ne_smul : (⊤ : Submodule R M) ≠ Ideal.ofList rs • ⊤
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {rs : List R} (self : RingTheory.Sequence.IsRegular M rs)
Goal: ⊤ ≠ Ideal.ofList rs • ⊤
-- RingTheory.Sequence.isRegular_iff
@[mk_iff]
structure IsRegular (rs : List R) extends IsWeaklyRegular M rs : Prop where
  top_ne_smul : (⊤ : Submodule R M) ≠ Ideal.ofList rs • ⊤
Arguments: {R : Type u_1} (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M] (rs : List R)
Goal: RingTheory.Sequence.IsRegular M rs ↔ RingTheory.Sequence.IsWeaklyRegular M rs ∧ ⊤ ≠ Ideal.ofList rs • ⊤
-- _private.Mathlib.RingTheory.Regular.RegularSequence.0.AddHom.map_smul_top_toAddSubgroup_of_surjective
private lemma _root_.AddHom.map_smul_top_toAddSubgroup_of_surjective
    {f : M →+ M₂} {as : List R} {bs : List S} (hf : Function.Surjective f)
    (h : List.Forall₂ (fun r s => ∀ x, f (r • x) = s • f x) as bs) :
    (Ideal.ofList as • ⊤ : Submodule R M).toAddSubgroup.map f =
      (Ideal.ofList bs • ⊤ : Submodule S M₂).toAddSubgroup 
Arguments: {R : Type u_1} {S : Type u_2} {M : Type u_3} {M₂ : Type u_4} [CommRing R] [CommRing S] [AddCommGroup M] [AddCommGroup M₂] [Module R M] [Module S M₂] {f : M →+ M₂} {as : List R} {bs : List S} (hf : Function.Surjective ⇑f) (h : List.Forall₂ (fun r s => ∀ (x : M), f (r • x) = s • f x) as bs)
Goal: AddSubgroup.map f (Ideal.ofList as • ⊤).toAddSubgroup = (Ideal.ofList bs • ⊤).toAddSubgroup