ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Ideal.exists_coeff_ne_zero_mem_comap_of_root_mem
theorem exists_coeff_ne_zero_mem_comap_of_root_mem [IsDomain S] {r : S} (r_ne_zero : r ≠ 0)
    (hr : r ∈ I) {p : R[X]} :
    p ≠ 0 → p.eval₂ f r = 0 → ∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ I.comap f 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] {f : R →+* S} {I : Ideal S} [IsDomain S] {r : S} (r_ne_zero : r ≠ 0) (hr : r ∈ I) {p : Polynomial R}
Goal: p ≠ 0 → Polynomial.eval₂ f r p = 0 → ∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ Ideal.comap f I
-- Ideal.exists_coeff_mem_comap_sdiff_comap_of_root_mem_sdiff
theorem exists_coeff_mem_comap_sdiff_comap_of_root_mem_sdiff [IsPrime I] (hIJ : I ≤ J) {r : S}
    (hr : r ∈ (J : Set S) \ I) {p : R[X]} (p_ne_zero : p.map (Quotient.mk (I.comap f)) ≠ 0)
    (hpI : p.eval₂ f r ∈ I) : ∃ i, p.coeff i ∈ (J.comap f : Set R) \ I.comap f 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] {f : R →+* S} {I J : Ideal S} [I.IsPrime] (hIJ : I ≤ J) {r : S} (hr : r ∈ ↑J \ ↑I) {p : Polynomial R} (p_ne_zero : Polynomial.map (Ideal.Quotient.mk (Ideal.comap f I)) p ≠ 0) (hpI : Polynomial.eval₂ f r p ∈ I)
Goal: ∃ i, p.coeff i ∈ ↑(Ideal.comap f J) \ ↑(Ideal.comap f I)
-- Ideal.comap_lt_comap_of_root_mem_sdiff
theorem comap_lt_comap_of_root_mem_sdiff [I.IsPrime] (hIJ : I ≤ J) {r : S}
    (hr : r ∈ (J : Set S) \ I) {p : R[X]} (p_ne_zero : p.map (Quotient.mk (I.comap f)) ≠ 0)
    (hp : p.eval₂ f r ∈ I) : I.comap f < J.comap f 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] {f : R →+* S} {I J : Ideal S} [I.IsPrime] (hIJ : I ≤ J) {r : S} (hr : r ∈ ↑J \ ↑I) {p : Polynomial R} (p_ne_zero : Polynomial.map (Ideal.Quotient.mk (Ideal.comap f I)) p ≠ 0) (hp : Polynomial.eval₂ f r p ∈ I)
Goal: Ideal.comap f I < Ideal.comap f J
-- Ideal.mem_of_one_mem
theorem mem_of_one_mem (h : (1 : S) ∈ I) (x) : x ∈ I 
Arguments: {S : Type u_2} [CommRing S] {I : Ideal S} (h : 1 ∈ I) (x : S)
Goal: x ∈ I
-- Ideal.comap_lt_comap_of_integral_mem_sdiff
theorem comap_lt_comap_of_integral_mem_sdiff [Algebra R S] [hI : I.IsPrime] (hIJ : I ≤ J) {x : S}
    (mem : x ∈ (J : Set S) \ I) (integral : IsIntegral R x) :
    I.comap (algebraMap R S) < J.comap (algebraMap R S) 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] {I J : Ideal S} [Algebra R S] [hI : I.IsPrime] (hIJ : I ≤ J) {x : S} (mem : x ∈ ↑J \ ↑I) (integral : IsIntegral R x)
Goal: Ideal.comap (algebraMap R S) I < Ideal.comap (algebraMap R S) J
-- Ideal.comap_ne_bot_of_root_mem
theorem comap_ne_bot_of_root_mem [IsDomain S] {r : S} (r_ne_zero : r ≠ 0) (hr : r ∈ I) {p : R[X]}
    (p_ne_zero : p ≠ 0) (hp : p.eval₂ f r = 0) : I.comap f ≠ ⊥ 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] {f : R →+* S} {I : Ideal S} [IsDomain S] {r : S} (r_ne_zero : r ≠ 0) (hr : r ∈ I) {p : Polynomial R} (p_ne_zero : p ≠ 0) (hp : Polynomial.eval₂ f r p = 0)
Goal: Ideal.comap f I ≠ ⊥
-- Ideal.isMaximal_of_isIntegral_of_isMaximal_comap
theorem isMaximal_of_isIntegral_of_isMaximal_comap [Algebra R S] [Algebra.IsIntegral R S]
    (I : Ideal S) [I.IsPrime] (hI : IsMaximal (I.comap (algebraMap R S))) : IsMaximal I 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] [Algebra R S] [Algebra.IsIntegral R S] (I : Ideal S) [I.IsPrime] (hI : (Ideal.comap (algebraMap R S) I).IsMaximal)
Goal: I.IsMaximal
-- Ideal.isMaximal_of_isIntegral_of_isMaximal_comap'
theorem isMaximal_of_isIntegral_of_isMaximal_comap' (f : R →+* S) (hf : f.IsIntegral) (I : Ideal S)
    [I.IsPrime] (hI : IsMaximal (I.comap f)) : IsMaximal I 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] (f : R →+* S) (hf : f.IsIntegral) (I : Ideal S) [I.IsPrime] (hI : (Ideal.comap f I).IsMaximal)
Goal: I.IsMaximal
-- Ideal.comap_ne_bot_of_algebraic_mem
theorem comap_ne_bot_of_algebraic_mem [IsDomain S] {x : S} (x_ne_zero : x ≠ 0) (x_mem : x ∈ I)
    (hx : IsAlgebraic R x) : I.comap (algebraMap R S) ≠ ⊥ 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] {I : Ideal S} [Algebra R S] [IsDomain S] {x : S} (x_ne_zero : x ≠ 0) (x_mem : x ∈ I) (hx : IsAlgebraic R x)
Goal: Ideal.comap (algebraMap R S) I ≠ ⊥
-- Ideal.comap_ne_bot_of_integral_mem
theorem comap_ne_bot_of_integral_mem [Nontrivial R] [IsDomain S] {x : S} (x_ne_zero : x ≠ 0)
    (x_mem : x ∈ I) (hx : IsIntegral R x) : I.comap (algebraMap R S) ≠ ⊥ 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] {I : Ideal S} [Algebra R S] [Nontrivial R] [IsDomain S] {x : S} (x_ne_zero : x ≠ 0) (x_mem : x ∈ I) (hx : IsIntegral R x)
Goal: Ideal.comap (algebraMap R S) I ≠ ⊥
-- Ideal.eq_bot_of_comap_eq_bot
theorem eq_bot_of_comap_eq_bot [Nontrivial R] [IsDomain S] [Algebra.IsIntegral R S]
    (hI : I.comap (algebraMap R S) = ⊥) : I = ⊥ 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] {I : Ideal S} [Algebra R S] [Nontrivial R] [IsDomain S] [Algebra.IsIntegral R S] (hI : Ideal.comap (algebraMap R S) I = ⊥)
Goal: I = ⊥
-- Ideal.isMaximal_comap_of_isIntegral_of_isMaximal
theorem isMaximal_comap_of_isIntegral_of_isMaximal [Algebra.IsIntegral R S] (I : Ideal S)
    [hI : I.IsMaximal] : IsMaximal (I.comap (algebraMap R S)) 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] [Algebra R S] [Algebra.IsIntegral R S] (I : Ideal S) [hI : I.IsMaximal]
Goal: (Ideal.comap (algebraMap R S) I).IsMaximal
-- Ideal.isMaximal_comap_of_isIntegral_of_isMaximal'
theorem isMaximal_comap_of_isIntegral_of_isMaximal' {R S : Type*} [CommRing R] [CommRing S]
    (f : R →+* S) (hf : f.IsIntegral) (I : Ideal S) [I.IsMaximal] : IsMaximal (I.comap f) 
Arguments: {R : Type u_3} {S : Type u_4} [CommRing R] [CommRing S] (f : R →+* S) (hf : f.IsIntegral) (I : Ideal S) [I.IsMaximal]
Goal: (Ideal.comap f I).IsMaximal
-- Ideal.IsIntegralClosure.comap_lt_comap
theorem IsIntegralClosure.comap_lt_comap {I J : Ideal A} [I.IsPrime] (I_lt_J : I < J) :
    I.comap (algebraMap R A) < J.comap (algebraMap R A) 
Arguments: {R : Type u_1} [CommRing R] (S : Type u_2) [CommRing S] [Algebra R S] {A : Type u_3} [CommRing A] [Algebra R A] [Algebra A S] [IsScalarTower R A S] [IsIntegralClosure A R S] {I J : Ideal A} [I.IsPrime] (I_lt_J : I < J)
Goal: Ideal.comap (algebraMap R A) I < Ideal.comap (algebraMap R A) J
-- Ideal.IsIntegralClosure.isMaximal_of_isMaximal_comap
theorem IsIntegralClosure.isMaximal_of_isMaximal_comap (I : Ideal A) [I.IsPrime]
    (hI : IsMaximal (I.comap (algebraMap R A))) : IsMaximal I 
Arguments: {R : Type u_1} [CommRing R] (S : Type u_2) [CommRing S] [Algebra R S] {A : Type u_3} [CommRing A] [Algebra R A] [Algebra A S] [IsScalarTower R A S] [IsIntegralClosure A R S] (I : Ideal A) [I.IsPrime] (hI : (Ideal.comap (algebraMap R A) I).IsMaximal)
Goal: I.IsMaximal
-- Ideal.IsIntegralClosure.comap_ne_bot
theorem IsIntegralClosure.comap_ne_bot [Nontrivial R] {I : Ideal A} (I_ne_bot : I ≠ ⊥) :
    I.comap (algebraMap R A) ≠ ⊥ 
Arguments: {R : Type u_1} [CommRing R] (S : Type u_2) [CommRing S] [Algebra R S] {A : Type u_3} [CommRing A] [Algebra R A] [Algebra A S] [IsScalarTower R A S] [IsIntegralClosure A R S] [IsDomain A] [Nontrivial R] {I : Ideal A} (I_ne_bot : I ≠ ⊥)
Goal: Ideal.comap (algebraMap R A) I ≠ ⊥
-- Ideal.IsIntegralClosure.eq_bot_of_comap_eq_bot
theorem IsIntegralClosure.eq_bot_of_comap_eq_bot [Nontrivial R] {I : Ideal A} :
    I.comap (algebraMap R A) = ⊥ → I = ⊥ 
Arguments: {R : Type u_1} [CommRing R] (S : Type u_2) [CommRing S] [Algebra R S] {A : Type u_3} [CommRing A] [Algebra R A] [Algebra A S] [IsScalarTower R A S] [IsIntegralClosure A R S] [IsDomain A] [Nontrivial R] {I : Ideal A}
Goal: Ideal.comap (algebraMap R A) I = ⊥ → I = ⊥
-- Ideal.IntegralClosure.comap_lt_comap
theorem IntegralClosure.comap_lt_comap {I J : Ideal (integralClosure R S)} [I.IsPrime]
    (I_lt_J : I < J) :
    I.comap (algebraMap R (integralClosure R S)) < J.comap (algebraMap R (integralClosure R S)) 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] [Algebra R S] {I J : Ideal ↥(integralClosure R S)} [I.IsPrime] (I_lt_J : I < J)
Goal: Ideal.comap (algebraMap R ↥(integralClosure R S)) I < Ideal.comap (algebraMap R ↥(integralClosure R S)) J
-- Ideal.IntegralClosure.isMaximal_of_isMaximal_comap
theorem IntegralClosure.isMaximal_of_isMaximal_comap (I : Ideal (integralClosure R S)) [I.IsPrime]
    (hI : IsMaximal (I.comap (algebraMap R (integralClosure R S)))) : IsMaximal I 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] [Algebra R S] (I : Ideal ↥(integralClosure R S)) [I.IsPrime] (hI : (Ideal.comap (algebraMap R ↥(integralClosure R S)) I).IsMaximal)
Goal: I.IsMaximal
-- Ideal.IntegralClosure.comap_ne_bot
theorem IntegralClosure.comap_ne_bot [Nontrivial R] {I : Ideal (integralClosure R S)}
    (I_ne_bot : I ≠ ⊥) : I.comap (algebraMap R (integralClosure R S)) ≠ ⊥ 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] [Algebra R S] [IsDomain S] [Nontrivial R] {I : Ideal ↥(integralClosure R S)} (I_ne_bot : I ≠ ⊥)
Goal: Ideal.comap (algebraMap R ↥(integralClosure R S)) I ≠ ⊥
-- Ideal.IntegralClosure.eq_bot_of_comap_eq_bot
theorem IntegralClosure.eq_bot_of_comap_eq_bot [Nontrivial R] {I : Ideal (integralClosure R S)} :
    I.comap (algebraMap R (integralClosure R S)) = ⊥ → I = ⊥ 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] [Algebra R S] [IsDomain S] [Nontrivial R] {I : Ideal ↥(integralClosure R S)}
Goal: Ideal.comap (algebraMap R ↥(integralClosure R S)) I = ⊥ → I = ⊥
-- Ideal.exists_ideal_over_prime_of_isIntegral_of_isDomain
theorem exists_ideal_over_prime_of_isIntegral_of_isDomain [Algebra.IsIntegral R S] (P : Ideal R)
    [IsPrime P] (hP : RingHom.ker (algebraMap R S) ≤ P) :
    ∃ Q : Ideal S, IsPrime Q ∧ Q.comap (algebraMap R S) = P 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] [Algebra R S] [IsDomain S] [Algebra.IsIntegral R S] (P : Ideal R) [P.IsPrime] (hP : RingHom.ker (algebraMap R S) ≤ P)
Goal: ∃ Q, Q.IsPrime ∧ Ideal.comap (algebraMap R S) Q = P
-- Ideal.exists_ideal_over_prime_of_isIntegral_of_isPrime
theorem exists_ideal_over_prime_of_isIntegral_of_isPrime
    [Algebra.IsIntegral R S] (P : Ideal R) [IsPrime P]
    (I : Ideal S) [IsPrime I] (hIP : I.comap (algebraMap R S) ≤ P) :
    ∃ Q ≥ I, IsPrime Q ∧ Q.comap (algebraMap R S) = P 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] [Algebra R S] [Algebra.IsIntegral R S] (P : Ideal R) [P.IsPrime] (I : Ideal S) [I.IsPrime] (hIP : Ideal.comap (algebraMap R S) I ≤ P)
Goal: ∃ Q ≥ I, Q.IsPrime ∧ Ideal.comap (algebraMap R S) Q = P
-- Ideal.exists_ideal_comap_le_prime
lemma exists_ideal_comap_le_prime (P : Ideal R) [P.IsPrime]
    (I : Ideal S) (hI : I.comap (algebraMap R S) ≤ P) :
    ∃ Q ≥ I, Q.IsPrime ∧ Q.comap (algebraMap R S) ≤ P 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] [Algebra R S] (P : Ideal R) [P.IsPrime] (I : Ideal S) (hI : Ideal.comap (algebraMap R S) I ≤ P)
Goal: ∃ Q ≥ I, Q.IsPrime ∧ Ideal.comap (algebraMap R S) Q ≤ P
-- Ideal.exists_ideal_over_prime_of_isIntegral
theorem exists_ideal_over_prime_of_isIntegral [Algebra.IsIntegral R S] (P : Ideal R) [IsPrime P]
    (I : Ideal S) (hIP : I.comap (algebraMap R S) ≤ P) :
    ∃ Q ≥ I, IsPrime Q ∧ Q.comap (algebraMap R S) = P 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] [Algebra R S] [Algebra.IsIntegral R S] (P : Ideal R) [P.IsPrime] (I : Ideal S) (hIP : Ideal.comap (algebraMap R S) I ≤ P)
Goal: ∃ Q ≥ I, Q.IsPrime ∧ Ideal.comap (algebraMap R S) Q = P
-- Ideal.exists_ideal_over_maximal_of_isIntegral
theorem exists_ideal_over_maximal_of_isIntegral [Algebra.IsIntegral R S]
    (P : Ideal R) [P_max : IsMaximal P] (hP : RingHom.ker (algebraMap R S) ≤ P) :
    ∃ Q : Ideal S, IsMaximal Q ∧ Q.comap (algebraMap R S) = P 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] [Algebra R S] [Algebra.IsIntegral R S] (P : Ideal R) [P_max : P.IsMaximal] (hP : RingHom.ker (algebraMap R S) ≤ P)
Goal: ∃ Q, Q.IsMaximal ∧ Ideal.comap (algebraMap R S) Q = P
-- Ideal.map_eq_top_iff_of_ker_le
lemma map_eq_top_iff_of_ker_le
    (f : R →+* S) {I : Ideal R} (hf₁ : RingHom.ker f ≤ I) (hf₂ : f.IsIntegral) :
    I.map f = ⊤ ↔ I = ⊤ 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] (f : R →+* S) {I : Ideal R} (hf₁ : RingHom.ker f ≤ I) (hf₂ : f.IsIntegral)
Goal: Ideal.map f I = ⊤ ↔ I = ⊤
-- Ideal.map_eq_top_iff
lemma map_eq_top_iff
    (f : R →+* S) {I : Ideal R} (hf₁ : Function.Injective f) (hf₂ : f.IsIntegral) :
    I.map f = ⊤ ↔ I = ⊤ 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] (f : R →+* S) {I : Ideal R} (hf₁ : Function.Injective ⇑f) (hf₂ : f.IsIntegral)
Goal: Ideal.map f I = ⊤ ↔ I = ⊤
-- Ideal.toCotangent_apply
@[simps! (config := .lemmasOnly) apply]
def toCotangent : I →ₗ[R] I.Cotangent 
Arguments: {R : Type u} [CommRing R] (I : Ideal R)
Goal: ∀ (a : ↥I), I.toCotangent a = Submodule.Quotient.mk a
-- Ideal.map_toCotangent_ker
theorem map_toCotangent_ker : I.toCotangent.ker.map I.subtype = I ^ 2 
Arguments: {R : Type u} [CommRing R] (I : Ideal R)
Goal: Submodule.map (Submodule.subtype I) (LinearMap.ker I.toCotangent) = I ^ 2
-- Ideal.mem_toCotangent_ker
theorem mem_toCotangent_ker {x : I} : x ∈ LinearMap.ker I.toCotangent ↔ (x : R) ∈ I ^ 2 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) {x : ↥I}
Goal: x ∈ LinearMap.ker I.toCotangent ↔ ↑x ∈ I ^ 2
-- Ideal.toCotangent_eq
theorem toCotangent_eq {x y : I} : I.toCotangent x = I.toCotangent y ↔ (x - y : R) ∈ I ^ 2 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) {x y : ↥I}
Goal: I.toCotangent x = I.toCotangent y ↔ ↑x - ↑y ∈ I ^ 2
-- Ideal.toCotangent_eq_zero
theorem toCotangent_eq_zero (x : I) : I.toCotangent x = 0 ↔ (x : R) ∈ I ^ 2 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (x : ↥I)
Goal: I.toCotangent x = 0 ↔ ↑x ∈ I ^ 2
-- Ideal.toCotangent_surjective
theorem toCotangent_surjective : Function.Surjective I.toCotangent 
Arguments: {R : Type u} [CommRing R] (I : Ideal R)
Goal: Function.Surjective ⇑I.toCotangent
-- Ideal.toCotangent_range
theorem toCotangent_range : LinearMap.range I.toCotangent = ⊤ 
Arguments: {R : Type u} [CommRing R] (I : Ideal R)
Goal: LinearMap.range I.toCotangent = ⊤
-- Ideal.cotangent_subsingleton_iff
theorem cotangent_subsingleton_iff : Subsingleton I.Cotangent ↔ IsIdempotentElem I 
Arguments: {R : Type u} [CommRing R] (I : Ideal R)
Goal: Subsingleton I.Cotangent ↔ IsIdempotentElem I
-- Ideal.to_quotient_square_comp_toCotangent
theorem to_quotient_square_comp_toCotangent :
    I.cotangentToQuotientSquare.comp I.toCotangent = (I ^ 2).mkQ.comp (Submodule.subtype I) 
Arguments: {R : Type u} [CommRing R] (I : Ideal R)
Goal: I.cotangentToQuotientSquare ∘ₗ I.toCotangent = Submodule.mkQ (I ^ 2) ∘ₗ Submodule.subtype I
-- Ideal.toCotangent_to_quotient_square
@[simp]
theorem toCotangent_to_quotient_square (x : I) :
    I.cotangentToQuotientSquare (I.toCotangent x) = (I ^ 2).mkQ x 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (x : ↥I)
Goal: I.cotangentToQuotientSquare (I.toCotangent x) = (Submodule.mkQ (I ^ 2)) ↑x
-- Ideal.cotangentIdeal_square
theorem cotangentIdeal_square (I : Ideal R) : I.cotangentIdeal ^ 2 = ⊥ 
Arguments: {R : Type u} [CommRing R] (I : Ideal R)
Goal: I.cotangentIdeal ^ 2 = ⊥
-- Ideal.to_quotient_square_range
theorem to_quotient_square_range :
    LinearMap.range I.cotangentToQuotientSquare = I.cotangentIdeal.restrictScalars R 
Arguments: {R : Type u} [CommRing R] (I : Ideal R)
Goal: LinearMap.range I.cotangentToQuotientSquare = Submodule.restrictScalars R I.cotangentIdeal
-- Ideal.cotangentEquivIdeal_apply
@[simp]
theorem cotangentEquivIdeal_apply (x : I.Cotangent) :
    ↑(I.cotangentEquivIdeal x) = I.cotangentToQuotientSquare x 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (x : I.Cotangent)
Goal: ↑(I.cotangentEquivIdeal x) = I.cotangentToQuotientSquare x
-- Ideal.cotangentEquivIdeal_symm_apply
theorem cotangentEquivIdeal_symm_apply (x : R) (hx : x ∈ I) :
    -- Note: #8386 had to specify `(R₂ := R)` because `I.toCotangent` suggested `R ⧸ I^2` instead
    I.cotangentEquivIdeal.symm ⟨(I ^ 2).mkQ x, Submodule.mem_map_of_mem (R₂ := R) hx⟩ =
      I.toCotangent ⟨x, hx⟩ 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (x : R) (hx : x ∈ I)
Goal: I.cotangentEquivIdeal.symm ⟨(Submodule.mkQ (I ^ 2)) x, ⋯⟩ = I.toCotangent ⟨x, hx⟩
-- AlgHom.ker_kerSquareLift
theorem _root_.AlgHom.ker_kerSquareLift (f : A →ₐ[R] B) :
    RingHom.ker f.kerSquareLift.toRingHom = f.toRingHom.ker.cotangentIdeal 
Arguments: {R : Type u} [CommRing R] {A : Type u_1} {B : Type u_2} [CommRing A] [CommRing B] [Algebra R A] [Algebra R B] (f : A →ₐ[R] B)
Goal: RingHom.ker f.kerSquareLift.toRingHom = (RingHom.ker f.toRingHom).cotangentIdeal
-- Ideal.mapCotangent_toCotangent
@[simp]
lemma mapCotangent_toCotangent
    (I₁ : Ideal A) (I₂ : Ideal B) (f : A →ₐ[R] B) (h : I₁ ≤ I₂.comap f) (x : I₁) :
    Ideal.mapCotangent I₁ I₂ f h (Ideal.toCotangent I₁ x) = Ideal.toCotangent I₂ ⟨f x, h x.2⟩ 
Arguments: {R : Type u} [CommRing R] {A : Type u_1} {B : Type u_2} [CommRing A] [CommRing B] [Algebra R A] [Algebra R B] (I₁ : Ideal A) (I₂ : Ideal B) (f : A →ₐ[R] B) (h : I₁ ≤ Ideal.comap f I₂) (x : ↥I₁)
Goal: (I₁.mapCotangent I₂ f h) (I₁.toCotangent x) = I₂.toCotangent ⟨f ↑x, ⋯⟩
-- LocalRing.subsingleton_cotangentSpace_iff
lemma subsingleton_cotangentSpace_iff [IsNoetherianRing R] :
    Subsingleton (CotangentSpace R) ↔ IsField R 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R] [IsNoetherianRing R]
Goal: Subsingleton (LocalRing.CotangentSpace R) ↔ IsField R
-- LocalRing.CotangentSpace.map_eq_top_iff
lemma CotangentSpace.map_eq_top_iff [IsNoetherianRing R] {M : Submodule R (maximalIdeal R)} :
    M.map (maximalIdeal R).toCotangent = ⊤ ↔ M = ⊤ 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R] [IsNoetherianRing R] {M : Submodule R ↥(LocalRing.maximalIdeal R)}
Goal: Submodule.map (LocalRing.maximalIdeal R).toCotangent M = ⊤ ↔ M = ⊤
-- LocalRing.CotangentSpace.span_image_eq_top_iff
lemma CotangentSpace.span_image_eq_top_iff [IsNoetherianRing R] {s : Set (maximalIdeal R)} :
    Submodule.span (ResidueField R) ((maximalIdeal R).toCotangent '' s) = ⊤ ↔
      Submodule.span R s = ⊤ 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R] [IsNoetherianRing R] {s : Set ↥(LocalRing.maximalIdeal R)}
Goal: Submodule.span (LocalRing.ResidueField R) (⇑(LocalRing.maximalIdeal R).toCotangent '' s) = ⊤ ↔ Submodule.span R s = ⊤
-- LocalRing.finrank_cotangentSpace_eq_zero_iff
lemma finrank_cotangentSpace_eq_zero_iff [IsNoetherianRing R] :
    finrank (ResidueField R) (CotangentSpace R) = 0 ↔ IsField R 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R] [IsNoetherianRing R]
Goal: FiniteDimensional.finrank (LocalRing.ResidueField R) (LocalRing.CotangentSpace R) = 0 ↔ IsField R
-- LocalRing.finrank_cotangentSpace_eq_zero
lemma finrank_cotangentSpace_eq_zero (R) [Field R] :
    finrank (ResidueField R) (CotangentSpace R) = 0 
Arguments: (R : Type u_2) [Field R]
Goal: FiniteDimensional.finrank (LocalRing.ResidueField R) (LocalRing.CotangentSpace R) = 0
-- LocalRing.finrank_cotangentSpace_le_one_iff
theorem finrank_cotangentSpace_le_one_iff [IsNoetherianRing R] :
    finrank (ResidueField R) (CotangentSpace R) ≤ 1 ↔ (maximalIdeal R).IsPrincipal 
Arguments: {R : Type u_1} [CommRing R] [LocalRing R] [IsNoetherianRing R]
Goal: FiniteDimensional.finrank (LocalRing.ResidueField R) (LocalRing.CotangentSpace R) ≤ 1 ↔
  Submodule.IsPrincipal (LocalRing.maximalIdeal R)
-- SlimCheck.InjectiveFunction.List.applyId_cons
@[simp]
theorem List.applyId_cons [DecidableEq α] (xs : List (α × α)) (x y z : α) :
    List.applyId ((y, z)::xs) x = if y = x then z else List.applyId xs x 
Arguments: {α : Type u} [DecidableEq α] (xs : List (α × α)) (x y z : α)
Goal: SlimCheck.InjectiveFunction.List.applyId ((y, z) :: xs) x =
  if y = x then z else SlimCheck.InjectiveFunction.List.applyId xs x
-- SlimCheck.InjectiveFunction.List.applyId_zip_eq
theorem List.applyId_zip_eq [DecidableEq α] {xs ys : List α} (h₀ : List.Nodup xs)
    (h₁ : xs.length = ys.length) (x y : α) (i : ℕ) (h₂ : xs[i]? = some x) :
    List.applyId.{u} (xs.zip ys) x = y ↔ ys[i]? = some y 
Arguments: {α : Type u} [DecidableEq α] {xs ys : List α} (h₀ : xs.Nodup) (h₁ : xs.length = ys.length) (x y : α) (i : ℕ) (h₂ : xs[i]? = some x)
Goal: SlimCheck.InjectiveFunction.List.applyId (xs.zip ys) x = y ↔ ys[i]? = some y
-- SlimCheck.InjectiveFunction.applyId_mem_iff
theorem applyId_mem_iff [DecidableEq α] {xs ys : List α} (h₀ : List.Nodup xs) (h₁ : xs ~ ys)
    (x : α) : List.applyId.{u} (xs.zip ys) x ∈ ys ↔ x ∈ xs 
Arguments: {α : Type u} [DecidableEq α] {xs ys : List α} (h₀ : xs.Nodup) (h₁ : xs ~ ys) (x : α)
Goal: SlimCheck.InjectiveFunction.List.applyId (xs.zip ys) x ∈ ys ↔ x ∈ xs
-- SlimCheck.InjectiveFunction.List.applyId_eq_self
theorem List.applyId_eq_self [DecidableEq α] {xs ys : List α} (x : α) :
    x ∉ xs → List.applyId.{u} (xs.zip ys) x = x 
Arguments: {α : Type u} [DecidableEq α] {xs ys : List α} (x : α)
Goal: x ∉ xs → SlimCheck.InjectiveFunction.List.applyId (xs.zip ys) x = x
-- SlimCheck.InjectiveFunction.applyId_injective
theorem applyId_injective [DecidableEq α] {xs ys : List α} (h₀ : List.Nodup xs) (h₁ : xs ~ ys) :
    Injective.{u + 1, u + 1} (List.applyId (xs.zip ys)) 
Arguments: {α : Type u} [DecidableEq α] {xs ys : List α} (h₀ : xs.Nodup) (h₁ : xs ~ ys)
Goal: Function.Injective (SlimCheck.InjectiveFunction.List.applyId (xs.zip ys))
-- SlimCheck.InjectiveFunction.injective
protected theorem injective [DecidableEq α] (f : InjectiveFunction α) : Injective (apply f) 
Arguments: {α : Type u} [DecidableEq α] (f : SlimCheck.InjectiveFunction α)
Goal: Function.Injective f.apply
-- cross_apply
theorem cross_apply (a b : Fin 3 → R) :
    a ×₃ b = ![a 1 * b 2 - a 2 * b 1, a 2 * b 0 - a 0 * b 2, a 0 * b 1 - a 1 * b 0] 
Arguments: {R : Type u_1} [CommRing R] (a b : Fin 3 → R)
Goal: (crossProduct a) b = ![a 1 * b 2 - a 2 * b 1, a 2 * b 0 - a 0 * b 2, a 0 * b 1 - a 1 * b 0]
-- cross_anticomm
@[simp]
theorem cross_anticomm (v w : Fin 3 → R) : -(v ×₃ w) = w ×₃ v 
Arguments: {R : Type u_1} [CommRing R] (v w : Fin 3 → R)
Goal: -(crossProduct v) w = (crossProduct w) v
-- cross_anticomm'
@[simp]
theorem cross_anticomm' (v w : Fin 3 → R) : v ×₃ w + w ×₃ v = 0 
Arguments: {R : Type u_1} [CommRing R] (v w : Fin 3 → R)
Goal: (crossProduct v) w + (crossProduct w) v = 0
-- cross_self
@[simp]
theorem cross_self (v : Fin 3 → R) : v ×₃ v = 0 
Arguments: {R : Type u_1} [CommRing R] (v : Fin 3 → R)
Goal: (crossProduct v) v = 0
-- dot_self_cross
@[simp 1100] -- Porting note: increase priority so that the LHS doesn't simplify
theorem dot_self_cross (v w : Fin 3 → R) : v ⬝ᵥ v ×₃ w = 0 
Arguments: {R : Type u_1} [CommRing R] (v w : Fin 3 → R)
Goal: v ⬝ᵥ (crossProduct v) w = 0
-- dot_cross_self
@[simp 1100] -- Porting note: increase priority so that the LHS doesn't simplify
theorem dot_cross_self (v w : Fin 3 → R) : w ⬝ᵥ v ×₃ w = 0 
Arguments: {R : Type u_1} [CommRing R] (v w : Fin 3 → R)
Goal: w ⬝ᵥ (crossProduct v) w = 0
-- triple_product_permutation
theorem triple_product_permutation (u v w : Fin 3 → R) : u ⬝ᵥ v ×₃ w = v ⬝ᵥ w ×₃ u 
Arguments: {R : Type u_1} [CommRing R] (u v w : Fin 3 → R)
Goal: u ⬝ᵥ (crossProduct v) w = v ⬝ᵥ (crossProduct w) u
-- triple_product_eq_det
theorem triple_product_eq_det (u v w : Fin 3 → R) : u ⬝ᵥ v ×₃ w = Matrix.det ![u, v, w] 
Arguments: {R : Type u_1} [CommRing R] (u v w : Fin 3 → R)
Goal: u ⬝ᵥ (crossProduct v) w = Matrix.det ![u, v, w]
-- cross_dot_cross
theorem cross_dot_cross (u v w x : Fin 3 → R) :
    u ×₃ v ⬝ᵥ w ×₃ x = u ⬝ᵥ w * v ⬝ᵥ x - u ⬝ᵥ x * v ⬝ᵥ w 
Arguments: {R : Type u_1} [CommRing R] (u v w x : Fin 3 → R)
Goal: (crossProduct u) v ⬝ᵥ (crossProduct w) x = u ⬝ᵥ w * v ⬝ᵥ x - u ⬝ᵥ x * v ⬝ᵥ w
-- leibniz_cross
theorem leibniz_cross (u v w : Fin 3 → R) : u ×₃ (v ×₃ w) = u ×₃ v ×₃ w + v ×₃ (u ×₃ w) 
Arguments: {R : Type u_1} [CommRing R] (u v w : Fin 3 → R)
Goal: (crossProduct u) ((crossProduct v) w) = (crossProduct ((crossProduct u) v)) w + (crossProduct v) ((crossProduct u) w)
-- cross_cross
theorem cross_cross (u v w : Fin 3 → R) : u ×₃ v ×₃ w = u ×₃ (v ×₃ w) - v ×₃ (u ×₃ w) 
Arguments: {R : Type u_1} [CommRing R] (u v w : Fin 3 → R)
Goal: (crossProduct ((crossProduct u) v)) w = (crossProduct u) ((crossProduct v) w) - (crossProduct v) ((crossProduct u) w)
-- jacobi_cross
theorem jacobi_cross (u v w : Fin 3 → R) : u ×₃ (v ×₃ w) + v ×₃ (w ×₃ u) + w ×₃ (u ×₃ v) = 0 
Arguments: {R : Type u_1} [CommRing R] (u v w : Fin 3 → R)
Goal: (crossProduct u) ((crossProduct v) w) + (crossProduct v) ((crossProduct w) u) + (crossProduct w) ((crossProduct u) v) =
  0