ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Ring.multichoose_one_right'
@[simp]
theorem multichoose_one_right' (r : R) : multichoose r 1 = r ^ 1 
Arguments: {R : Type u_1} [AddCommMonoid R] [Pow R ℕ] [BinomialRing R] (r : R)
Goal: Ring.multichoose r 1 = r ^ 1
-- Ring.multichoose_one_right
theorem multichoose_one_right [MulOneClass R] [NatPowAssoc R] (r : R) : multichoose r 1 = r 
Arguments: {R : Type u_1} [AddCommMonoid R] [Pow R ℕ] [BinomialRing R] [MulOneClass R] [NatPowAssoc R] (r : R)
Goal: Ring.multichoose r 1 = r
-- Ring.multichoose_zero_succ
@[simp]
theorem multichoose_zero_succ (k : ℕ) : multichoose (0 : R) (k + 1) = 0 
Arguments: {R : Type u_2} [NonAssocSemiring R] [Pow R ℕ] [NatPowAssoc R] [BinomialRing R] (k : ℕ)
Goal: Ring.multichoose 0 (k + 1) = 0
-- Ring.ascPochhammer_succ_succ
theorem ascPochhammer_succ_succ (r : R) (k : ℕ) :
    smeval (ascPochhammer ℕ (k + 1)) (r + 1) = Nat.factorial (k + 1) • multichoose (r + 1) k +
    smeval (ascPochhammer ℕ (k + 1)) r 
Arguments: {R : Type u_2} [NonAssocSemiring R] [Pow R ℕ] [NatPowAssoc R] [BinomialRing R] (r : R) (k : ℕ)
Goal: (ascPochhammer ℕ (k + 1)).smeval (r + 1) =
  (k + 1).factorial • Ring.multichoose (r + 1) k + (ascPochhammer ℕ (k + 1)).smeval r
-- Ring.multichoose_succ_succ
theorem multichoose_succ_succ (r : R) (k : ℕ) :
    multichoose (r + 1) (k + 1) = multichoose r (k + 1) + multichoose (r + 1) k 
Arguments: {R : Type u_2} [NonAssocSemiring R] [Pow R ℕ] [NatPowAssoc R] [BinomialRing R] (r : R) (k : ℕ)
Goal: Ring.multichoose (r + 1) (k + 1) = Ring.multichoose r (k + 1) + Ring.multichoose (r + 1) k
-- Ring.multichoose_one
@[simp]
theorem multichoose_one (k : ℕ) : multichoose (1 : R) k = 1 
Arguments: {R : Type u_2} [NonAssocSemiring R] [Pow R ℕ] [NatPowAssoc R] [BinomialRing R] (k : ℕ)
Goal: Ring.multichoose 1 k = 1
-- Ring.multichoose_two
theorem multichoose_two (k : ℕ) : multichoose (2 : R) k = k + 1 
Arguments: {R : Type u_2} [NonAssocSemiring R] [Pow R ℕ] [NatPowAssoc R] [BinomialRing R] (k : ℕ)
Goal: Ring.multichoose 2 k = ↑k + 1
-- Polynomial.ascPochhammer_smeval_cast
@[simp]
theorem ascPochhammer_smeval_cast (R : Type*) [Semiring R] {S : Type*} [NonAssocSemiring S]
    [Pow S ℕ] [Module R S] [IsScalarTower R S S] [NatPowAssoc S]
    (x : S) (n : ℕ) : (ascPochhammer R n).smeval x = (ascPochhammer ℕ n).smeval x 
Arguments: (R : Type u_1) [Semiring R] {S : Type u_2} [NonAssocSemiring S] [Pow S ℕ] [Module R S] [IsScalarTower R S S] [NatPowAssoc S] (x : S) (n : ℕ)
Goal: (ascPochhammer R n).smeval x = (ascPochhammer ℕ n).smeval x
-- Polynomial.ascPochhammer_smeval_eq_eval
theorem ascPochhammer_smeval_eq_eval [Semiring R] (r : R) (n : ℕ) :
    (ascPochhammer ℕ n).smeval r = (ascPochhammer R n).eval r 
Arguments: {R : Type u_1} [Semiring R] (r : R) (n : ℕ)
Goal: (ascPochhammer ℕ n).smeval r = Polynomial.eval r (ascPochhammer R n)
-- Polynomial.descPochhammer_smeval_eq_ascPochhammer
theorem descPochhammer_smeval_eq_ascPochhammer (r : R) (n : ℕ) :
    (descPochhammer ℤ n).smeval r = (ascPochhammer ℕ n).smeval (r - n + 1) 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] (r : R) (n : ℕ)
Goal: (descPochhammer ℤ n).smeval r = (ascPochhammer ℕ n).smeval (r - ↑n + 1)
-- Polynomial.descPochhammer_smeval_eq_descFactorial
theorem descPochhammer_smeval_eq_descFactorial (n k : ℕ) :
    (descPochhammer ℤ k).smeval (n : R) = n.descFactorial k 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] (n k : ℕ)
Goal: (descPochhammer ℤ k).smeval ↑n = ↑(n.descFactorial k)
-- Polynomial.ascPochhammer_smeval_neg_eq_descPochhammer
theorem ascPochhammer_smeval_neg_eq_descPochhammer (r : R) (k : ℕ) :
    (ascPochhammer ℕ k).smeval (-r) = (-1)^k * (descPochhammer ℤ k).smeval r 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] (r : R) (k : ℕ)
Goal: (ascPochhammer ℕ k).smeval (-r) = (-1) ^ k * (descPochhammer ℤ k).smeval r
-- Ring.smeval_ascPochhammer_self_neg
@[simp]
theorem smeval_ascPochhammer_self_neg : ∀ n : ℕ,
    smeval (ascPochhammer ℕ n) (-n : ℤ) = (-1)^n * n.factorial
  
Arguments: (n : ℕ)
Goal: (ascPochhammer ℕ n).smeval (-↑n) = (-1) ^ n * ↑n.factorial
-- Ring.smeval_ascPochhammer_succ_neg
@[simp]
theorem smeval_ascPochhammer_succ_neg (n : ℕ) :
    smeval (ascPochhammer ℕ (n + 1)) (-n : ℤ) = 0 
Arguments: (n : ℕ)
Goal: (ascPochhammer ℕ (n + 1)).smeval (-↑n) = 0
-- Ring.smeval_ascPochhammer_neg_add
theorem smeval_ascPochhammer_neg_add (n : ℕ) : ∀ k : ℕ,
    smeval (ascPochhammer ℕ (n + k + 1)) (-n : ℤ) = 0
  
Arguments: (n k : ℕ)
Goal: (ascPochhammer ℕ (n + k + 1)).smeval (-↑n) = 0
-- Ring.smeval_ascPochhammer_neg_of_lt
@[simp]
theorem smeval_ascPochhammer_neg_of_lt {n k : ℕ} (h : n < k) :
    smeval (ascPochhammer ℕ k) (-n : ℤ) = 0 
Arguments: {n k : ℕ} (h : n < k)
Goal: (ascPochhammer ℕ k).smeval (-↑n) = 0
-- Ring.smeval_ascPochhammer_nat_cast
theorem smeval_ascPochhammer_nat_cast [NatPowAssoc R] (n k : ℕ) :
    smeval (ascPochhammer ℕ k) (n : R) = smeval (ascPochhammer ℕ k) n 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] (n k : ℕ)
Goal: (ascPochhammer ℕ k).smeval ↑n = ↑((ascPochhammer ℕ k).smeval n)
-- Ring.multichoose_neg_self
theorem multichoose_neg_self (n : ℕ) : multichoose (-n : ℤ) n = (-1)^n 
Arguments: (n : ℕ)
Goal: Ring.multichoose (-↑n) n = (-1) ^ n
-- Ring.multichoose_neg_succ
@[simp]
theorem multichoose_neg_succ (n : ℕ) : multichoose (-n : ℤ) (n + 1) = 0 
Arguments: (n : ℕ)
Goal: Ring.multichoose (-↑n) (n + 1) = 0
-- Ring.multichoose_neg_add
theorem multichoose_neg_add (n k : ℕ) : multichoose (-n : ℤ) (n + k + 1) = 0 
Arguments: (n k : ℕ)
Goal: Ring.multichoose (-↑n) (n + k + 1) = 0
-- Ring.multichoose_neg_of_lt
@[simp]
theorem multichoose_neg_of_lt (n k : ℕ) (h : n < k) : multichoose (-n : ℤ) k = 0 
Arguments: (n k : ℕ) (h : n < k)
Goal: Ring.multichoose (-↑n) k = 0
-- Ring.multichoose_succ_neg_natCast
theorem multichoose_succ_neg_natCast [NatPowAssoc R] (n : ℕ) :
    multichoose (-n : R) (n + 1) = 0 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [BinomialRing R] [NatPowAssoc R] (n : ℕ)
Goal: Ring.multichoose (-↑n) (n + 1) = 0
-- Ring.smeval_ascPochhammer_int_ofNat
theorem smeval_ascPochhammer_int_ofNat [NatPowAssoc R] (r : R) : ∀ n : ℕ,
    smeval (ascPochhammer ℤ n) r = smeval (ascPochhammer ℕ n) r
  
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] (r : R) (n : ℕ)
Goal: (ascPochhammer ℤ n).smeval r = (ascPochhammer ℕ n).smeval r
-- Ring.descPochhammer_eq_factorial_smul_choose
theorem descPochhammer_eq_factorial_smul_choose [NatPowAssoc R] (r : R) (n : ℕ) :
    (descPochhammer ℤ n).smeval r = n.factorial • choose r n 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [BinomialRing R] [NatPowAssoc R] (r : R) (n : ℕ)
Goal: (descPochhammer ℤ n).smeval r = n.factorial • Ring.choose r n
-- Ring.choose_natCast
theorem choose_natCast [NatPowAssoc R] (n k : ℕ) : choose (n : R) k = Nat.choose n k 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [BinomialRing R] [NatPowAssoc R] (n k : ℕ)
Goal: Ring.choose (↑n) k = ↑(n.choose k)
-- Ring.choose_zero_right'
@[simp]
theorem choose_zero_right' (r : R) : choose r 0 = (r + 1) ^ 0 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [BinomialRing R] (r : R)
Goal: Ring.choose r 0 = (r + 1) ^ 0
-- Ring.choose_zero_right
theorem choose_zero_right [NatPowAssoc R] (r : R) : choose r 0 = 1 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [BinomialRing R] [NatPowAssoc R] (r : R)
Goal: Ring.choose r 0 = 1
-- Ring.choose_zero_succ
@[simp]
theorem choose_zero_succ (R) [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] [BinomialRing R]
    (n : ℕ) : choose (0 : R) (n + 1) = 0 
Arguments: (R : Type u_2) [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] [BinomialRing R] (n : ℕ)
Goal: Ring.choose 0 (n + 1) = 0
-- Ring.choose_zero_pos
theorem choose_zero_pos (R) [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] [BinomialRing R]
    {k : ℕ} (h_pos: 0 < k) : choose (0 : R) k = 0 
Arguments: (R : Type u_2) [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] [BinomialRing R] {k : ℕ} (h_pos : 0 < k)
Goal: Ring.choose 0 k = 0
-- Ring.choose_zero_ite
theorem choose_zero_ite (R) [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] [BinomialRing R]
    (k : ℕ) : choose (0 : R) k = if k = 0 then 1 else 0 
Arguments: (R : Type u_2) [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] [BinomialRing R] (k : ℕ)
Goal: Ring.choose 0 k = if k = 0 then 1 else 0
-- Ring.choose_one_right'
@[simp]
theorem choose_one_right' (r : R) : choose r 1 = r ^ 1 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [BinomialRing R] (r : R)
Goal: Ring.choose r 1 = r ^ 1
-- Ring.choose_one_right
theorem choose_one_right [NatPowAssoc R] (r : R) : choose r 1 = r 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [BinomialRing R] [NatPowAssoc R] (r : R)
Goal: Ring.choose r 1 = r
-- Ring.descPochhammer_succ_succ_smeval
theorem descPochhammer_succ_succ_smeval {R} [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R]
    (r : R) (k : ℕ) : smeval (descPochhammer ℤ (k + 1)) (r + 1) =
    (k + 1) • smeval (descPochhammer ℤ k) r + smeval (descPochhammer ℤ (k + 1)) r 
Arguments: {R : Type u_2} [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] (r : R) (k : ℕ)
Goal: (descPochhammer ℤ (k + 1)).smeval (r + 1) =
  (k + 1) • (descPochhammer ℤ k).smeval r + (descPochhammer ℤ (k + 1)).smeval r
-- Ring.choose_succ_succ
theorem choose_succ_succ [NatPowAssoc R] (r : R) (k : ℕ) :
    choose (r + 1) (k + 1) = choose r k + choose r (k + 1) 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [BinomialRing R] [NatPowAssoc R] (r : R) (k : ℕ)
Goal: Ring.choose (r + 1) (k + 1) = Ring.choose r k + Ring.choose r (k + 1)
-- Ring.choose_eq_nat_choose
theorem choose_eq_nat_choose [NatPowAssoc R] (n k : ℕ) : choose (n : R) k = Nat.choose n k 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [BinomialRing R] [NatPowAssoc R] (n k : ℕ)
Goal: Ring.choose (↑n) k = ↑(n.choose k)
-- Ring.choose_smul_choose
theorem choose_smul_choose [NatPowAssoc R] (r : R) (n k : ℕ) (hkn : k ≤ n) :
    (Nat.choose n k) • choose r n = choose r k * choose (r - k) (n - k) 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [BinomialRing R] [NatPowAssoc R] (r : R) (n k : ℕ) (hkn : k ≤ n)
Goal: n.choose k • Ring.choose r n = Ring.choose r k * Ring.choose (r - ↑k) (n - k)
-- Ring.choose_add_smul_choose
theorem choose_add_smul_choose [NatPowAssoc R] (r : R) (n k : ℕ) :
    (Nat.choose (n + k) k) • choose (r + k) (n + k) = choose (r + k) k * choose r n 
Arguments: {R : Type u_1} [NonAssocRing R] [Pow R ℕ] [BinomialRing R] [NatPowAssoc R] (r : R) (n k : ℕ)
Goal: (n + k).choose k • Ring.choose (r + ↑k) (n + k) = Ring.choose (r + ↑k) k * Ring.choose r n
-- Ring.descPochhammer_smeval_add
theorem descPochhammer_smeval_add [Ring R] {r s : R} (k : ℕ) (h: Commute r s) :
    (descPochhammer ℤ k).smeval (r + s) = ∑ ij ∈ antidiagonal k,
    Nat.choose k ij.1 * ((descPochhammer ℤ ij.1).smeval r * (descPochhammer ℤ ij.2).smeval s) 
Arguments: {R : Type u_1} [Ring R] {r s : R} (k : ℕ) (h : Commute r s)
Goal: (descPochhammer ℤ k).smeval (r + s) =
  ∑ ij ∈ Finset.antidiagonal k, ↑(k.choose ij.1) * ((descPochhammer ℤ ij.1).smeval r * (descPochhammer ℤ ij.2).smeval s)
-- Ring.add_choose_eq
theorem add_choose_eq [Ring R] [BinomialRing R] {r s : R} (k : ℕ) (h : Commute r s) :
    choose (r + s) k =
      ∑ ij ∈ antidiagonal k, choose r ij.1 * choose s ij.2 
Arguments: {R : Type u_1} [Ring R] [BinomialRing R] {r s : R} (k : ℕ) (h : Commute r s)
Goal: Ring.choose (r + s) k = ∑ ij ∈ Finset.antidiagonal k, Ring.choose r ij.1 * Ring.choose s ij.2
-- IsPrincipalIdealRing.principal
@[mk_iff]
class IsPrincipalIdealRing (R : Type u) [Semiring R] : Prop where
  principal : ∀ S : Ideal R, S.IsPrincipal
Arguments: {R : Type u} [Semiring R] [self : IsPrincipalIdealRing R] (S : Ideal R)
Goal: Submodule.IsPrincipal S
-- isPrincipalIdealRing_iff
@[mk_iff]
class IsPrincipalIdealRing (R : Type u) [Semiring R] : Prop where
  principal : ∀ S : Ideal R, S.IsPrincipal
Arguments: (R : Type u) [Semiring R]
Goal: IsPrincipalIdealRing R ↔ ∀ (S : Ideal R), Submodule.IsPrincipal S
-- Ideal.zero_mem
protected theorem zero_mem : (0 : α) ∈ I 
Arguments: {α : Type u} [Semiring α] (I : Ideal α)
Goal: 0 ∈ I
-- Ideal.add_mem
protected theorem add_mem : a ∈ I → b ∈ I → a + b ∈ I 
Arguments: {α : Type u} [Semiring α] (I : Ideal α) {a b : α}
Goal: a ∈ I → b ∈ I → a + b ∈ I
-- Ideal.mul_mem_left
theorem mul_mem_left : b ∈ I → a * b ∈ I 
Arguments: {α : Type u} [Semiring α] (I : Ideal α) (a : α) {b : α}
Goal: b ∈ I → a * b ∈ I
-- Ideal.ext
@[ext]
theorem ext {I J : Ideal α} (h : ∀ x, x ∈ I ↔ x ∈ J) : I = J 
Arguments: {α : Type u} [Semiring α] {I J : Ideal α} (h : ∀ (x : α), x ∈ I ↔ x ∈ J)
Goal: I = J
-- Ideal.sum_mem
theorem sum_mem (I : Ideal α) {ι : Type*} {t : Finset ι} {f : ι → α} :
    (∀ c ∈ t, f c ∈ I) → (∑ i ∈ t, f i) ∈ I 
Arguments: {α : Type u} [Semiring α] (I : Ideal α) {ι : Type u_1} {t : Finset ι} {f : ι → α}
Goal: (∀ c ∈ t, f c ∈ I) → ∑ i ∈ t, f i ∈ I
-- Ideal.eq_top_of_unit_mem
theorem eq_top_of_unit_mem (x y : α) (hx : x ∈ I) (h : y * x = 1) : I = ⊤ 
Arguments: {α : Type u} [Semiring α] (I : Ideal α) (x y : α) (hx : x ∈ I) (h : y * x = 1)
Goal: I = ⊤
-- Ideal.eq_top_of_isUnit_mem
theorem eq_top_of_isUnit_mem {x} (hx : x ∈ I) (h : IsUnit x) : I = ⊤ 
Arguments: {α : Type u} [Semiring α] (I : Ideal α) {x : α} (hx : x ∈ I) (h : IsUnit x)
Goal: I = ⊤
-- Ideal.eq_top_iff_one
theorem eq_top_iff_one : I = ⊤ ↔ (1 : α) ∈ I 
Arguments: {α : Type u} [Semiring α] (I : Ideal α)
Goal: I = ⊤ ↔ 1 ∈ I
-- Ideal.ne_top_iff_one
theorem ne_top_iff_one : I ≠ ⊤ ↔ (1 : α) ∉ I 
Arguments: {α : Type u} [Semiring α] (I : Ideal α)
Goal: I ≠ ⊤ ↔ 1 ∉ I
-- Ideal.unit_mul_mem_iff_mem
@[simp]
theorem unit_mul_mem_iff_mem {x y : α} (hy : IsUnit y) : y * x ∈ I ↔ x ∈ I 
Arguments: {α : Type u} [Semiring α] (I : Ideal α) {x y : α} (hy : IsUnit y)
Goal: y * x ∈ I ↔ x ∈ I
-- Ideal.submodule_span_eq
@[simp]
theorem submodule_span_eq {s : Set α} : Submodule.span α s = Ideal.span s 
Arguments: {α : Type u} [Semiring α] {s : Set α}
Goal: Submodule.span α s = Ideal.span s
-- Ideal.span_empty
@[simp]
theorem span_empty : span (∅ : Set α) = ⊥ 
Arguments: {α : Type u} [Semiring α]
Goal: Ideal.span ∅ = ⊥
-- Ideal.span_univ
@[simp]
theorem span_univ : span (Set.univ : Set α) = ⊤ 
Arguments: {α : Type u} [Semiring α]
Goal: Ideal.span Set.univ = ⊤
-- Ideal.span_union
theorem span_union (s t : Set α) : span (s ∪ t) = span s ⊔ span t 
Arguments: {α : Type u} [Semiring α] (s t : Set α)
Goal: Ideal.span (s ∪ t) = Ideal.span s ⊔ Ideal.span t
-- Ideal.span_iUnion
theorem span_iUnion {ι} (s : ι → Set α) : span (⋃ i, s i) = ⨆ i, span (s i) 
Arguments: {α : Type u} [Semiring α] {ι : Sort u_1} (s : ι → Set α)
Goal: Ideal.span (⋃ i, s i) = ⨆ i, Ideal.span (s i)
-- Ideal.mem_span
theorem mem_span {s : Set α} (x) : x ∈ span s ↔ ∀ p : Ideal α, s ⊆ p → x ∈ p 
Arguments: {α : Type u} [Semiring α] {s : Set α} (x : α)
Goal: x ∈ Ideal.span s ↔ ∀ (p : Ideal α), s ⊆ ↑p → x ∈ p
-- Ideal.subset_span
theorem subset_span {s : Set α} : s ⊆ span s 
Arguments: {α : Type u} [Semiring α] {s : Set α}
Goal: s ⊆ ↑(Ideal.span s)
-- Ideal.span_le
theorem span_le {s : Set α} {I} : span s ≤ I ↔ s ⊆ I 
Arguments: {α : Type u} [Semiring α] {s : Set α} {I : Ideal α}
Goal: Ideal.span s ≤ I ↔ s ⊆ ↑I
-- Ideal.span_mono
theorem span_mono {s t : Set α} : s ⊆ t → span s ≤ span t 
Arguments: {α : Type u} [Semiring α] {s t : Set α}
Goal: s ⊆ t → Ideal.span s ≤ Ideal.span t
-- Ideal.span_eq
@[simp]
theorem span_eq : span (I : Set α) = I 
Arguments: {α : Type u} [Semiring α] (I : Ideal α)
Goal: Ideal.span ↑I = I
-- Ideal.span_singleton_one
@[simp]
theorem span_singleton_one : span ({1} : Set α) = ⊤ 
Arguments: {α : Type u} [Semiring α]
Goal: Ideal.span {1} = ⊤
-- Ideal.isCompactElement_top
theorem isCompactElement_top : CompleteLattice.IsCompactElement (⊤ : Ideal α) 
Arguments: {α : Type u} [Semiring α]
Goal: CompleteLattice.IsCompactElement ⊤
-- Ideal.mem_span_insert
theorem mem_span_insert {s : Set α} {x y} :
    x ∈ span (insert y s) ↔ ∃ a, ∃ z ∈ span s, x = a * y + z 
Arguments: {α : Type u} [Semiring α] {s : Set α} {x y : α}
Goal: x ∈ Ideal.span (insert y s) ↔ ∃ a, ∃ z ∈ Ideal.span s, x = a * y + z
-- Ideal.mem_span_singleton'
theorem mem_span_singleton' {x y : α} : x ∈ span ({y} : Set α) ↔ ∃ a, a * y = x 
Arguments: {α : Type u} [Semiring α] {x y : α}
Goal: x ∈ Ideal.span {y} ↔ ∃ a, a * y = x
-- Ideal.span_singleton_le_iff_mem
theorem span_singleton_le_iff_mem {x : α} : span {x} ≤ I ↔ x ∈ I 
Arguments: {α : Type u} [Semiring α] (I : Ideal α) {x : α}
Goal: Ideal.span {x} ≤ I ↔ x ∈ I
-- Ideal.span_singleton_mul_left_unit
theorem span_singleton_mul_left_unit {a : α} (h2 : IsUnit a) (x : α) :
    span ({a * x} : Set α) = span {x} 
Arguments: {α : Type u} [Semiring α] {a : α} (h2 : IsUnit a) (x : α)
Goal: Ideal.span {a * x} = Ideal.span {x}
-- Ideal.span_insert
theorem span_insert (x) (s : Set α) : span (insert x s) = span ({x} : Set α) ⊔ span s 
Arguments: {α : Type u} [Semiring α] (x : α) (s : Set α)
Goal: Ideal.span (insert x s) = Ideal.span {x} ⊔ Ideal.span s
-- Ideal.span_eq_bot
theorem span_eq_bot {s : Set α} : span s = ⊥ ↔ ∀ x ∈ s, (x : α) = 0 
Arguments: {α : Type u} [Semiring α] {s : Set α}
Goal: Ideal.span s = ⊥ ↔ ∀ x ∈ s, x = 0
-- Ideal.span_singleton_eq_bot
@[simp]
theorem span_singleton_eq_bot {x} : span ({x} : Set α) = ⊥ ↔ x = 0 
Arguments: {α : Type u} [Semiring α] {x : α}
Goal: Ideal.span {x} = ⊥ ↔ x = 0
-- Ideal.span_singleton_ne_top
theorem span_singleton_ne_top {α : Type*} [CommSemiring α] {x : α} (hx : ¬IsUnit x) :
    Ideal.span ({x} : Set α) ≠ ⊤ 
Arguments: {α : Type u_1} [CommSemiring α] {x : α} (hx : ¬IsUnit x)
Goal: Ideal.span {x} ≠ ⊤
-- Ideal.span_zero
@[simp]
theorem span_zero : span (0 : Set α) = ⊥ 
Arguments: {α : Type u} [Semiring α]
Goal: Ideal.span 0 = ⊥
-- Ideal.span_one
@[simp]
theorem span_one : span (1 : Set α) = ⊤ 
Arguments: {α : Type u} [Semiring α]
Goal: Ideal.span 1 = ⊤
-- Ideal.span_eq_top_iff_finite
theorem span_eq_top_iff_finite (s : Set α) :
    span s = ⊤ ↔ ∃ s' : Finset α, ↑s' ⊆ s ∧ span (s' : Set α) = ⊤ 
Arguments: {α : Type u} [Semiring α] (s : Set α)
Goal: Ideal.span s = ⊤ ↔ ∃ s', ↑s' ⊆ s ∧ Ideal.span ↑s' = ⊤
-- Ideal.mem_span_singleton_sup
theorem mem_span_singleton_sup {S : Type*} [CommSemiring S] {x y : S} {I : Ideal S} :
    x ∈ Ideal.span {y} ⊔ I ↔ ∃ a : S, ∃ b ∈ I, a * y + b = x 
Arguments: {S : Type u_1} [CommSemiring S] {x y : S} {I : Ideal S}
Goal: x ∈ Ideal.span {y} ⊔ I ↔ ∃ a, ∃ b ∈ I, a * y + b = x
-- Ideal.IsPrime.mem_or_mem'
class IsPrime (I : Ideal α) : Prop where
    ne_top' : I ≠ ⊤
    mem_or_mem' : ∀ {x y : α}, x * y ∈ I → x ∈ I ∨ y ∈ I
Arguments: {α : Type u} [Semiring α] {I : Ideal α} [self : I.IsPrime] {x y : α}
Goal: x * y ∈ I → x ∈ I ∨ y ∈ I
-- Ideal.IsPrime.ne_top'
class IsPrime (I : Ideal α) : Prop where
    ne_top' : I ≠ ⊤
    mem_or_mem' : ∀ {x y : α}, x * y ∈ I → x ∈ I ∨ y ∈ I
Arguments: {α : Type u} [Semiring α] {I : Ideal α} [self : I.IsPrime]
Goal: I ≠ ⊤
-- Ideal.isPrime_iff
theorem isPrime_iff {I : Ideal α} : IsPrime I ↔ I ≠ ⊤ ∧ ∀ {x y : α}, x * y ∈ I → x ∈ I ∨ y ∈ I 
Arguments: {α : Type u} [Semiring α] {I : Ideal α}
Goal: I.IsPrime ↔ I ≠ ⊤ ∧ ∀ {x y : α}, x * y ∈ I → x ∈ I ∨ y ∈ I
-- Ideal.IsPrime.ne_top
theorem IsPrime.ne_top {I : Ideal α} (hI : I.IsPrime) : I ≠ ⊤ 
Arguments: {α : Type u} [Semiring α] {I : Ideal α} (hI : I.IsPrime)
Goal: I ≠ ⊤
-- Ideal.IsPrime.mem_or_mem
theorem IsPrime.mem_or_mem {I : Ideal α} (hI : I.IsPrime) {x y : α} : x * y ∈ I → x ∈ I ∨ y ∈ I 
Arguments: {α : Type u} [Semiring α] {I : Ideal α} (hI : I.IsPrime) {x y : α}
Goal: x * y ∈ I → x ∈ I ∨ y ∈ I
-- Ideal.IsPrime.mem_or_mem_of_mul_eq_zero
theorem IsPrime.mem_or_mem_of_mul_eq_zero {I : Ideal α} (hI : I.IsPrime) {x y : α} (h : x * y = 0) :
    x ∈ I ∨ y ∈ I 
Arguments: {α : Type u} [Semiring α] {I : Ideal α} (hI : I.IsPrime) {x y : α} (h : x * y = 0)
Goal: x ∈ I ∨ y ∈ I
-- Ideal.IsPrime.mem_of_pow_mem
theorem IsPrime.mem_of_pow_mem {I : Ideal α} (hI : I.IsPrime) {r : α} (n : ℕ) (H : r ^ n ∈ I) :
    r ∈ I 
Arguments: {α : Type u} [Semiring α] {I : Ideal α} (hI : I.IsPrime) {r : α} (n : ℕ) (H : r ^ n ∈ I)
Goal: r ∈ I
-- Ideal.not_isPrime_iff
theorem not_isPrime_iff {I : Ideal α} :
    ¬I.IsPrime ↔ I = ⊤ ∨ ∃ (x : α) (_hx : x ∉ I) (y : α) (_hy : y ∉ I), x * y ∈ I 
Arguments: {α : Type u} [Semiring α] {I : Ideal α}
Goal: ¬I.IsPrime ↔ I = ⊤ ∨ ∃ x, ∃ (_ : x ∉ I), ∃ y, ∃ (_ : y ∉ I), x * y ∈ I
-- Ideal.zero_ne_one_of_proper
theorem zero_ne_one_of_proper {I : Ideal α} (h : I ≠ ⊤) : (0 : α) ≠ 1 
Arguments: {α : Type u} [Semiring α] {I : Ideal α} (h : I ≠ ⊤)
Goal: 0 ≠ 1
-- Ideal.bot_prime
theorem bot_prime [IsDomain α] : (⊥ : Ideal α).IsPrime 
Arguments: {α : Type u} [Semiring α] [IsDomain α]
Goal: ⊥.IsPrime
-- Ideal.IsMaximal.out
class IsMaximal (I : Ideal α) : Prop where
    out : IsCoatom I
Arguments: {α : Type u} [Semiring α] {I : Ideal α} [self : I.IsMaximal]
Goal: IsCoatom I
-- Ideal.isMaximal_def
theorem isMaximal_def {I : Ideal α} : I.IsMaximal ↔ IsCoatom I 
Arguments: {α : Type u} [Semiring α] {I : Ideal α}
Goal: I.IsMaximal ↔ IsCoatom I
-- Ideal.IsMaximal.ne_top
theorem IsMaximal.ne_top {I : Ideal α} (h : I.IsMaximal) : I ≠ ⊤ 
Arguments: {α : Type u} [Semiring α] {I : Ideal α} (h : I.IsMaximal)
Goal: I ≠ ⊤
-- Ideal.isMaximal_iff
theorem isMaximal_iff {I : Ideal α} :
    I.IsMaximal ↔ (1 : α) ∉ I ∧ ∀ (J : Ideal α) (x), I ≤ J → x ∉ I → x ∈ J → (1 : α) ∈ J 
Arguments: {α : Type u} [Semiring α] {I : Ideal α}
Goal: I.IsMaximal ↔ 1 ∉ I ∧ ∀ (J : Ideal α) (x : α), I ≤ J → x ∉ I → x ∈ J → 1 ∈ J
-- Ideal.IsMaximal.eq_of_le
theorem IsMaximal.eq_of_le {I J : Ideal α} (hI : I.IsMaximal) (hJ : J ≠ ⊤) (IJ : I ≤ J) : I = J 
Arguments: {α : Type u} [Semiring α] {I J : Ideal α} (hI : I.IsMaximal) (hJ : J ≠ ⊤) (IJ : I ≤ J)
Goal: I = J
-- Ideal.IsMaximal.coprime_of_ne
theorem IsMaximal.coprime_of_ne {M M' : Ideal α} (hM : M.IsMaximal) (hM' : M'.IsMaximal)
    (hne : M ≠ M') : M ⊔ M' = ⊤ 
Arguments: {α : Type u} [Semiring α] {M M' : Ideal α} (hM : M.IsMaximal) (hM' : M'.IsMaximal) (hne : M ≠ M')
Goal: M ⊔ M' = ⊤
-- Ideal.exists_le_maximal
theorem exists_le_maximal (I : Ideal α) (hI : I ≠ ⊤) : ∃ M : Ideal α, M.IsMaximal ∧ I ≤ M 
Arguments: {α : Type u} [Semiring α] (I : Ideal α) (hI : I ≠ ⊤)
Goal: ∃ M, M.IsMaximal ∧ I ≤ M
-- Ideal.exists_maximal
theorem exists_maximal [Nontrivial α] : ∃ M : Ideal α, M.IsMaximal 
Arguments: (α : Type u) [Semiring α] [Nontrivial α]
Goal: ∃ M, M.IsMaximal
-- Ideal.maximal_of_no_maximal
theorem maximal_of_no_maximal {P : Ideal α}
    (hmax : ∀ m : Ideal α, P < m → ¬IsMaximal m) (J : Ideal α) (hPJ : P < J) : J = ⊤ 
Arguments: {α : Type u} [Semiring α] {P : Ideal α} (hmax : ∀ (m : Ideal α), P < m → ¬m.IsMaximal) (J : Ideal α) (hPJ : P < J)
Goal: J = ⊤
-- Ideal.span_pair_comm
theorem span_pair_comm {x y : α} : (span {x, y} : Ideal α) = span {y, x} 
Arguments: {α : Type u} [Semiring α] {x y : α}
Goal: Ideal.span {x, y} = Ideal.span {y, x}
-- Ideal.mem_span_pair
theorem mem_span_pair {x y z : α} : z ∈ span ({x, y} : Set α) ↔ ∃ a b, a * x + b * y = z 
Arguments: {α : Type u} [Semiring α] {x y z : α}
Goal: z ∈ Ideal.span {x, y} ↔ ∃ a b, a * x + b * y = z
-- Ideal.span_pair_add_mul_left
@[simp]
theorem span_pair_add_mul_left {R : Type u} [CommRing R] {x y : R} (z : R) :
    (span {x + y * z, y} : Ideal R) = span {x, y} 
Arguments: {R : Type u} [CommRing R] {x y : R} (z : R)
Goal: Ideal.span {x + y * z, y} = Ideal.span {x, y}
-- Ideal.span_pair_add_mul_right
@[simp]
theorem span_pair_add_mul_right {R : Type u} [CommRing R] {x y : R} (z : R) :
    (span {x, y + x * z} : Ideal R) = span {x, y} 
Arguments: {R : Type u} [CommRing R] {x y : R} (z : R)
Goal: Ideal.span {x, y + x * z} = Ideal.span {x, y}
-- Ideal.IsMaximal.exists_inv
theorem IsMaximal.exists_inv {I : Ideal α} (hI : I.IsMaximal) {x} (hx : x ∉ I) :
    ∃ y, ∃ i ∈ I, y * x + i = 1 
Arguments: {α : Type u} [Semiring α] {I : Ideal α} (hI : I.IsMaximal) {x : α} (hx : x ∉ I)
Goal: ∃ y, ∃ i ∈ I, y * x + i = 1
-- Ideal.mem_sup_left
theorem mem_sup_left {S T : Ideal R} : ∀ {x : R}, x ∈ S → x ∈ S ⊔ T 
Arguments: {R : Type u} [Semiring R] {S T : Ideal R} {x : R}
Goal: x ∈ S → x ∈ S ⊔ T
-- Ideal.mem_sup_right
theorem mem_sup_right {S T : Ideal R} : ∀ {x : R}, x ∈ T → x ∈ S ⊔ T 
Arguments: {R : Type u} [Semiring R] {S T : Ideal R} {x : R}
Goal: x ∈ T → x ∈ S ⊔ T
-- Ideal.mem_iSup_of_mem
theorem mem_iSup_of_mem {ι : Sort*} {S : ι → Ideal R} (i : ι) : ∀ {x : R}, x ∈ S i → x ∈ iSup S 
Arguments: {R : Type u} [Semiring R] {ι : Sort u_1} {S : ι → Ideal R} (i : ι) {x : R}
Goal: x ∈ S i → x ∈ iSup S