ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MvPolynomial.optionEquivLeft_X_some
lemma optionEquivLeft_X_some (x : S₁) : optionEquivLeft R S₁ (X (some x)) = Polynomial.C (X x) 
Arguments: (R : Type u) (S₁ : Type v) [CommSemiring R] (x : S₁)
Goal: (MvPolynomial.optionEquivLeft R S₁) (MvPolynomial.X (some x)) = Polynomial.C (MvPolynomial.X x)
-- MvPolynomial.optionEquivLeft_X_none
lemma optionEquivLeft_X_none : optionEquivLeft R S₁ (X none) = Polynomial.X 
Arguments: (R : Type u) (S₁ : Type v) [CommSemiring R]
Goal: (MvPolynomial.optionEquivLeft R S₁) (MvPolynomial.X none) = Polynomial.X
-- MvPolynomial.optionEquivLeft_C
lemma optionEquivLeft_C (r : R) : optionEquivLeft R S₁ (C r) = Polynomial.C (C r) 
Arguments: (R : Type u) (S₁ : Type v) [CommSemiring R] (r : R)
Goal: (MvPolynomial.optionEquivLeft R S₁) (MvPolynomial.C r) = Polynomial.C (MvPolynomial.C r)
-- MvPolynomial.optionEquivRight_apply
@[simps!]
def optionEquivRight : MvPolynomial (Option S₁) R ≃ₐ[R] MvPolynomial S₁ R[X] 
Arguments: (R : Type u) (S₁ : Type v) [CommSemiring R] (a : MvPolynomial (Option S₁) R)
Goal: (MvPolynomial.optionEquivRight R S₁) a =
  (MvPolynomial.aeval fun o => o.elim (MvPolynomial.C Polynomial.X) MvPolynomial.X) a
-- MvPolynomial.optionEquivRight_symm_apply
@[simps!]
def optionEquivRight : MvPolynomial (Option S₁) R ≃ₐ[R] MvPolynomial S₁ R[X] 
Arguments: (R : Type u) (S₁ : Type v) [CommSemiring R] (a : MvPolynomial S₁ R[X])
Goal: (MvPolynomial.optionEquivRight R S₁).symm a =
  (MvPolynomial.aevalTower (Polynomial.aeval (MvPolynomial.X none)) fun i => MvPolynomial.X (some i)) a
-- MvPolynomial.optionEquivRight_X_some
lemma optionEquivRight_X_some (x : S₁) : optionEquivRight R S₁ (X (some x)) = X x 
Arguments: (R : Type u) (S₁ : Type v) [CommSemiring R] (x : S₁)
Goal: (MvPolynomial.optionEquivRight R S₁) (MvPolynomial.X (some x)) = MvPolynomial.X x
-- MvPolynomial.optionEquivRight_X_none
lemma optionEquivRight_X_none : optionEquivRight R S₁ (X none) = C Polynomial.X 
Arguments: (R : Type u) (S₁ : Type v) [CommSemiring R]
Goal: (MvPolynomial.optionEquivRight R S₁) (MvPolynomial.X none) = MvPolynomial.C Polynomial.X
-- MvPolynomial.optionEquivRight_C
lemma optionEquivRight_C (r : R) : optionEquivRight R S₁ (C r) = C (Polynomial.C r) 
Arguments: (R : Type u) (S₁ : Type v) [CommSemiring R] (r : R)
Goal: (MvPolynomial.optionEquivRight R S₁) (MvPolynomial.C r) = MvPolynomial.C (Polynomial.C r)
-- MvPolynomial.finSuccEquiv_eq
theorem finSuccEquiv_eq :
    (finSuccEquiv R n : MvPolynomial (Fin (n + 1)) R →+* Polynomial (MvPolynomial (Fin n) R)) =
      eval₂Hom (Polynomial.C.comp (C : R →+* MvPolynomial (Fin n) R)) fun i : Fin (n + 1) =>
        Fin.cases Polynomial.X (fun k => Polynomial.C (X k)) i 
Arguments: (R : Type u) [CommSemiring R] (n : ℕ)
Goal: ↑(MvPolynomial.finSuccEquiv R n) =
  MvPolynomial.eval₂Hom (Polynomial.C.comp MvPolynomial.C) fun i =>
    Fin.cases Polynomial.X (fun k => Polynomial.C (MvPolynomial.X k)) i
-- MvPolynomial.finSuccEquiv_apply
@[simp]
theorem finSuccEquiv_apply (p : MvPolynomial (Fin (n + 1)) R) :
    finSuccEquiv R n p =
      eval₂Hom (Polynomial.C.comp (C : R →+* MvPolynomial (Fin n) R))
        (fun i : Fin (n + 1) => Fin.cases Polynomial.X (fun k => Polynomial.C (X k)) i) p 
Arguments: (R : Type u) [CommSemiring R] (n : ℕ) (p : MvPolynomial (Fin (n + 1)) R)
Goal: (MvPolynomial.finSuccEquiv R n) p =
  (MvPolynomial.eval₂Hom (Polynomial.C.comp MvPolynomial.C) fun i =>
      Fin.cases Polynomial.X (fun k => Polynomial.C (MvPolynomial.X k)) i)
    p
-- MvPolynomial.finSuccEquiv_comp_C_eq_C
theorem finSuccEquiv_comp_C_eq_C {R : Type u} [CommSemiring R] (n : ℕ) :
    (↑(MvPolynomial.finSuccEquiv R n).symm : Polynomial (MvPolynomial (Fin n) R) →+* _).comp
        (Polynomial.C.comp MvPolynomial.C) =
      (MvPolynomial.C : R →+* MvPolynomial (Fin n.succ) R) 
Arguments: {R : Type u} [CommSemiring R] (n : ℕ)
Goal: (↑(MvPolynomial.finSuccEquiv R n).symm).comp (Polynomial.C.comp MvPolynomial.C) = MvPolynomial.C
-- MvPolynomial.finSuccEquiv_X_zero
theorem finSuccEquiv_X_zero : finSuccEquiv R n (X 0) = Polynomial.X 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ}
Goal: (MvPolynomial.finSuccEquiv R n) (MvPolynomial.X 0) = Polynomial.X
-- MvPolynomial.finSuccEquiv_X_succ
theorem finSuccEquiv_X_succ {j : Fin n} : finSuccEquiv R n (X j.succ) = Polynomial.C (X j) 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} {j : Fin n}
Goal: (MvPolynomial.finSuccEquiv R n) (MvPolynomial.X j.succ) = Polynomial.C (MvPolynomial.X j)
-- MvPolynomial.finSuccEquiv_coeff_coeff
theorem finSuccEquiv_coeff_coeff (m : Fin n →₀ ℕ) (f : MvPolynomial (Fin (n + 1)) R) (i : ℕ) :
    coeff m (Polynomial.coeff (finSuccEquiv R n f) i) = coeff (m.cons i) f 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} (m : Fin n →₀ ℕ) (f : MvPolynomial (Fin (n + 1)) R) (i : ℕ)
Goal: MvPolynomial.coeff m (((MvPolynomial.finSuccEquiv R n) f).coeff i) = MvPolynomial.coeff (Finsupp.cons i m) f
-- MvPolynomial.eval_eq_eval_mv_eval'
theorem eval_eq_eval_mv_eval' (s : Fin n → R) (y : R) (f : MvPolynomial (Fin (n + 1)) R) :
    eval (Fin.cons y s : Fin (n + 1) → R) f =
      Polynomial.eval y (Polynomial.map (eval s) (finSuccEquiv R n f)) 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} (s : Fin n → R) (y : R) (f : MvPolynomial (Fin (n + 1)) R)
Goal: (MvPolynomial.eval (Fin.cons y s)) f =
  Polynomial.eval y (Polynomial.map (MvPolynomial.eval s) ((MvPolynomial.finSuccEquiv R n) f))
-- MvPolynomial.coeff_eval_eq_eval_coeff
theorem coeff_eval_eq_eval_coeff (s' : Fin n → R) (f : Polynomial (MvPolynomial (Fin n) R))
    (i : ℕ) : Polynomial.coeff (Polynomial.map (eval s') f) i = eval s' (Polynomial.coeff f i) 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} (s' : Fin n → R) (f : (MvPolynomial (Fin n) R)[X]) (i : ℕ)
Goal: (Polynomial.map (MvPolynomial.eval s') f).coeff i = (MvPolynomial.eval s') (f.coeff i)
-- MvPolynomial.support_coeff_finSuccEquiv
theorem support_coeff_finSuccEquiv {f : MvPolynomial (Fin (n + 1)) R} {i : ℕ} {m : Fin n →₀ ℕ} :
    m ∈ (Polynomial.coeff ((finSuccEquiv R n) f) i).support ↔ Finsupp.cons i m ∈ f.support 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} {f : MvPolynomial (Fin (n + 1)) R} {i : ℕ} {m : Fin n →₀ ℕ}
Goal: m ∈ (((MvPolynomial.finSuccEquiv R n) f).coeff i).support ↔ Finsupp.cons i m ∈ f.support
-- MvPolynomial.totalDegree_coeff_finSuccEquiv_add_le
lemma totalDegree_coeff_finSuccEquiv_add_le (f : MvPolynomial (Fin (n + 1)) R) (i : ℕ)
    (hi : (finSuccEquiv R n f).coeff i ≠ 0) :
    totalDegree ((finSuccEquiv R n f).coeff i) + i ≤ totalDegree f 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} (f : MvPolynomial (Fin (n + 1)) R) (i : ℕ) (hi : ((MvPolynomial.finSuccEquiv R n) f).coeff i ≠ 0)
Goal: (((MvPolynomial.finSuccEquiv R n) f).coeff i).totalDegree + i ≤ f.totalDegree
-- MvPolynomial.finSuccEquiv_support
theorem finSuccEquiv_support (f : MvPolynomial (Fin (n + 1)) R) :
    (finSuccEquiv R n f).support = Finset.image (fun m : Fin (n + 1) →₀ ℕ => m 0) f.support 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} (f : MvPolynomial (Fin (n + 1)) R)
Goal: ((MvPolynomial.finSuccEquiv R n) f).support = Finset.image (fun m => m 0) f.support
-- MvPolynomial.finSuccEquiv_support'
theorem finSuccEquiv_support' {f : MvPolynomial (Fin (n + 1)) R} {i : ℕ} :
    Finset.image (Finsupp.cons i) (Polynomial.coeff ((finSuccEquiv R n) f) i).support =
      f.support.filter fun m => m 0 = i 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} {f : MvPolynomial (Fin (n + 1)) R} {i : ℕ}
Goal: Finset.image (Finsupp.cons i) (((MvPolynomial.finSuccEquiv R n) f).coeff i).support =
  Finset.filter (fun m => m 0 = i) f.support
-- MvPolynomial.support_finSuccEquiv_nonempty
theorem support_finSuccEquiv_nonempty {f : MvPolynomial (Fin (n + 1)) R} (h : f ≠ 0) :
    (finSuccEquiv R n f).support.Nonempty 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} {f : MvPolynomial (Fin (n + 1)) R} (h : f ≠ 0)
Goal: ((MvPolynomial.finSuccEquiv R n) f).support.Nonempty
-- MvPolynomial.degree_finSuccEquiv
theorem degree_finSuccEquiv {f : MvPolynomial (Fin (n + 1)) R} (h : f ≠ 0) :
    (finSuccEquiv R n f).degree = degreeOf 0 f 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} {f : MvPolynomial (Fin (n + 1)) R} (h : f ≠ 0)
Goal: ((MvPolynomial.finSuccEquiv R n) f).degree = ↑(MvPolynomial.degreeOf 0 f)
-- MvPolynomial.natDegree_finSuccEquiv
theorem natDegree_finSuccEquiv (f : MvPolynomial (Fin (n + 1)) R) :
    (finSuccEquiv R n f).natDegree = degreeOf 0 f 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} (f : MvPolynomial (Fin (n + 1)) R)
Goal: ((MvPolynomial.finSuccEquiv R n) f).natDegree = MvPolynomial.degreeOf 0 f
-- MvPolynomial.degreeOf_coeff_finSuccEquiv
theorem degreeOf_coeff_finSuccEquiv (p : MvPolynomial (Fin (n + 1)) R) (j : Fin n) (i : ℕ) :
    degreeOf j (Polynomial.coeff (finSuccEquiv R n p) i) ≤ degreeOf j.succ p 
Arguments: {R : Type u} [CommSemiring R] {n : ℕ} (p : MvPolynomial (Fin (n + 1)) R) (j : Fin n) (i : ℕ)
Goal: MvPolynomial.degreeOf j (((MvPolynomial.finSuccEquiv R n) p).coeff i) ≤ MvPolynomial.degreeOf j.succ p
-- MvPolynomial.finSuccEquiv_rename_finSuccEquiv
lemma finSuccEquiv_rename_finSuccEquiv (e : σ ≃ Fin n) (φ : MvPolynomial (Option σ) R) :
    ((finSuccEquiv R n) ((rename ((Equiv.optionCongr e).trans (_root_.finSuccEquiv n).symm)) φ)) =
      Polynomial.map (rename e).toRingHom (optionEquivLeft R σ φ) 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {n : ℕ} (e : σ ≃ Fin n) (φ : MvPolynomial (Option σ) R)
Goal: (MvPolynomial.finSuccEquiv R n) ((MvPolynomial.rename ⇑(e.optionCongr.trans (finSuccEquiv n).symm)) φ) =
  Polynomial.map (MvPolynomial.rename ⇑e).toRingHom ((MvPolynomial.optionEquivLeft R σ) φ)
-- Nat.castEmbedding_apply
@[simps]
def castEmbedding : ℕ ↪ R 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R]
Goal: ∀ (a : ℕ), Nat.castEmbedding a = ↑a
-- Nat.cast_pow_eq_one
@[simp]
theorem cast_pow_eq_one {R : Type*} [Semiring R] [CharZero R] (q : ℕ) (n : ℕ) (hn : n ≠ 0) :
    (q : R) ^ n = 1 ↔ q = 1 
Arguments: {R : Type u_2} [Semiring R] [CharZero R] (q n : ℕ) (hn : n ≠ 0)
Goal: ↑q ^ n = 1 ↔ q = 1
-- Nat.cast_div_charZero
@[simp, norm_cast]
theorem cast_div_charZero {k : Type*} [DivisionSemiring k] [CharZero k] {m n : ℕ} (n_dvd : n ∣ m) :
    ((m / n : ℕ) : k) = m / n 
Arguments: {k : Type u_2} [DivisionSemiring k] [CharZero k] {m n : ℕ} (n_dvd : n ∣ m)
Goal: ↑(m / n) = ↑m / ↑n
-- Function.support_natCast
lemma support_natCast (hn : n ≠ 0) : support (n : α → M) = univ 
Arguments: {α : Type u_1} {M : Type u_2} [AddMonoidWithOne M] [CharZero M] {n : ℕ} (hn : n ≠ 0)
Goal: Function.support ↑n = Set.univ
-- Function.mulSupport_natCast
lemma mulSupport_natCast (hn : n ≠ 1) : mulSupport (n : α → M) = univ 
Arguments: {α : Type u_1} {M : Type u_2} [AddMonoidWithOne M] [CharZero M] {n : ℕ} (hn : n ≠ 1)
Goal: Function.mulSupport ↑n = Set.univ
-- add_self_eq_zero
@[simp]
theorem add_self_eq_zero {a : R} : a + a = 0 ↔ a = 0 
Arguments: {R : Type u_1} [NonAssocSemiring R] [NoZeroDivisors R] [CharZero R] {a : R}
Goal: a + a = 0 ↔ a = 0
-- neg_eq_self_iff
@[simp] theorem neg_eq_self_iff {a : R} : -a = a ↔ a = 0 
Arguments: {R : Type u_1} [NonAssocRing R] [NoZeroDivisors R] [CharZero R] {a : R}
Goal: -a = a ↔ a = 0
-- eq_neg_self_iff
@[simp] theorem eq_neg_self_iff {a : R} : a = -a ↔ a = 0 
Arguments: {R : Type u_1} [NonAssocRing R] [NoZeroDivisors R] [CharZero R] {a : R}
Goal: a = -a ↔ a = 0
-- nat_mul_inj
theorem nat_mul_inj {n : ℕ} {a b : R} (h : (n : R) * a = (n : R) * b) : n = 0 ∨ a = b 
Arguments: {R : Type u_1} [NonAssocRing R] [NoZeroDivisors R] [CharZero R] {n : ℕ} {a b : R} (h : ↑n * a = ↑n * b)
Goal: n = 0 ∨ a = b
-- nat_mul_inj'
theorem nat_mul_inj' {n : ℕ} {a b : R} (h : (n : R) * a = (n : R) * b) (w : n ≠ 0) : a = b 
Arguments: {R : Type u_1} [NonAssocRing R] [NoZeroDivisors R] [CharZero R] {n : ℕ} {a b : R} (h : ↑n * a = ↑n * b) (w : n ≠ 0)
Goal: a = b
-- add_self_div_two
@[simp] lemma add_self_div_two (a : R) : (a + a) / 2 = a 
Arguments: {R : Type u_1} [DivisionSemiring R] [NeZero 2] (a : R)
Goal: (a + a) / 2 = a
-- add_halves
@[simp]
theorem add_halves (a : R) : a / 2 + a / 2 = a 
Arguments: {R : Type u_1} [DivisionSemiring R] [NeZero 2] (a : R)
Goal: a / 2 + a / 2 = a
-- sub_half
theorem sub_half (a : R) : a - a / 2 = a / 2 
Arguments: {R : Type u_1} [DivisionRing R] [CharZero R] (a : R)
Goal: a - a / 2 = a / 2
-- half_sub
theorem half_sub (a : R) : a / 2 - a = -(a / 2) 
Arguments: {R : Type u_1} [DivisionRing R] [CharZero R] (a : R)
Goal: a / 2 - a = -(a / 2)
-- RingHom.charZero
theorem RingHom.charZero (ϕ : R →+* S) [CharZero S] : CharZero R 
Arguments: {R : Type u_1} {S : Type u_2} [NonAssocSemiring R] [NonAssocSemiring S] (ϕ : R →+* S) [CharZero S]
Goal: CharZero R
-- RingHom.charZero_iff
theorem RingHom.charZero_iff {ϕ : R →+* S} (hϕ : Function.Injective ϕ) : CharZero R ↔ CharZero S 
Arguments: {R : Type u_1} {S : Type u_2} [NonAssocSemiring R] [NonAssocSemiring S] {ϕ : R →+* S} (hϕ : Function.Injective ⇑ϕ)
Goal: CharZero R ↔ CharZero S
-- RingHom.injective_nat
theorem RingHom.injective_nat (f : ℕ →+* R) [CharZero R] : Function.Injective f 
Arguments: {R : Type u_1} [NonAssocSemiring R] (f : ℕ →+* R) [CharZero R]
Goal: Function.Injective ⇑f
-- units_ne_neg_self
@[simp]
theorem units_ne_neg_self (u : Rˣ) : u ≠ -u 
Arguments: {R : Type u_1} [Ring R] [CharZero R] (u : Rˣ)
Goal: u ≠ -u
-- neg_units_ne_self
@[simp]
theorem neg_units_ne_self (u : Rˣ) : -u ≠ u 
Arguments: {R : Type u_1} [Ring R] [CharZero R] (u : Rˣ)
Goal: -u ≠ u
-- AddSubgroup.zsmul_mem_zmultiples_iff_exists_sub_div
theorem zsmul_mem_zmultiples_iff_exists_sub_div {r : R} {z : ℤ} (hz : z ≠ 0) :
    z • r ∈ AddSubgroup.zmultiples p ↔
      ∃ k : Fin z.natAbs, r - (k : ℕ) • (p / z : R) ∈ AddSubgroup.zmultiples p 
Arguments: {R : Type u_1} [DivisionRing R] [CharZero R] {p r : R} {z : ℤ} (hz : z ≠ 0)
Goal: z • r ∈ AddSubgroup.zmultiples p ↔ ∃ k, r - ↑k • (p / ↑z) ∈ AddSubgroup.zmultiples p
-- AddSubgroup.nsmul_mem_zmultiples_iff_exists_sub_div
theorem nsmul_mem_zmultiples_iff_exists_sub_div {r : R} {n : ℕ} (hn : n ≠ 0) :
    n • r ∈ AddSubgroup.zmultiples p ↔
      ∃ k : Fin n, r - (k : ℕ) • (p / n : R) ∈ AddSubgroup.zmultiples p 
Arguments: {R : Type u_1} [DivisionRing R] [CharZero R] {p r : R} {n : ℕ} (hn : n ≠ 0)
Goal: n • r ∈ AddSubgroup.zmultiples p ↔ ∃ k, r - ↑k • (p / ↑n) ∈ AddSubgroup.zmultiples p
-- QuotientAddGroup.zmultiples_zsmul_eq_zsmul_iff
theorem zmultiples_zsmul_eq_zsmul_iff {ψ θ : R ⧸ AddSubgroup.zmultiples p} {z : ℤ} (hz : z ≠ 0) :
    z • ψ = z • θ ↔ ∃ k : Fin z.natAbs, ψ = θ + ((k : ℕ) • (p / z) : R) 
Arguments: {R : Type u_1} [DivisionRing R] [CharZero R] {p : R} {ψ θ : R ⧸ AddSubgroup.zmultiples p} {z : ℤ} (hz : z ≠ 0)
Goal: z • ψ = z • θ ↔ ∃ k, ψ = θ + ↑(↑k • (p / ↑z))
-- QuotientAddGroup.zmultiples_nsmul_eq_nsmul_iff
theorem zmultiples_nsmul_eq_nsmul_iff {ψ θ : R ⧸ AddSubgroup.zmultiples p} {n : ℕ} (hz : n ≠ 0) :
    n • ψ = n • θ ↔ ∃ k : Fin n, ψ = θ + (k : ℕ) • (p / n : R) 
Arguments: {R : Type u_1} [DivisionRing R] [CharZero R] {p : R} {ψ θ : R ⧸ AddSubgroup.zmultiples p} {n : ℕ} (hz : n ≠ 0)
Goal: n • ψ = n • θ ↔ ∃ k, ψ = θ + ↑k • ↑(p / ↑n)
-- StarOrderedRing.le_iff
class StarOrderedRing (R : Type u) [NonUnitalSemiring R] [PartialOrder R]
    [StarRing R] : Prop where
    le_iff :
    ∀ x y : R, x ≤ y ↔ ∃ p, p ∈ AddSubmonoid.closure (Set.range fun s => star s * s) ∧ y = x + p
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [self : StarOrderedRing R] (x y : R)
Goal: x ≤ y ↔ ∃ p ∈ AddSubmonoid.closure (Set.range fun s => star s * s), y = x + p
-- StarOrderedRing.of_le_iff
lemma of_le_iff [NonUnitalSemiring R] [PartialOrder R] [StarRing R]
    (h_le_iff : ∀ x y : R, x ≤ y ↔ ∃ s, y = x + star s * s) : StarOrderedRing R 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] (h_le_iff : ∀ (x y : R), x ≤ y ↔ ∃ s, y = x + star s * s)
Goal: StarOrderedRing R
-- StarOrderedRing.of_nonneg_iff
lemma of_nonneg_iff [NonUnitalRing R] [PartialOrder R] [StarRing R]
    (h_add : ∀ {x y : R}, x ≤ y → ∀ z, z + x ≤ z + y)
    (h_nonneg_iff : ∀ x : R, 0 ≤ x ↔ x ∈ AddSubmonoid.closure (Set.range fun s : R => star s * s)) :
    StarOrderedRing R 
Arguments: {R : Type u} [NonUnitalRing R] [PartialOrder R] [StarRing R] (h_add : ∀ {x y : R}, x ≤ y → ∀ (z : R), z + x ≤ z + y) (h_nonneg_iff : ∀ (x : R), 0 ≤ x ↔ x ∈ AddSubmonoid.closure (Set.range fun s => star s * s))
Goal: StarOrderedRing R
-- StarOrderedRing.of_nonneg_iff'
lemma of_nonneg_iff' [NonUnitalRing R] [PartialOrder R] [StarRing R]
    (h_add : ∀ {x y : R}, x ≤ y → ∀ z, z + x ≤ z + y)
    (h_nonneg_iff : ∀ x : R, 0 ≤ x ↔ ∃ s, x = star s * s) : StarOrderedRing R 
Arguments: {R : Type u} [NonUnitalRing R] [PartialOrder R] [StarRing R] (h_add : ∀ {x y : R}, x ≤ y → ∀ (z : R), z + x ≤ z + y) (h_nonneg_iff : ∀ (x : R), 0 ≤ x ↔ ∃ s, x = star s * s)
Goal: StarOrderedRing R
-- StarOrderedRing.nonneg_iff
theorem nonneg_iff [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x : R} :
    0 ≤ x ↔ x ∈ AddSubmonoid.closure (Set.range fun s : R => star s * s) 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x : R}
Goal: 0 ≤ x ↔ x ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
-- star_mul_self_nonneg
theorem star_mul_self_nonneg (r : R) : 0 ≤ star r * r 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] (r : R)
Goal: 0 ≤ star r * r
-- mul_star_self_nonneg
theorem mul_star_self_nonneg (r : R) : 0 ≤ r * star r 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] (r : R)
Goal: 0 ≤ r * star r
-- conjugate_nonneg
theorem conjugate_nonneg {a : R} (ha : 0 ≤ a) (c : R) : 0 ≤ star c * a * c 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {a : R} (ha : 0 ≤ a) (c : R)
Goal: 0 ≤ star c * a * c
-- conjugate_nonneg'
theorem conjugate_nonneg' {a : R} (ha : 0 ≤ a) (c : R) : 0 ≤ c * a * star c 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {a : R} (ha : 0 ≤ a) (c : R)
Goal: 0 ≤ c * a * star c
-- conjugate_le_conjugate
theorem conjugate_le_conjugate {a b : R} (hab : a ≤ b) (c : R) :
    star c * a * c ≤ star c * b * c 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {a b : R} (hab : a ≤ b) (c : R)
Goal: star c * a * c ≤ star c * b * c
-- conjugate_le_conjugate'
theorem conjugate_le_conjugate' {a b : R} (hab : a ≤ b) (c : R) :
    c * a * star c ≤ c * b * star c 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {a b : R} (hab : a ≤ b) (c : R)
Goal: c * a * star c ≤ c * b * star c
-- star_le_star_iff
@[simp]
lemma star_le_star_iff {x y : R} : star x ≤ star y ↔ x ≤ y 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x y : R}
Goal: star x ≤ star y ↔ x ≤ y
-- star_lt_star_iff
@[simp]
lemma star_lt_star_iff {x y : R} : star x < star y ↔ x < y 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x y : R}
Goal: star x < star y ↔ x < y
-- star_le_iff
lemma star_le_iff {x y : R} : star x ≤ y ↔ x ≤ star y 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x y : R}
Goal: star x ≤ y ↔ x ≤ star y
-- star_lt_iff
lemma star_lt_iff {x y : R} : star x < y ↔ x < star y 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x y : R}
Goal: star x < y ↔ x < star y
-- star_nonneg_iff
@[simp]
lemma star_nonneg_iff {x : R} : 0 ≤ star x ↔ 0 ≤ x 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x : R}
Goal: 0 ≤ star x ↔ 0 ≤ x
-- star_nonpos_iff
@[simp]
lemma star_nonpos_iff {x : R} : star x ≤ 0 ↔ x ≤ 0 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x : R}
Goal: star x ≤ 0 ↔ x ≤ 0
-- star_pos_iff
@[simp]
lemma star_pos_iff {x : R} : 0 < star x ↔ 0 < x 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x : R}
Goal: 0 < star x ↔ 0 < x
-- star_neg_iff
@[simp]
lemma star_neg_iff {x : R} : star x < 0 ↔ x < 0 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x : R}
Goal: star x < 0 ↔ x < 0
-- IsSelfAdjoint.mono
lemma IsSelfAdjoint.mono {x y : R} (h : x ≤ y) (hx : IsSelfAdjoint x) : IsSelfAdjoint y 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x y : R} (h : x ≤ y) (hx : IsSelfAdjoint x)
Goal: IsSelfAdjoint y
-- IsSelfAdjoint.of_nonneg
@[aesop 10% apply]
lemma IsSelfAdjoint.of_nonneg {x : R} (hx : 0 ≤ x) : IsSelfAdjoint x 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x : R} (hx : 0 ≤ x)
Goal: IsSelfAdjoint x
-- conjugate_lt_conjugate
theorem conjugate_lt_conjugate {a b : R} (hab : a < b) {c : R} (hc : IsRegular c) :
    star c * a * c < star c * b * c 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {a b : R} (hab : a < b) {c : R} (hc : IsRegular c)
Goal: star c * a * c < star c * b * c
-- conjugate_lt_conjugate'
theorem conjugate_lt_conjugate' {a b : R} (hab : a < b) {c : R} (hc : IsRegular c) :
    c * a * star c < c * b * star c 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {a b : R} (hab : a < b) {c : R} (hc : IsRegular c)
Goal: c * a * star c < c * b * star c
-- conjugate_pos
theorem conjugate_pos {a : R} (ha : 0 < a) {c : R} (hc : IsRegular c) : 0 < star c * a * c 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {a : R} (ha : 0 < a) {c : R} (hc : IsRegular c)
Goal: 0 < star c * a * c
-- conjugate_pos'
theorem conjugate_pos' {a : R} (ha : 0 < a) {c : R} (hc : IsRegular c) : 0 < c * a * star c 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {a : R} (ha : 0 < a) {c : R} (hc : IsRegular c)
Goal: 0 < c * a * star c
-- star_mul_self_pos
theorem star_mul_self_pos [Nontrivial R] {x : R} (hx : IsRegular x) : 0 < star x * x 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] [Nontrivial R] {x : R} (hx : IsRegular x)
Goal: 0 < star x * x
-- mul_star_self_pos
theorem mul_star_self_pos [Nontrivial R] {x : R} (hx : IsRegular x) : 0 < x * star x 
Arguments: {R : Type u} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] [Nontrivial R] {x : R} (hx : IsRegular x)
Goal: 0 < x * star x
-- one_le_star_iff
@[simp]
lemma one_le_star_iff {x : R} : 1 ≤ star x ↔ 1 ≤ x 
Arguments: {R : Type u} [Semiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x : R}
Goal: 1 ≤ star x ↔ 1 ≤ x
-- star_le_one_iff
@[simp]
lemma star_le_one_iff {x : R} : star x ≤ 1 ↔ x ≤ 1 
Arguments: {R : Type u} [Semiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x : R}
Goal: star x ≤ 1 ↔ x ≤ 1
-- one_lt_star_iff
@[simp]
lemma one_lt_star_iff {x : R} : 1 < star x ↔ 1 < x 
Arguments: {R : Type u} [Semiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x : R}
Goal: 1 < star x ↔ 1 < x
-- star_lt_one_iff
@[simp]
lemma star_lt_one_iff {x : R} : star x < 1 ↔ x < 1 
Arguments: {R : Type u} [Semiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] {x : R}
Goal: star x < 1 ↔ x < 1
-- StarModule.smul_lt_smul_of_pos
lemma StarModule.smul_lt_smul_of_pos {a b : A} {c : R} (hab : a < b) (hc : 0 < c) :
    c • a < c • b 
Arguments: {R : Type u} {A : Type u_1} [Semiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] [NonUnitalRing A] [StarRing A] [PartialOrder A] [StarOrderedRing A] [Module R A] [StarModule R A] [NoZeroSMulDivisors R A] [IsScalarTower R A A] [SMulCommClass R A A] {a b : A} {c : R} (hab : a < b) (hc : 0 < c)
Goal: c • a < c • b
-- NonUnitalStarRingHom.map_le_map_of_map_star
lemma NonUnitalStarRingHom.map_le_map_of_map_star (f : R →⋆ₙ+* S) {x y : R} (hxy : x ≤ y) :
    f x ≤ f y 
Arguments: {R : Type u_2} {S : Type u_3} [NonUnitalSemiring R] [PartialOrder R] [StarRing R] [StarOrderedRing R] [NonUnitalSemiring S] [PartialOrder S] [StarRing S] [StarOrderedRing S] (f : R →⋆ₙ+* S) {x y : R} (hxy : x ≤ y)
Goal: f x ≤ f y