ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- PrimeSpectrum.zeroLocus_radical
@[simp]
theorem zeroLocus_radical (I : Ideal R) : zeroLocus (I.radical : Set R) = zeroLocus I 
Arguments: {R : Type u} [CommSemiring R] (I : Ideal R)
Goal: PrimeSpectrum.zeroLocus ↑I.radical = PrimeSpectrum.zeroLocus ↑I
-- PrimeSpectrum.subset_zeroLocus_vanishingIdeal
theorem subset_zeroLocus_vanishingIdeal (t : Set (PrimeSpectrum R)) :
    t ⊆ zeroLocus (vanishingIdeal t) 
Arguments: {R : Type u} [CommSemiring R] (t : Set (PrimeSpectrum R))
Goal: t ⊆ PrimeSpectrum.zeroLocus ↑(PrimeSpectrum.vanishingIdeal t)
-- PrimeSpectrum.zeroLocus_anti_mono
theorem zeroLocus_anti_mono {s t : Set R} (h : s ⊆ t) : zeroLocus t ⊆ zeroLocus s 
Arguments: {R : Type u} [CommSemiring R] {s t : Set R} (h : s ⊆ t)
Goal: PrimeSpectrum.zeroLocus t ⊆ PrimeSpectrum.zeroLocus s
-- PrimeSpectrum.zeroLocus_anti_mono_ideal
theorem zeroLocus_anti_mono_ideal {s t : Ideal R} (h : s ≤ t) :
    zeroLocus (t : Set R) ⊆ zeroLocus (s : Set R) 
Arguments: {R : Type u} [CommSemiring R] {s t : Ideal R} (h : s ≤ t)
Goal: PrimeSpectrum.zeroLocus ↑t ⊆ PrimeSpectrum.zeroLocus ↑s
-- PrimeSpectrum.vanishingIdeal_anti_mono
theorem vanishingIdeal_anti_mono {s t : Set (PrimeSpectrum R)} (h : s ⊆ t) :
    vanishingIdeal t ≤ vanishingIdeal s 
Arguments: {R : Type u} [CommSemiring R] {s t : Set (PrimeSpectrum R)} (h : s ⊆ t)
Goal: PrimeSpectrum.vanishingIdeal t ≤ PrimeSpectrum.vanishingIdeal s
-- PrimeSpectrum.zeroLocus_subset_zeroLocus_iff
theorem zeroLocus_subset_zeroLocus_iff (I J : Ideal R) :
    zeroLocus (I : Set R) ⊆ zeroLocus (J : Set R) ↔ J ≤ I.radical 
Arguments: {R : Type u} [CommSemiring R] (I J : Ideal R)
Goal: PrimeSpectrum.zeroLocus ↑I ⊆ PrimeSpectrum.zeroLocus ↑J ↔ J ≤ I.radical
-- PrimeSpectrum.zeroLocus_subset_zeroLocus_singleton_iff
theorem zeroLocus_subset_zeroLocus_singleton_iff (f g : R) :
    zeroLocus ({f} : Set R) ⊆ zeroLocus {g} ↔ g ∈ (Ideal.span ({f} : Set R)).radical 
Arguments: {R : Type u} [CommSemiring R] (f g : R)
Goal: PrimeSpectrum.zeroLocus {f} ⊆ PrimeSpectrum.zeroLocus {g} ↔ g ∈ (Ideal.span {f}).radical
-- PrimeSpectrum.zeroLocus_bot
theorem zeroLocus_bot : zeroLocus ((⊥ : Ideal R) : Set R) = Set.univ 
Arguments: {R : Type u} [CommSemiring R]
Goal: PrimeSpectrum.zeroLocus ↑⊥ = Set.univ
-- PrimeSpectrum.zeroLocus_singleton_zero
@[simp]
theorem zeroLocus_singleton_zero : zeroLocus ({0} : Set R) = Set.univ 
Arguments: {R : Type u} [CommSemiring R]
Goal: PrimeSpectrum.zeroLocus {0} = Set.univ
-- PrimeSpectrum.zeroLocus_empty
@[simp]
theorem zeroLocus_empty : zeroLocus (∅ : Set R) = Set.univ 
Arguments: {R : Type u} [CommSemiring R]
Goal: PrimeSpectrum.zeroLocus ∅ = Set.univ
-- PrimeSpectrum.vanishingIdeal_empty
@[simp]
theorem vanishingIdeal_empty : vanishingIdeal (∅ : Set (PrimeSpectrum R)) = ⊤ 
Arguments: {R : Type u} [CommSemiring R]
Goal: PrimeSpectrum.vanishingIdeal ∅ = ⊤
-- PrimeSpectrum.zeroLocus_empty_of_one_mem
theorem zeroLocus_empty_of_one_mem {s : Set R} (h : (1 : R) ∈ s) : zeroLocus s = ∅ 
Arguments: {R : Type u} [CommSemiring R] {s : Set R} (h : 1 ∈ s)
Goal: PrimeSpectrum.zeroLocus s = ∅
-- PrimeSpectrum.zeroLocus_singleton_one
@[simp]
theorem zeroLocus_singleton_one : zeroLocus ({1} : Set R) = ∅ 
Arguments: {R : Type u} [CommSemiring R]
Goal: PrimeSpectrum.zeroLocus {1} = ∅
-- PrimeSpectrum.zeroLocus_empty_iff_eq_top
theorem zeroLocus_empty_iff_eq_top {I : Ideal R} : zeroLocus (I : Set R) = ∅ ↔ I = ⊤ 
Arguments: {R : Type u} [CommSemiring R] {I : Ideal R}
Goal: PrimeSpectrum.zeroLocus ↑I = ∅ ↔ I = ⊤
-- PrimeSpectrum.zeroLocus_univ
@[simp]
theorem zeroLocus_univ : zeroLocus (Set.univ : Set R) = ∅ 
Arguments: {R : Type u} [CommSemiring R]
Goal: PrimeSpectrum.zeroLocus Set.univ = ∅
-- PrimeSpectrum.vanishingIdeal_eq_top_iff
theorem vanishingIdeal_eq_top_iff {s : Set (PrimeSpectrum R)} : vanishingIdeal s = ⊤ ↔ s = ∅ 
Arguments: {R : Type u} [CommSemiring R] {s : Set (PrimeSpectrum R)}
Goal: PrimeSpectrum.vanishingIdeal s = ⊤ ↔ s = ∅
-- PrimeSpectrum.zeroLocus_eq_top_iff
theorem zeroLocus_eq_top_iff (s : Set R) :
    zeroLocus s = ⊤ ↔ s ⊆ nilradical R 
Arguments: {R : Type u} [CommSemiring R] (s : Set R)
Goal: PrimeSpectrum.zeroLocus s = ⊤ ↔ s ⊆ ↑(nilradical R)
-- PrimeSpectrum.zeroLocus_sup
theorem zeroLocus_sup (I J : Ideal R) :
    zeroLocus ((I ⊔ J : Ideal R) : Set R) = zeroLocus I ∩ zeroLocus J 
Arguments: {R : Type u} [CommSemiring R] (I J : Ideal R)
Goal: PrimeSpectrum.zeroLocus ↑(I ⊔ J) = PrimeSpectrum.zeroLocus ↑I ∩ PrimeSpectrum.zeroLocus ↑J
-- PrimeSpectrum.zeroLocus_union
theorem zeroLocus_union (s s' : Set R) : zeroLocus (s ∪ s') = zeroLocus s ∩ zeroLocus s' 
Arguments: {R : Type u} [CommSemiring R] (s s' : Set R)
Goal: PrimeSpectrum.zeroLocus (s ∪ s') = PrimeSpectrum.zeroLocus s ∩ PrimeSpectrum.zeroLocus s'
-- PrimeSpectrum.vanishingIdeal_union
theorem vanishingIdeal_union (t t' : Set (PrimeSpectrum R)) :
    vanishingIdeal (t ∪ t') = vanishingIdeal t ⊓ vanishingIdeal t' 
Arguments: {R : Type u} [CommSemiring R] (t t' : Set (PrimeSpectrum R))
Goal: PrimeSpectrum.vanishingIdeal (t ∪ t') = PrimeSpectrum.vanishingIdeal t ⊓ PrimeSpectrum.vanishingIdeal t'
-- PrimeSpectrum.zeroLocus_iSup
theorem zeroLocus_iSup {ι : Sort*} (I : ι → Ideal R) :
    zeroLocus ((⨆ i, I i : Ideal R) : Set R) = ⋂ i, zeroLocus (I i) 
Arguments: {R : Type u} [CommSemiring R] {ι : Sort u_1} (I : ι → Ideal R)
Goal: PrimeSpectrum.zeroLocus ↑(⨆ i, I i) = ⋂ i, PrimeSpectrum.zeroLocus ↑(I i)
-- PrimeSpectrum.zeroLocus_iUnion
theorem zeroLocus_iUnion {ι : Sort*} (s : ι → Set R) :
    zeroLocus (⋃ i, s i) = ⋂ i, zeroLocus (s i) 
Arguments: {R : Type u} [CommSemiring R] {ι : Sort u_1} (s : ι → Set R)
Goal: PrimeSpectrum.zeroLocus (⋃ i, s i) = ⋂ i, PrimeSpectrum.zeroLocus (s i)
-- PrimeSpectrum.zeroLocus_iUnion₂
theorem zeroLocus_iUnion₂ {ι : Sort*} {κ : (i : ι) → Sort*} (s : ∀ i, κ i → Set R) :
    zeroLocus (⋃ (i) (j), s i j) = ⋂ (i) (j), zeroLocus (s i j) 
Arguments: {R : Type u} [CommSemiring R] {ι : Sort u_1} {κ : ι → Sort u_2} (s : (i : ι) → κ i → Set R)
Goal: PrimeSpectrum.zeroLocus (⋃ i, ⋃ j, s i j) = ⋂ i, ⋂ j, PrimeSpectrum.zeroLocus (s i j)
-- PrimeSpectrum.zeroLocus_bUnion
theorem zeroLocus_bUnion (s : Set (Set R)) :
    zeroLocus (⋃ s' ∈ s, s' : Set R) = ⋂ s' ∈ s, zeroLocus s' 
Arguments: {R : Type u} [CommSemiring R] (s : Set (Set R))
Goal: PrimeSpectrum.zeroLocus (⋃ s' ∈ s, s') = ⋂ s' ∈ s, PrimeSpectrum.zeroLocus s'
-- PrimeSpectrum.vanishingIdeal_iUnion
theorem vanishingIdeal_iUnion {ι : Sort*} (t : ι → Set (PrimeSpectrum R)) :
    vanishingIdeal (⋃ i, t i) = ⨅ i, vanishingIdeal (t i) 
Arguments: {R : Type u} [CommSemiring R] {ι : Sort u_1} (t : ι → Set (PrimeSpectrum R))
Goal: PrimeSpectrum.vanishingIdeal (⋃ i, t i) = ⨅ i, PrimeSpectrum.vanishingIdeal (t i)
-- PrimeSpectrum.zeroLocus_inf
theorem zeroLocus_inf (I J : Ideal R) :
    zeroLocus ((I ⊓ J : Ideal R) : Set R) = zeroLocus I ∪ zeroLocus J 
Arguments: {R : Type u} [CommSemiring R] (I J : Ideal R)
Goal: PrimeSpectrum.zeroLocus ↑(I ⊓ J) = PrimeSpectrum.zeroLocus ↑I ∪ PrimeSpectrum.zeroLocus ↑J
-- PrimeSpectrum.union_zeroLocus
theorem union_zeroLocus (s s' : Set R) :
    zeroLocus s ∪ zeroLocus s' = zeroLocus (Ideal.span s ⊓ Ideal.span s' : Ideal R) 
Arguments: {R : Type u} [CommSemiring R] (s s' : Set R)
Goal: PrimeSpectrum.zeroLocus s ∪ PrimeSpectrum.zeroLocus s' = PrimeSpectrum.zeroLocus ↑(Ideal.span s ⊓ Ideal.span s')
-- PrimeSpectrum.zeroLocus_mul
theorem zeroLocus_mul (I J : Ideal R) :
    zeroLocus ((I * J : Ideal R) : Set R) = zeroLocus I ∪ zeroLocus J 
Arguments: {R : Type u} [CommSemiring R] (I J : Ideal R)
Goal: PrimeSpectrum.zeroLocus ↑(I * J) = PrimeSpectrum.zeroLocus ↑I ∪ PrimeSpectrum.zeroLocus ↑J
-- PrimeSpectrum.zeroLocus_singleton_mul
theorem zeroLocus_singleton_mul (f g : R) :
    zeroLocus ({f * g} : Set R) = zeroLocus {f} ∪ zeroLocus {g} 
Arguments: {R : Type u} [CommSemiring R] (f g : R)
Goal: PrimeSpectrum.zeroLocus {f * g} = PrimeSpectrum.zeroLocus {f} ∪ PrimeSpectrum.zeroLocus {g}
-- PrimeSpectrum.zeroLocus_pow
@[simp]
theorem zeroLocus_pow (I : Ideal R) {n : ℕ} (hn : n ≠ 0) :
    zeroLocus ((I ^ n : Ideal R) : Set R) = zeroLocus I 
Arguments: {R : Type u} [CommSemiring R] (I : Ideal R) {n : ℕ} (hn : n ≠ 0)
Goal: PrimeSpectrum.zeroLocus ↑(I ^ n) = PrimeSpectrum.zeroLocus ↑I
-- PrimeSpectrum.zeroLocus_singleton_pow
@[simp]
theorem zeroLocus_singleton_pow (f : R) (n : ℕ) (hn : 0 < n) :
    zeroLocus ({f ^ n} : Set R) = zeroLocus {f} 
Arguments: {R : Type u} [CommSemiring R] (f : R) (n : ℕ) (hn : 0 < n)
Goal: PrimeSpectrum.zeroLocus {f ^ n} = PrimeSpectrum.zeroLocus {f}
-- PrimeSpectrum.sup_vanishingIdeal_le
theorem sup_vanishingIdeal_le (t t' : Set (PrimeSpectrum R)) :
    vanishingIdeal t ⊔ vanishingIdeal t' ≤ vanishingIdeal (t ∩ t') 
Arguments: {R : Type u} [CommSemiring R] (t t' : Set (PrimeSpectrum R))
Goal: PrimeSpectrum.vanishingIdeal t ⊔ PrimeSpectrum.vanishingIdeal t' ≤ PrimeSpectrum.vanishingIdeal (t ∩ t')
-- PrimeSpectrum.mem_compl_zeroLocus_iff_not_mem
theorem mem_compl_zeroLocus_iff_not_mem {f : R} {I : PrimeSpectrum R} :
    I ∈ (zeroLocus {f} : Set (PrimeSpectrum R))ᶜ ↔ f ∉ I.asIdeal 
Arguments: {R : Type u} [CommSemiring R] {f : R} {I : PrimeSpectrum R}
Goal: I ∈ (PrimeSpectrum.zeroLocus {f})ᶜ ↔ f ∉ I.asIdeal
-- PrimeSpectrum.asIdeal_le_asIdeal
@[simp]
theorem asIdeal_le_asIdeal (x y : PrimeSpectrum R) : x.asIdeal ≤ y.asIdeal ↔ x ≤ y 
Arguments: {R : Type u} [CommSemiring R] (x y : PrimeSpectrum R)
Goal: x.asIdeal ≤ y.asIdeal ↔ x ≤ y
-- PrimeSpectrum.asIdeal_lt_asIdeal
@[simp]
theorem asIdeal_lt_asIdeal (x y : PrimeSpectrum R) : x.asIdeal < y.asIdeal ↔ x < y 
Arguments: {R : Type u} [CommSemiring R] (x y : PrimeSpectrum R)
Goal: x.asIdeal < y.asIdeal ↔ x < y
-- PrimeSpectrum.exists_primeSpectrum_prod_le
theorem exists_primeSpectrum_prod_le (I : Ideal R) :
    ∃ Z : Multiset (PrimeSpectrum R), Multiset.prod (Z.map asIdeal) ≤ I 
Arguments: (R : Type u) [CommRing R] [IsNoetherianRing R] (I : Ideal R)
Goal: ∃ Z, (Multiset.map PrimeSpectrum.asIdeal Z).prod ≤ I
-- PrimeSpectrum.exists_primeSpectrum_prod_le_and_ne_bot_of_domain
theorem exists_primeSpectrum_prod_le_and_ne_bot_of_domain (h_fA : ¬IsField A) {I : Ideal A}
    (h_nzI : I ≠ ⊥) :
    ∃ Z : Multiset (PrimeSpectrum A),
      Multiset.prod (Z.map asIdeal) ≤ I ∧ Multiset.prod (Z.map asIdeal) ≠ ⊥ 
Arguments: {A : Type u} [CommRing A] [IsDomain A] [IsNoetherianRing A] (h_fA : ¬IsField A) {I : Ideal A} (h_nzI : I ≠ ⊥)
Goal: ∃ Z, (Multiset.map PrimeSpectrum.asIdeal Z).prod ≤ I ∧ (Multiset.map PrimeSpectrum.asIdeal Z).prod ≠ ⊥
-- RingCon.op_iff
lemma op_iff {c : RingCon R} {x y : Rᵐᵒᵖ} : c.op x y ↔ c y.unop x.unop 
Arguments: {R : Type u_1} [Add R] [Mul R] {c : RingCon R} {x y : Rᵐᵒᵖ}
Goal: c.op x y ↔ c (MulOpposite.unop y) (MulOpposite.unop x)
-- RingCon.unop_iff
lemma unop_iff {c : RingCon Rᵐᵒᵖ} {x y : R} : c.unop x y ↔ c (.op y) (.op x) 
Arguments: {R : Type u_1} [Add R] [Mul R] {c : RingCon Rᵐᵒᵖ} {x y : R}
Goal: c.unop x y ↔ c (MulOpposite.op y) (MulOpposite.op x)
-- RingCon.opOrderIso_symm_apply
@[simps]
def opOrderIso : RingCon R ≃o RingCon Rᵐᵒᵖ 
Arguments: {R : Type u_1} [Add R] [Mul R] (c : RingCon Rᵐᵒᵖ)
Goal: (RelIso.symm RingCon.opOrderIso) c = c.unop
-- RingCon.opOrderIso_apply
@[simps]
def opOrderIso : RingCon R ≃o RingCon Rᵐᵒᵖ 
Arguments: {R : Type u_1} [Add R] [Mul R] (c : RingCon R)
Goal: RingCon.opOrderIso c = c.op
-- PolyEquivTensor.toFunBilinear_apply_apply
-- Porting note: was  `@[simps apply_apply]`
@[simps! apply_apply]
def toFunBilinear : A →ₗ[A] R[X] →ₗ[R] A[X] 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (b : A) (a : R[X])
Goal: ((PolyEquivTensor.toFunBilinear R A) b) a = b • (Polynomial.aeval Polynomial.X) a
-- PolyEquivTensor.toFunBilinear_apply_eq_sum
theorem toFunBilinear_apply_eq_sum (a : A) (p : R[X]) :
    toFunBilinear R A a p = p.sum fun n r => monomial n (a * algebraMap R A r) 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (a : A) (p : R[X])
Goal: ((PolyEquivTensor.toFunBilinear R A) a) p = p.sum fun n r => (Polynomial.monomial n) (a * (algebraMap R A) r)
-- PolyEquivTensor.toFunLinear_tmul_apply
@[simp]
theorem toFunLinear_tmul_apply (a : A) (p : R[X]) :
    toFunLinear R A (a ⊗ₜ[R] p) = toFunBilinear R A a p 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (a : A) (p : R[X])
Goal: (PolyEquivTensor.toFunLinear R A) (a ⊗ₜ[R] p) = ((PolyEquivTensor.toFunBilinear R A) a) p
-- PolyEquivTensor.toFunLinear_mul_tmul_mul_aux_1
theorem toFunLinear_mul_tmul_mul_aux_1 (p : R[X]) (k : ℕ) (h : Decidable ¬p.coeff k = 0) (a : A) :
    ite (¬coeff p k = 0) (a * (algebraMap R A) (coeff p k)) 0 =
    a * (algebraMap R A) (coeff p k) 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (p : R[X]) (k : ℕ) (h : Decidable ¬p.coeff k = 0) (a : A)
Goal: (if ¬p.coeff k = 0 then a * (algebraMap R A) (p.coeff k) else 0) = a * (algebraMap R A) (p.coeff k)
-- PolyEquivTensor.toFunLinear_mul_tmul_mul_aux_2
theorem toFunLinear_mul_tmul_mul_aux_2 (k : ℕ) (a₁ a₂ : A) (p₁ p₂ : R[X]) :
    a₁ * a₂ * (algebraMap R A) ((p₁ * p₂).coeff k) =
      (Finset.antidiagonal k).sum fun x =>
        a₁ * (algebraMap R A) (coeff p₁ x.1) * (a₂ * (algebraMap R A) (coeff p₂ x.2)) 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (k : ℕ) (a₁ a₂ : A) (p₁ p₂ : R[X])
Goal: a₁ * a₂ * (algebraMap R A) ((p₁ * p₂).coeff k) =
  ∑ x ∈ Finset.antidiagonal k, a₁ * (algebraMap R A) (p₁.coeff x.1) * (a₂ * (algebraMap R A) (p₂.coeff x.2))
-- PolyEquivTensor.toFunLinear_mul_tmul_mul
theorem toFunLinear_mul_tmul_mul (a₁ a₂ : A) (p₁ p₂ : R[X]) :
    (toFunLinear R A) ((a₁ * a₂) ⊗ₜ[R] (p₁ * p₂)) =
      (toFunLinear R A) (a₁ ⊗ₜ[R] p₁) * (toFunLinear R A) (a₂ ⊗ₜ[R] p₂) 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (a₁ a₂ : A) (p₁ p₂ : R[X])
Goal: (PolyEquivTensor.toFunLinear R A) ((a₁ * a₂) ⊗ₜ[R] (p₁ * p₂)) =
  (PolyEquivTensor.toFunLinear R A) (a₁ ⊗ₜ[R] p₁) * (PolyEquivTensor.toFunLinear R A) (a₂ ⊗ₜ[R] p₂)
-- PolyEquivTensor.toFunLinear_one_tmul_one
theorem toFunLinear_one_tmul_one :
    toFunLinear R A (1 ⊗ₜ[R] 1) = 1 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A]
Goal: (PolyEquivTensor.toFunLinear R A) (1 ⊗ₜ[R] 1) = 1
-- PolyEquivTensor.toFunAlgHom_apply_tmul
@[simp]
theorem toFunAlgHom_apply_tmul (a : A) (p : R[X]) :
    toFunAlgHom R A (a ⊗ₜ[R] p) = p.sum fun n r => monomial n (a * (algebraMap R A) r) 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (a : A) (p : R[X])
Goal: (PolyEquivTensor.toFunAlgHom R A) (a ⊗ₜ[R] p) = p.sum fun n r => (Polynomial.monomial n) (a * (algebraMap R A) r)
-- PolyEquivTensor.invFun_add
@[simp]
theorem invFun_add {p q} : invFun R A (p + q) = invFun R A p + invFun R A q 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] {p q : A[X]}
Goal: PolyEquivTensor.invFun R A (p + q) = PolyEquivTensor.invFun R A p + PolyEquivTensor.invFun R A q
-- PolyEquivTensor.invFun_monomial
theorem invFun_monomial (n : ℕ) (a : A) :
    invFun R A (monomial n a) = (a ⊗ₜ[R] 1) * 1 ⊗ₜ[R] X ^ n 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (n : ℕ) (a : A)
Goal: PolyEquivTensor.invFun R A ((Polynomial.monomial n) a) = a ⊗ₜ[R] 1 * 1 ⊗ₜ[R] Polynomial.X ^ n
-- PolyEquivTensor.left_inv
theorem left_inv (x : A ⊗ R[X]) : invFun R A ((toFunAlgHom R A) x) = x 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (x : A ⊗[R] R[X])
Goal: PolyEquivTensor.invFun R A ((PolyEquivTensor.toFunAlgHom R A) x) = x
-- PolyEquivTensor.right_inv
theorem right_inv (x : A[X]) : (toFunAlgHom R A) (invFun R A x) = x 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (x : A[X])
Goal: (PolyEquivTensor.toFunAlgHom R A) (PolyEquivTensor.invFun R A x) = x
-- polyEquivTensor_apply
@[simp]
theorem polyEquivTensor_apply (p : A[X]) :
    polyEquivTensor R A p =
      p.eval₂ (includeLeft : A →ₐ[R] A ⊗[R] R[X]) ((1 : A) ⊗ₜ[R] (X : R[X])) 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (p : A[X])
Goal: (polyEquivTensor R A) p = Polynomial.eval₂ (↑Algebra.TensorProduct.includeLeft) (1 ⊗ₜ[R] Polynomial.X) p
-- polyEquivTensor_symm_apply_tmul
@[simp]
theorem polyEquivTensor_symm_apply_tmul (a : A) (p : R[X]) :
    (polyEquivTensor R A).symm (a ⊗ₜ p) = p.sum fun n r => monomial n (a * algebraMap R A r) 
Arguments: (R : Type u_1) (A : Type u_2) [CommSemiring R] [Semiring A] [Algebra R A] (a : A) (p : R[X])
Goal: (polyEquivTensor R A).symm (a ⊗ₜ[R] p) = p.sum fun n r => (Polynomial.monomial n) (a * (algebraMap R A) r)
-- matPolyEquiv_symm_C
@[simp] theorem matPolyEquiv_symm_C (M : Matrix n n R) : matPolyEquiv.symm (C M) = M.map C 
Arguments: {R : Type u_1} [CommSemiring R] {n : Type w} [DecidableEq n] [Fintype n] (M : Matrix n n R)
Goal: matPolyEquiv.symm (Polynomial.C M) = M.map ⇑Polynomial.C
-- matPolyEquiv_map_C
@[simp] theorem matPolyEquiv_map_C (M : Matrix n n R) : matPolyEquiv (M.map C) = C M 
Arguments: {R : Type u_1} [CommSemiring R] {n : Type w} [DecidableEq n] [Fintype n] (M : Matrix n n R)
Goal: matPolyEquiv (M.map ⇑Polynomial.C) = Polynomial.C M
-- matPolyEquiv_symm_X
@[simp] theorem matPolyEquiv_symm_X :
    matPolyEquiv.symm X = diagonal fun _ : n => (X : R[X]) 
Arguments: {R : Type u_1} [CommSemiring R] {n : Type w} [DecidableEq n] [Fintype n]
Goal: matPolyEquiv.symm Polynomial.X = Matrix.diagonal fun x => Polynomial.X
-- matPolyEquiv_diagonal_X
@[simp] theorem matPolyEquiv_diagonal_X :
    matPolyEquiv (diagonal fun _ : n => (X : R[X])) = X 
Arguments: {R : Type u_1} [CommSemiring R] {n : Type w} [DecidableEq n] [Fintype n]
Goal: matPolyEquiv (Matrix.diagonal fun x => Polynomial.X) = Polynomial.X
-- matPolyEquiv_coeff_apply_aux_1
theorem matPolyEquiv_coeff_apply_aux_1 (i j : n) (k : ℕ) (x : R) :
    matPolyEquiv (stdBasisMatrix i j <| monomial k x) = monomial k (stdBasisMatrix i j x) 
Arguments: {R : Type u_1} [CommSemiring R] {n : Type w} [DecidableEq n] [Fintype n] (i j : n) (k : ℕ) (x : R)
Goal: matPolyEquiv (Matrix.stdBasisMatrix i j ((Polynomial.monomial k) x)) =
  (Polynomial.monomial k) (Matrix.stdBasisMatrix i j x)
-- matPolyEquiv_coeff_apply_aux_2
theorem matPolyEquiv_coeff_apply_aux_2 (i j : n) (p : R[X]) (k : ℕ) :
    coeff (matPolyEquiv (stdBasisMatrix i j p)) k = stdBasisMatrix i j (coeff p k) 
Arguments: {R : Type u_1} [CommSemiring R] {n : Type w} [DecidableEq n] [Fintype n] (i j : n) (p : R[X]) (k : ℕ)
Goal: (matPolyEquiv (Matrix.stdBasisMatrix i j p)).coeff k = Matrix.stdBasisMatrix i j (p.coeff k)
-- matPolyEquiv_coeff_apply
@[simp]
theorem matPolyEquiv_coeff_apply (m : Matrix n n R[X]) (k : ℕ) (i j : n) :
    coeff (matPolyEquiv m) k i j = coeff (m i j) k 
Arguments: {R : Type u_1} [CommSemiring R] {n : Type w} [DecidableEq n] [Fintype n] (m : Matrix n n R[X]) (k : ℕ) (i j : n)
Goal: (matPolyEquiv m).coeff k i j = (m i j).coeff k
-- matPolyEquiv_symm_apply_coeff
@[simp]
theorem matPolyEquiv_symm_apply_coeff (p : (Matrix n n R)[X]) (i j : n) (k : ℕ) :
    coeff (matPolyEquiv.symm p i j) k = coeff p k i j 
Arguments: {R : Type u_1} [CommSemiring R] {n : Type w} [DecidableEq n] [Fintype n] (p : (Matrix n n R)[X]) (i j : n) (k : ℕ)
Goal: (matPolyEquiv.symm p i j).coeff k = p.coeff k i j
-- matPolyEquiv_smul_one
theorem matPolyEquiv_smul_one (p : R[X]) :
    matPolyEquiv (p • (1 : Matrix n n R[X])) = p.map (algebraMap R (Matrix n n R)) 
Arguments: {R : Type u_1} [CommSemiring R] {n : Type w} [DecidableEq n] [Fintype n] (p : R[X])
Goal: matPolyEquiv (p • 1) = Polynomial.map (algebraMap R (Matrix n n R)) p
-- matPolyEquiv_map_smul
@[simp]
lemma matPolyEquiv_map_smul (p : R[X]) (M : Matrix n n R[X]) :
    matPolyEquiv (p • M) = p.map (algebraMap _ _) * matPolyEquiv M 
Arguments: {R : Type u_1} [CommSemiring R] {n : Type w} [DecidableEq n] [Fintype n] (p : R[X]) (M : Matrix n n R[X])
Goal: matPolyEquiv (p • M) = Polynomial.map (algebraMap R (Matrix n n R)) p * matPolyEquiv M
-- support_subset_support_matPolyEquiv
theorem support_subset_support_matPolyEquiv (m : Matrix n n R[X]) (i j : n) :
    support (m i j) ⊆ support (matPolyEquiv m) 
Arguments: {R : Type u_1} [CommSemiring R] {n : Type w} [DecidableEq n] [Fintype n] (m : Matrix n n R[X]) (i j : n)
Goal: (m i j).support ⊆ (matPolyEquiv m).support
-- MaximalSpectrum.IsMaximal
@[ext]
structure MaximalSpectrum where
  asIdeal : Ideal R
  IsMaximal : asIdeal.IsMaximal
Arguments: {R : Type u} [CommRing R] (self : MaximalSpectrum R)
Goal: self.asIdeal.IsMaximal
-- MaximalSpectrum.toPrimeSpectrum_injective
theorem toPrimeSpectrum_injective : (@toPrimeSpectrum R _).Injective 
Arguments: {R : Type u} [CommRing R]
Goal: Function.Injective MaximalSpectrum.toPrimeSpectrum
-- MaximalSpectrum.iInf_localization_eq_bot
theorem iInf_localization_eq_bot : (⨅ v : MaximalSpectrum R,
    Localization.subalgebra.ofField K _ v.asIdeal.primeCompl_le_nonZeroDivisors) = ⊥ 
Arguments: (R : Type u) [CommRing R] [IsDomain R] (K : Type v) [Field K] [Algebra R K] [IsFractionRing R K]
Goal: ⨅ v, Localization.subalgebra.ofField K v.asIdeal.primeCompl ⋯ = ⊥
-- PrimeSpectrum.iInf_localization_eq_bot
theorem iInf_localization_eq_bot : ⨅ v : PrimeSpectrum R,
    Localization.subalgebra.ofField K _ (v.asIdeal.primeCompl_le_nonZeroDivisors) = ⊥ 
Arguments: (R : Type u) [CommRing R] [IsDomain R] (K : Type v) [Field K] [Algebra R K] [IsFractionRing R K]
Goal: ⨅ v, Localization.subalgebra.ofField K v.asIdeal.primeCompl ⋯ = ⊥
-- Finset.esymm_map_val
theorem _root_.Finset.esymm_map_val {σ} (f : σ → R) (s : Finset σ) (n : ℕ) :
    (s.val.map f).esymm n = (s.powersetCard n).sum fun t => t.prod f 
Arguments: {R : Type u_1} [CommSemiring R] {σ : Type u_2} (f : σ → R) (s : Finset σ) (n : ℕ)
Goal: (Multiset.map f s.val).esymm n = ∑ t ∈ Finset.powersetCard n s, t.prod f
-- MvPolynomial.mem_symmetricSubalgebra
@[simp]
theorem mem_symmetricSubalgebra [CommSemiring R] (p : MvPolynomial σ R) :
    p ∈ symmetricSubalgebra σ R ↔ p.IsSymmetric 
Arguments: {σ : Type u_1} {R : Type u_2} [CommSemiring R] (p : MvPolynomial σ R)
Goal: p ∈ MvPolynomial.symmetricSubalgebra σ R ↔ p.IsSymmetric
-- MvPolynomial.IsSymmetric.C
@[simp]
theorem C (r : R) : IsSymmetric (C r : MvPolynomial σ R) 
Arguments: {σ : Type u_1} {R : Type u_2} [CommSemiring R] (r : R)
Goal: (MvPolynomial.C r).IsSymmetric
-- MvPolynomial.IsSymmetric.zero
@[simp]
theorem zero : IsSymmetric (0 : MvPolynomial σ R) 
Arguments: {σ : Type u_1} {R : Type u_2} [CommSemiring R]
Goal: MvPolynomial.IsSymmetric 0
-- MvPolynomial.IsSymmetric.one
@[simp]
theorem one : IsSymmetric (1 : MvPolynomial σ R) 
Arguments: {σ : Type u_1} {R : Type u_2} [CommSemiring R]
Goal: MvPolynomial.IsSymmetric 1
-- MvPolynomial.IsSymmetric.add
theorem add (hφ : IsSymmetric φ) (hψ : IsSymmetric ψ) : IsSymmetric (φ + ψ) 
Arguments: {σ : Type u_1} {R : Type u_2} [CommSemiring R] {φ ψ : MvPolynomial σ R} (hφ : φ.IsSymmetric) (hψ : ψ.IsSymmetric)
Goal: (φ + ψ).IsSymmetric
-- MvPolynomial.IsSymmetric.mul
theorem mul (hφ : IsSymmetric φ) (hψ : IsSymmetric ψ) : IsSymmetric (φ * ψ) 
Arguments: {σ : Type u_1} {R : Type u_2} [CommSemiring R] {φ ψ : MvPolynomial σ R} (hφ : φ.IsSymmetric) (hψ : ψ.IsSymmetric)
Goal: (φ * ψ).IsSymmetric
-- MvPolynomial.IsSymmetric.smul
theorem smul (r : R) (hφ : IsSymmetric φ) : IsSymmetric (r • φ) 
Arguments: {σ : Type u_1} {R : Type u_2} [CommSemiring R] {φ : MvPolynomial σ R} (r : R) (hφ : φ.IsSymmetric)
Goal: (r • φ).IsSymmetric
-- MvPolynomial.IsSymmetric.map
@[simp]
theorem map (hφ : IsSymmetric φ) (f : R →+* S) : IsSymmetric (map f φ) 
Arguments: {σ : Type u_1} {R : Type u_2} {S : Type u_4} [CommSemiring R] [CommSemiring S] {φ : MvPolynomial σ R} (hφ : φ.IsSymmetric) (f : R →+* S)
Goal: ((MvPolynomial.map f) φ).IsSymmetric
-- MvPolynomial.IsSymmetric.rename
protected theorem rename (hφ : φ.IsSymmetric) (e : σ ≃ τ) : (rename e φ).IsSymmetric 
Arguments: {σ : Type u_1} {R : Type u_2} {τ : Type u_3} [CommSemiring R] {φ : MvPolynomial σ R} (hφ : φ.IsSymmetric) (e : σ ≃ τ)
Goal: ((MvPolynomial.rename ⇑e) φ).IsSymmetric
-- MvPolynomial.isSymmetric_rename
@[simp]
theorem _root_.MvPolynomial.isSymmetric_rename {e : σ ≃ τ} :
    (MvPolynomial.rename e φ).IsSymmetric ↔ φ.IsSymmetric 
Arguments: {σ : Type u_1} {R : Type u_2} {τ : Type u_3} [CommSemiring R] {φ : MvPolynomial σ R} {e : σ ≃ τ}
Goal: ((MvPolynomial.rename ⇑e) φ).IsSymmetric ↔ φ.IsSymmetric