ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddEquiv.isWeaklyRegular_congr
lemma _root_.AddEquiv.isWeaklyRegular_congr {e : M ≃+ M₂} {as bs}
    (h : List.Forall₂ (fun (r : R) (s : S) => ∀ x, e (r • x) = s • e x) as bs) :
    IsWeaklyRegular M as ↔ IsWeaklyRegular M₂ bs 
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₂] {e : M ≃+ M₂} {as : List R} {bs : List S} (h : List.Forall₂ (fun r s => ∀ (x : M), e (r • x) = s • e x) as bs)
Goal: RingTheory.Sequence.IsWeaklyRegular M as ↔ RingTheory.Sequence.IsWeaklyRegular M₂ bs
-- LinearEquiv.isWeaklyRegular_congr'
lemma _root_.LinearEquiv.isWeaklyRegular_congr' (e : M ≃ₛₗ[σ] M₂) (rs : List R) :
    IsWeaklyRegular M rs ↔ IsWeaklyRegular M₂ (rs.map σ) 
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₂] {σ : R →+* S} {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] (e : M ≃ₛₗ[σ] M₂) (rs : List R)
Goal: RingTheory.Sequence.IsWeaklyRegular M rs ↔ RingTheory.Sequence.IsWeaklyRegular M₂ (List.map (⇑σ) rs)
-- LinearEquiv.isWeaklyRegular_congr
lemma _root_.LinearEquiv.isWeaklyRegular_congr (e : M ≃ₗ[R] M₂) (rs : List R) :
    IsWeaklyRegular M rs ↔ IsWeaklyRegular M₂ rs 
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₂] (e : M ≃ₗ[R] M₂) (rs : List R)
Goal: RingTheory.Sequence.IsWeaklyRegular M rs ↔ RingTheory.Sequence.IsWeaklyRegular M₂ rs
-- AddEquiv.isRegular_congr
lemma _root_.AddEquiv.isRegular_congr {e : M ≃+ M₂} {as bs}
    (h : List.Forall₂ (fun (r : R) (s : S) => ∀ x, e (r • x) = s • e x) as bs) :
    IsRegular M as ↔ IsRegular M₂ bs 
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₂] {e : M ≃+ M₂} {as : List R} {bs : List S} (h : List.Forall₂ (fun r s => ∀ (x : M), e (r • x) = s • e x) as bs)
Goal: RingTheory.Sequence.IsRegular M as ↔ RingTheory.Sequence.IsRegular M₂ bs
-- LinearEquiv.isRegular_congr'
lemma _root_.LinearEquiv.isRegular_congr' (e : M ≃ₛₗ[σ] M₂) (rs : List R) :
    IsRegular M rs ↔ IsRegular M₂ (rs.map σ) 
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₂] {σ : R →+* S} {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] (e : M ≃ₛₗ[σ] M₂) (rs : List R)
Goal: RingTheory.Sequence.IsRegular M rs ↔ RingTheory.Sequence.IsRegular M₂ (List.map (⇑σ) rs)
-- LinearEquiv.isRegular_congr
lemma _root_.LinearEquiv.isRegular_congr (e : M ≃ₗ[R] M₂) (rs : List R) :
    IsRegular M rs ↔ IsRegular M₂ rs 
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₂] (e : M ≃ₗ[R] M₂) (rs : List R)
Goal: RingTheory.Sequence.IsRegular M rs ↔ RingTheory.Sequence.IsRegular M₂ rs
-- RingTheory.Sequence.isWeaklyRegular_map_algebraMap_iff
lemma isWeaklyRegular_map_algebraMap_iff [CommRing R] [CommRing S]
    [Algebra R S] [AddCommGroup M] [Module R M] [Module S M]
    [IsScalarTower R S M] (rs : List R) :
    IsWeaklyRegular M (rs.map (algebraMap R S)) ↔ IsWeaklyRegular M rs 
Arguments: {R : Type u_1} (S : Type u_2) (M : Type u_3) [CommRing R] [CommRing S] [Algebra R S] [AddCommGroup M] [Module R M] [Module S M] [IsScalarTower R S M] (rs : List R)
Goal: RingTheory.Sequence.IsWeaklyRegular M (List.map (⇑(algebraMap R S)) rs) ↔ RingTheory.Sequence.IsWeaklyRegular M rs
-- RingTheory.Sequence.isWeaklyRegular_cons_iff
@[simp]
lemma isWeaklyRegular_cons_iff (r : R) (rs : List R) :
    IsWeaklyRegular M (r :: rs) ↔
      IsSMulRegular M r ∧ IsWeaklyRegular (QuotSMulTop r M) rs 
Arguments: {R : Type u_1} (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M] (r : R) (rs : List R)
Goal: RingTheory.Sequence.IsWeaklyRegular M (r :: rs) ↔
  IsSMulRegular M r ∧ RingTheory.Sequence.IsWeaklyRegular (QuotSMulTop r M) rs
-- RingTheory.Sequence.isWeaklyRegular_cons_iff'
lemma isWeaklyRegular_cons_iff' (r : R) (rs : List R) :
    IsWeaklyRegular M (r :: rs) ↔
      IsSMulRegular M r ∧
        IsWeaklyRegular (QuotSMulTop r M)
          (rs.map (Ideal.Quotient.mk (Ideal.span {r}))) 
Arguments: {R : Type u_1} (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M] (r : R) (rs : List R)
Goal: RingTheory.Sequence.IsWeaklyRegular M (r :: rs) ↔
  IsSMulRegular M r ∧
    RingTheory.Sequence.IsWeaklyRegular (QuotSMulTop r M) (List.map (⇑(Ideal.Quotient.mk (Ideal.span {r}))) rs)
-- RingTheory.Sequence.isRegular_cons_iff
@[simp]
lemma isRegular_cons_iff (r : R) (rs : List R) :
    IsRegular M (r :: rs) ↔
      IsSMulRegular M r ∧ IsRegular (QuotSMulTop r M) rs 
Arguments: {R : Type u_1} (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M] (r : R) (rs : List R)
Goal: RingTheory.Sequence.IsRegular M (r :: rs) ↔ IsSMulRegular M r ∧ RingTheory.Sequence.IsRegular (QuotSMulTop r M) rs
-- RingTheory.Sequence.isRegular_cons_iff'
lemma isRegular_cons_iff' (r : R) (rs : List R) :
    IsRegular M (r :: rs) ↔
      IsSMulRegular M r ∧ IsRegular (QuotSMulTop r M)
          (rs.map (Ideal.Quotient.mk (Ideal.span {r}))) 
Arguments: {R : Type u_1} (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M] (r : R) (rs : List R)
Goal: RingTheory.Sequence.IsRegular M (r :: rs) ↔
  IsSMulRegular M r ∧
    RingTheory.Sequence.IsRegular (QuotSMulTop r M) (List.map (⇑(Ideal.Quotient.mk (Ideal.span {r}))) rs)
-- RingTheory.Sequence.IsWeaklyRegular.nil
@[simp] lemma nil : IsWeaklyRegular M ([] : List R) 
Arguments: (R : Type u_1) (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M]
Goal: RingTheory.Sequence.IsWeaklyRegular M []
-- RingTheory.Sequence.IsWeaklyRegular.cons
lemma cons {r : R} {rs : List R} (h1 : IsSMulRegular M r)
    (h2 : IsWeaklyRegular (QuotSMulTop r M) rs) : IsWeaklyRegular M (r :: rs) 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {r : R} {rs : List R} (h1 : IsSMulRegular M r) (h2 : RingTheory.Sequence.IsWeaklyRegular (QuotSMulTop r M) rs)
Goal: RingTheory.Sequence.IsWeaklyRegular M (r :: rs)
-- RingTheory.Sequence.IsWeaklyRegular.cons'
lemma cons' {r : R} {rs : List R} (h1 : IsSMulRegular M r)
    (h2 : IsWeaklyRegular (QuotSMulTop r M)
            (rs.map (Ideal.Quotient.mk (Ideal.span {r})))) :
    IsWeaklyRegular M (r :: rs) 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {r : R} {rs : List R} (h1 : IsSMulRegular M r) (h2 : RingTheory.Sequence.IsWeaklyRegular (QuotSMulTop r M) (List.map (⇑(Ideal.Quotient.mk (Ideal.span {r}))) rs))
Goal: RingTheory.Sequence.IsWeaklyRegular M (r :: rs)
-- RingTheory.Sequence.isWeaklyRegular_singleton_iff
lemma isWeaklyRegular_singleton_iff (r : R) :
    IsWeaklyRegular M [r] ↔ IsSMulRegular M r 
Arguments: {R : Type u_1} (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M] (r : R)
Goal: RingTheory.Sequence.IsWeaklyRegular M [r] ↔ IsSMulRegular M r
-- RingTheory.Sequence.isWeaklyRegular_append_iff
lemma isWeaklyRegular_append_iff (rs₁ rs₂ : List R) :
    IsWeaklyRegular M (rs₁ ++ rs₂) ↔
      IsWeaklyRegular M rs₁ ∧
        IsWeaklyRegular (M ⧸ (Ideal.ofList rs₁ • ⊤ : Submodule R M)) rs₂ 
Arguments: {R : Type u_1} (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M] (rs₁ rs₂ : List R)
Goal: RingTheory.Sequence.IsWeaklyRegular M (rs₁ ++ rs₂) ↔
  RingTheory.Sequence.IsWeaklyRegular M rs₁ ∧ RingTheory.Sequence.IsWeaklyRegular (M ⧸ Ideal.ofList rs₁ • ⊤) rs₂
-- RingTheory.Sequence.isWeaklyRegular_append_iff'
lemma isWeaklyRegular_append_iff' (rs₁ rs₂ : List R) :
    IsWeaklyRegular M (rs₁ ++ rs₂) ↔
      IsWeaklyRegular M rs₁ ∧
        IsWeaklyRegular (M ⧸ (Ideal.ofList rs₁ • ⊤ : Submodule R M))
          (rs₂.map (Ideal.Quotient.mk (Ideal.ofList rs₁))) 
Arguments: {R : Type u_1} (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M] (rs₁ rs₂ : List R)
Goal: RingTheory.Sequence.IsWeaklyRegular M (rs₁ ++ rs₂) ↔
  RingTheory.Sequence.IsWeaklyRegular M rs₁ ∧
    RingTheory.Sequence.IsWeaklyRegular (M ⧸ Ideal.ofList rs₁ • ⊤)
      (List.map (⇑(Ideal.Quotient.mk (Ideal.ofList rs₁))) rs₂)
-- RingTheory.Sequence.IsRegular.nil
lemma nil [Nontrivial M] : IsRegular M ([] : List R) 
Arguments: (R : Type u_1) (M : Type u_3) [CommRing R] [AddCommGroup M] [Module R M] [Nontrivial M]
Goal: RingTheory.Sequence.IsRegular M []
-- RingTheory.Sequence.IsRegular.cons
lemma cons {r : R} {rs : List R} (h1 : IsSMulRegular M r)
    (h2 : IsRegular (QuotSMulTop r M) rs) : IsRegular M (r :: rs) 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {r : R} {rs : List R} (h1 : IsSMulRegular M r) (h2 : RingTheory.Sequence.IsRegular (QuotSMulTop r M) rs)
Goal: RingTheory.Sequence.IsRegular M (r :: rs)
-- RingTheory.Sequence.IsRegular.cons'
lemma cons' {r : R} {rs : List R} (h1 : IsSMulRegular M r)
    (h2 : IsRegular (QuotSMulTop r M) (rs.map (Ideal.Quotient.mk (Ideal.span {r})))) :
    IsRegular M (r :: rs) 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {r : R} {rs : List R} (h1 : IsSMulRegular M r) (h2 : RingTheory.Sequence.IsRegular (QuotSMulTop r M) (List.map (⇑(Ideal.Quotient.mk (Ideal.span {r}))) rs))
Goal: RingTheory.Sequence.IsRegular M (r :: rs)
-- RingTheory.Sequence.IsRegular.quot_ofList_smul_nontrivial
lemma quot_ofList_smul_nontrivial {rs : List R} (h : IsRegular M rs)
    (N : Submodule R M) : Nontrivial (M ⧸ Ideal.ofList rs • N) 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {rs : List R} (h : RingTheory.Sequence.IsRegular M rs) (N : Submodule R M)
Goal: Nontrivial (M ⧸ Ideal.ofList rs • N)
-- RingTheory.Sequence.IsRegular.nontrivial
lemma nontrivial {rs : List R} (h : IsRegular M rs) : Nontrivial M 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {rs : List R} (h : RingTheory.Sequence.IsRegular M rs)
Goal: Nontrivial M
-- RingTheory.Sequence.isRegular_iff_isWeaklyRegular_of_subset_jacobson_annihilator
lemma isRegular_iff_isWeaklyRegular_of_subset_jacobson_annihilator
    [Nontrivial M] [Module.Finite R M] {rs : List R}
    (h : ∀ r ∈ rs, r ∈ Ideal.jacobson (Module.annihilator R M)) :
    IsRegular M rs ↔ IsWeaklyRegular M rs 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] [Nontrivial M] [Module.Finite R M] {rs : List R} (h : ∀ r ∈ rs, r ∈ (Module.annihilator R M).jacobson)
Goal: RingTheory.Sequence.IsRegular M rs ↔ RingTheory.Sequence.IsWeaklyRegular M rs
-- LocalRing.isRegular_iff_isWeaklyRegular_of_subset_maximalIdeal
lemma _root_.LocalRing.isRegular_iff_isWeaklyRegular_of_subset_maximalIdeal
    [LocalRing R] [Nontrivial M] [Module.Finite R M] {rs : List R}
    (h : ∀ r ∈ rs, r ∈ LocalRing.maximalIdeal R) :
    IsRegular M rs ↔ IsWeaklyRegular M rs 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] [LocalRing R] [Nontrivial M] [Module.Finite R M] {rs : List R} (h : ∀ r ∈ rs, r ∈ LocalRing.maximalIdeal R)
Goal: RingTheory.Sequence.IsRegular M rs ↔ RingTheory.Sequence.IsWeaklyRegular M rs
-- RingTheory.Sequence.eq_nil_of_isRegular_on_artinian
lemma eq_nil_of_isRegular_on_artinian [IsArtinian R M] :
    {rs : List R} → IsRegular M rs → rs = []
  
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] [IsArtinian R M] {rs : List R}
Goal: RingTheory.Sequence.IsRegular M rs → rs = []
-- RingTheory.Sequence.IsWeaklyRegular.isWeaklyRegular_lTensor
lemma IsWeaklyRegular.isWeaklyRegular_lTensor [Module.Flat R M₂]
    {rs : List R} (h : IsWeaklyRegular M rs) :
    IsWeaklyRegular (M₂ ⊗[R] M) rs 
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₂] [Module.Flat R M₂] {rs : List R} (h : RingTheory.Sequence.IsWeaklyRegular M rs)
Goal: RingTheory.Sequence.IsWeaklyRegular (TensorProduct R M₂ M) rs
-- RingTheory.Sequence.IsWeaklyRegular.isWeaklyRegular_rTensor
lemma IsWeaklyRegular.isWeaklyRegular_rTensor [Module.Flat R M₂]
    {rs : List R} (h : IsWeaklyRegular M rs) :
    IsWeaklyRegular (M ⊗[R] M₂) rs 
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₂] [Module.Flat R M₂] {rs : List R} (h : RingTheory.Sequence.IsWeaklyRegular M rs)
Goal: RingTheory.Sequence.IsWeaklyRegular (TensorProduct R M M₂) rs
-- RingTheory.Sequence.map_first_exact_on_four_term_right_exact_of_isSMulRegular_last
lemma map_first_exact_on_four_term_right_exact_of_isSMulRegular_last
    {rs : List R} {f₁ : M →ₗ[R] M₂} {f₂ : M₂ →ₗ[R] M₃} {f₃ : M₃ →ₗ[R] M₄}
    (h₁₂ : Exact f₁ f₂) (h₂₃ : Exact f₂ f₃) (h₃ : Surjective f₃)
    (h₄ : IsWeaklyRegular M₄ rs) :
    Exact (mapQ _ _ _ (smul_top_le_comap_smul_top (Ideal.ofList rs) f₁))
          (mapQ _ _ _ (smul_top_le_comap_smul_top (Ideal.ofList rs) f₂)) 
Arguments: {R : Type u_1} {M : Type u_3} {M₂ : Type u_4} {M₃ : Type u_5} {M₄ : Type u_6} [CommRing R] [AddCommGroup M] [AddCommGroup M₂] [AddCommGroup M₃] [AddCommGroup M₄] [Module R M] [Module R M₂] [Module R M₃] [Module R M₄] {rs : List R} {f₁ : M →ₗ[R] M₂} {f₂ : M₂ →ₗ[R] M₃} {f₃ : M₃ →ₗ[R] M₄} (h₁₂ : Function.Exact ⇑f₁ ⇑f₂) (h₂₃ : Function.Exact ⇑f₂ ⇑f₃) (h₃ : Function.Surjective ⇑f₃) (h₄ : RingTheory.Sequence.IsWeaklyRegular M₄ rs)
Goal: Function.Exact ⇑((Ideal.ofList rs • ⊤).mapQ (Ideal.ofList rs • ⊤) f₁ ⋯)
  ⇑((Ideal.ofList rs • ⊤).mapQ (Ideal.ofList rs • ⊤) f₂ ⋯)
-- _private.Mathlib.RingTheory.Regular.RegularSequence.0.RingTheory.Sequence.IsWeaklyRegular.swap
private lemma IsWeaklyRegular.swap {a b : R} (h1 : IsWeaklyRegular M [a, b])
    (h2 : torsionBy R M b = a • torsionBy R M b → torsionBy R M b = ⊥) :
    IsWeaklyRegular M [b, a] 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {a b : R} (h1 : RingTheory.Sequence.IsWeaklyRegular M [a, b]) (h2 : Submodule.torsionBy R M b = a • Submodule.torsionBy R M b → Submodule.torsionBy R M b = ⊥)
Goal: RingTheory.Sequence.IsWeaklyRegular M [b, a]
-- RingTheory.Sequence.IsWeaklyRegular.prototype_perm.aux
lemma IsWeaklyRegular.prototype_perm {rs : List R} (h : IsWeaklyRegular M rs)
    {rs'} (h'' : rs ~ rs') (h' : ∀ a b rs', (a :: b :: rs') <+~ rs →
      let K := torsionBy R (M ⧸ (Ideal.ofList rs' • ⊤ : Submodule R M)) b
      K = a • K → K = ⊥) : IsWeaklyRegular M rs' 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {rs : List R} (h' :
  ∀ (a b : R) (rs' : List R),
    (a :: b :: rs').Subperm rs →
      let K := Submodule.torsionBy R (M ⧸ Ideal.ofList rs' • ⊤) b;
      K = a • K → K = ⊥) {rs₁ rs₂ : List R} (rs₀ : List R) (h₁₂ : rs₁.Perm rs₂) (H₁ : (rs₀ ++ rs₁).Subperm rs) (H₃ : (rs₀ ++ rs₂).Subperm rs) (h : RingTheory.Sequence.IsWeaklyRegular (M ⧸ Ideal.ofList rs₀ • ⊤) rs₁)
Goal: RingTheory.Sequence.IsWeaklyRegular (M ⧸ Ideal.ofList rs₀ • ⊤) rs₂
-- RingTheory.Sequence.IsWeaklyRegular.prototype_perm
lemma IsWeaklyRegular.prototype_perm {rs : List R} (h : IsWeaklyRegular M rs)
    {rs'} (h'' : rs ~ rs') (h' : ∀ a b rs', (a :: b :: rs') <+~ rs →
      let K := torsionBy R (M ⧸ (Ideal.ofList rs' • ⊤ : Submodule R M)) b
      K = a • K → K = ⊥) : IsWeaklyRegular M rs' 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {rs : List R} (h : RingTheory.Sequence.IsWeaklyRegular M rs) {rs' : List R} (h'' : rs.Perm rs') (h' :
  ∀ (a b : R) (rs' : List R),
    (a :: b :: rs').Subperm rs →
      let K := Submodule.torsionBy R (M ⧸ Ideal.ofList rs' • ⊤) b;
      K = a • K → K = ⊥)
Goal: RingTheory.Sequence.IsWeaklyRegular M rs'
-- RingTheory.Sequence.IsWeaklyRegular.of_perm_of_subset_jacobson_annihilator
lemma IsWeaklyRegular.of_perm_of_subset_jacobson_annihilator [IsNoetherian R M]
    {rs rs' : List R} (h1 : IsWeaklyRegular M rs) (h2 : List.Perm rs rs')
    (h3 : ∀ r ∈ rs, r ∈ (Module.annihilator R M).jacobson) :
    IsWeaklyRegular M rs' 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] [IsNoetherian R M] {rs rs' : List R} (h1 : RingTheory.Sequence.IsWeaklyRegular M rs) (h2 : rs.Perm rs') (h3 : ∀ r ∈ rs, r ∈ (Module.annihilator R M).jacobson)
Goal: RingTheory.Sequence.IsWeaklyRegular M rs'
-- RingTheory.Sequence.IsRegular.of_perm_of_subset_jacobson_annihilator
lemma IsRegular.of_perm_of_subset_jacobson_annihilator [IsNoetherian R M]
    {rs rs' : List R} (h1 : IsRegular M rs) (h2 : List.Perm rs rs')
    (h3 : ∀ r ∈ rs, r ∈ (Module.annihilator R M).jacobson) : IsRegular M rs' 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] [IsNoetherian R M] {rs rs' : List R} (h1 : RingTheory.Sequence.IsRegular M rs) (h2 : rs.Perm rs') (h3 : ∀ r ∈ rs, r ∈ (Module.annihilator R M).jacobson)
Goal: RingTheory.Sequence.IsRegular M rs'
-- LocalRing.isWeaklyRegular_of_perm_of_subset_maximalIdeal
lemma _root_.LocalRing.isWeaklyRegular_of_perm_of_subset_maximalIdeal
    [LocalRing R] [IsNoetherian R M] {rs rs' : List R}
    (h1 : IsWeaklyRegular M rs) (h2 : List.Perm rs rs')
    (h3 : ∀ r ∈ rs, r ∈ LocalRing.maximalIdeal R) : IsWeaklyRegular M rs' 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] [LocalRing R] [IsNoetherian R M] {rs rs' : List R} (h1 : RingTheory.Sequence.IsWeaklyRegular M rs) (h2 : rs.Perm rs') (h3 : ∀ r ∈ rs, r ∈ LocalRing.maximalIdeal R)
Goal: RingTheory.Sequence.IsWeaklyRegular M rs'
-- LocalRing.isRegular_of_perm
lemma _root_.LocalRing.isRegular_of_perm [LocalRing R] [IsNoetherian R M]
    {rs rs' : List R} (h1 : IsRegular M rs) (h2 : List.Perm rs rs') :
    IsRegular M rs' 
Arguments: {R : Type u_1} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] [LocalRing R] [IsNoetherian R M] {rs rs' : List R} (h1 : RingTheory.Sequence.IsRegular M rs) (h2 : rs.Perm rs')
Goal: RingTheory.Sequence.IsRegular M rs'
-- Finset.univ_of_card_le_two
lemma Finset.univ_of_card_le_two (h : Fintype.card R ≤ 2) :
    (univ : Finset R) = {0, 1} 
Arguments: {R : Type u_1} [Ring R] [Fintype R] [DecidableEq R] (h : Fintype.card R ≤ 2)
Goal: Finset.univ = {0, 1}
-- Finset.univ_of_card_le_three
lemma Finset.univ_of_card_le_three (h : Fintype.card R ≤ 3) :
    (univ : Finset R) = {0, 1, -1} 
Arguments: {R : Type u_1} [Ring R] [Fintype R] [DecidableEq R] (h : Fintype.card R ≤ 3)
Goal: Finset.univ = {0, 1, -1}
-- card_units_lt
theorem card_units_lt (M₀ : Type*) [MonoidWithZero M₀] [Nontrivial M₀] [Fintype M₀] :
    Fintype.card M₀ˣ < Fintype.card M₀ 
Arguments: (M₀ : Type u_2) [MonoidWithZero M₀] [Nontrivial M₀] [Fintype M₀]
Goal: Fintype.card M₀ˣ < Fintype.card M₀
-- span_eq_top_of_isLocalizedModule
theorem span_eq_top_of_isLocalizedModule {v : Set M} (hv : span R v = ⊤) :
    span Rₛ (f '' v) = ⊤ 
Arguments: {R : Type u_1} (Rₛ : Type u_2) [CommSemiring R] (S : Submonoid R) [CommSemiring Rₛ] [Algebra R Rₛ] [hT : IsLocalization S Rₛ] {M : Type u_3} {M' : Type u_4} [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M'] [Module Rₛ M'] [IsScalarTower R Rₛ M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] {v : Set M} (hv : Submodule.span R v = ⊤)
Goal: Submodule.span Rₛ (⇑f '' v) = ⊤
-- LinearIndependent.of_isLocalizedModule
theorem LinearIndependent.of_isLocalizedModule {ι : Type*} {v : ι → M}
    (hv : LinearIndependent R v) : LinearIndependent Rₛ (f ∘ v) 
Arguments: {R : Type u_1} (Rₛ : Type u_2) [CommSemiring R] (S : Submonoid R) [CommSemiring Rₛ] [Algebra R Rₛ] [hT : IsLocalization S Rₛ] {M : Type u_3} {M' : Type u_4} [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M'] [Module Rₛ M'] [IsScalarTower R Rₛ M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] {ι : Type u_5} {v : ι → M} (hv : LinearIndependent R v)
Goal: LinearIndependent Rₛ (⇑f ∘ v)
-- LinearIndependent.localization
theorem LinearIndependent.localization {ι : Type*} {b : ι → M} (hli : LinearIndependent R b) :
    LinearIndependent Rₛ b 
Arguments: {R : Type u_1} (Rₛ : Type u_2) [CommSemiring R] (S : Submonoid R) [CommSemiring Rₛ] [Algebra R Rₛ] [hT : IsLocalization S Rₛ] {M : Type u_3} [AddCommMonoid M] [Module R M] [Module Rₛ M] [IsScalarTower R Rₛ M] {ι : Type u_5} {b : ι → M} (hli : LinearIndependent R b)
Goal: LinearIndependent Rₛ b
-- Basis.ofIsLocalizedModule_apply
@[simp]
theorem Basis.ofIsLocalizedModule_apply (i : ι) : b.ofIsLocalizedModule Rₛ S f i = f (b i) 
Arguments: {R : Type u_1} (Rₛ : Type u_2) [CommSemiring R] (S : Submonoid R) [CommRing Rₛ] [Algebra R Rₛ] [hT : IsLocalization S Rₛ] {M : Type u_3} {Mₛ : Type u_4} [AddCommGroup M] [AddCommGroup Mₛ] [Module R M] [Module R Mₛ] [Module Rₛ Mₛ] (f : M →ₗ[R] Mₛ) [IsLocalizedModule S f] [IsScalarTower R Rₛ Mₛ] {ι : Type u_5} (b : Basis ι R M) (i : ι)
Goal: (Basis.ofIsLocalizedModule Rₛ S f b) i = f (b i)
-- Basis.ofIsLocalizedModule_repr_apply
@[simp]
theorem Basis.ofIsLocalizedModule_repr_apply (m : M) (i : ι) :
    ((b.ofIsLocalizedModule Rₛ S f).repr (f m)) i = algebraMap R Rₛ (b.repr m i) 
Arguments: {R : Type u_1} (Rₛ : Type u_2) [CommSemiring R] (S : Submonoid R) [CommRing Rₛ] [Algebra R Rₛ] [hT : IsLocalization S Rₛ] {M : Type u_3} {Mₛ : Type u_4} [AddCommGroup M] [AddCommGroup Mₛ] [Module R M] [Module R Mₛ] [Module Rₛ Mₛ] (f : M →ₗ[R] Mₛ) [IsLocalizedModule S f] [IsScalarTower R Rₛ Mₛ] {ι : Type u_5} (b : Basis ι R M) (m : M) (i : ι)
Goal: ((Basis.ofIsLocalizedModule Rₛ S f b).repr (f m)) i = (algebraMap R Rₛ) ((b.repr m) i)
-- Basis.ofIsLocalizedModule_span
theorem Basis.ofIsLocalizedModule_span :
    span R (Set.range (b.ofIsLocalizedModule Rₛ S f)) = LinearMap.range f 
Arguments: {R : Type u_1} (Rₛ : Type u_2) [CommSemiring R] (S : Submonoid R) [CommRing Rₛ] [Algebra R Rₛ] [hT : IsLocalization S Rₛ] {M : Type u_3} {Mₛ : Type u_4} [AddCommGroup M] [AddCommGroup Mₛ] [Module R M] [Module R Mₛ] [Module Rₛ Mₛ] (f : M →ₗ[R] Mₛ) [IsLocalizedModule S f] [IsScalarTower R Rₛ Mₛ] {ι : Type u_5} (b : Basis ι R M)
Goal: Submodule.span R (Set.range ⇑(Basis.ofIsLocalizedModule Rₛ S f b)) = LinearMap.range f
-- LinearIndependent.localization_localization
theorem LinearIndependent.localization_localization {ι : Type*} {v : ι → A}
    (hv : LinearIndependent R v) : LinearIndependent Rₛ ((algebraMap A Aₛ) ∘ v) 
Arguments: {R : Type u_3} (Rₛ : Type u_4) [CommSemiring R] [CommRing Rₛ] [Algebra R Rₛ] (S : Submonoid R) [hT : IsLocalization S Rₛ] {A : Type u_5} [CommRing A] [Algebra R A] (Aₛ : Type u_6) [CommRing Aₛ] [Algebra A Aₛ] [Algebra Rₛ Aₛ] [Algebra R Aₛ] [IsScalarTower R Rₛ Aₛ] [IsScalarTower R A Aₛ] [hA : IsLocalization (Algebra.algebraMapSubmonoid A S) Aₛ] {ι : Type u_7} {v : ι → A} (hv : LinearIndependent R v)
Goal: LinearIndependent Rₛ (⇑(algebraMap A Aₛ) ∘ v)
-- span_eq_top_localization_localization
theorem span_eq_top_localization_localization {v : Set A} (hv : span R v = ⊤) :
    span Rₛ (algebraMap A Aₛ '' v) = ⊤ 
Arguments: {R : Type u_3} (Rₛ : Type u_4) [CommSemiring R] [CommRing Rₛ] [Algebra R Rₛ] (S : Submonoid R) [hT : IsLocalization S Rₛ] {A : Type u_5} [CommRing A] [Algebra R A] (Aₛ : Type u_6) [CommRing Aₛ] [Algebra A Aₛ] [Algebra Rₛ Aₛ] [Algebra R Aₛ] [IsScalarTower R Rₛ Aₛ] [IsScalarTower R A Aₛ] [hA : IsLocalization (Algebra.algebraMapSubmonoid A S) Aₛ] {v : Set A} (hv : Submodule.span R v = ⊤)
Goal: Submodule.span Rₛ (⇑(algebraMap A Aₛ) '' v) = ⊤
-- Basis.localizationLocalization_apply
@[simp]
theorem Basis.localizationLocalization_apply {ι : Type*} (b : Basis ι R A) (i) :
    b.localizationLocalization Rₛ S Aₛ i = algebraMap A Aₛ (b i) 
Arguments: {R : Type u_3} (Rₛ : Type u_4) [CommSemiring R] [CommRing Rₛ] [Algebra R Rₛ] (S : Submonoid R) [hT : IsLocalization S Rₛ] {A : Type u_5} [CommRing A] [Algebra R A] (Aₛ : Type u_6) [CommRing Aₛ] [Algebra A Aₛ] [Algebra Rₛ Aₛ] [Algebra R Aₛ] [IsScalarTower R Rₛ Aₛ] [IsScalarTower R A Aₛ] [hA : IsLocalization (Algebra.algebraMapSubmonoid A S) Aₛ] {ι : Type u_7} (b : Basis ι R A) (i : ι)
Goal: (Basis.localizationLocalization Rₛ S Aₛ b) i = (algebraMap A Aₛ) (b i)