ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MvPolynomial.degreeOf_zero
@[simp]
theorem degreeOf_zero (n : σ) : degreeOf n (0 : MvPolynomial σ R) = 0 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (n : σ)
Goal: MvPolynomial.degreeOf n 0 = 0
-- MvPolynomial.degreeOf_C
@[simp]
theorem degreeOf_C (a : R) (x : σ) : degreeOf x (C a : MvPolynomial σ R) = 0 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (a : R) (x : σ)
Goal: MvPolynomial.degreeOf x (MvPolynomial.C a) = 0
-- MvPolynomial.degreeOf_X
theorem degreeOf_X [DecidableEq σ] (i j : σ) [Nontrivial R] :
    degreeOf i (X j : MvPolynomial σ R) = if i = j then 1 else 0 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] [DecidableEq σ] (i j : σ) [Nontrivial R]
Goal: MvPolynomial.degreeOf i (MvPolynomial.X j) = if i = j then 1 else 0
-- MvPolynomial.degreeOf_add_le
theorem degreeOf_add_le (n : σ) (f g : MvPolynomial σ R) :
    degreeOf n (f + g) ≤ max (degreeOf n f) (degreeOf n g) 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (n : σ) (f g : MvPolynomial σ R)
Goal: MvPolynomial.degreeOf n (f + g) ≤ max (MvPolynomial.degreeOf n f) (MvPolynomial.degreeOf n g)
-- MvPolynomial.monomial_le_degreeOf
theorem monomial_le_degreeOf (i : σ) {f : MvPolynomial σ R} {m : σ →₀ ℕ} (h_m : m ∈ f.support) :
    m i ≤ degreeOf i f 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (i : σ) {f : MvPolynomial σ R} {m : σ →₀ ℕ} (h_m : m ∈ f.support)
Goal: m i ≤ MvPolynomial.degreeOf i f
-- MvPolynomial.degreeOf_mul_le
theorem degreeOf_mul_le (i : σ) (f g : MvPolynomial σ R) :
    degreeOf i (f * g) ≤ degreeOf i f + degreeOf i g 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (i : σ) (f g : MvPolynomial σ R)
Goal: MvPolynomial.degreeOf i (f * g) ≤ MvPolynomial.degreeOf i f + MvPolynomial.degreeOf i g
-- MvPolynomial.degreeOf_mul_X_ne
theorem degreeOf_mul_X_ne {i j : σ} (f : MvPolynomial σ R) (h : i ≠ j) :
    degreeOf i (f * X j) = degreeOf i f 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {i j : σ} (f : MvPolynomial σ R) (h : i ≠ j)
Goal: MvPolynomial.degreeOf i (f * MvPolynomial.X j) = MvPolynomial.degreeOf i f
-- MvPolynomial.degreeOf_mul_X_eq
theorem degreeOf_mul_X_eq (j : σ) (f : MvPolynomial σ R) :
    degreeOf j (f * X j) ≤ degreeOf j f + 1 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (j : σ) (f : MvPolynomial σ R)
Goal: MvPolynomial.degreeOf j (f * MvPolynomial.X j) ≤ MvPolynomial.degreeOf j f + 1
-- MvPolynomial.degreeOf_C_mul_le
theorem degreeOf_C_mul_le (p : MvPolynomial σ R) (i : σ) (c : R) :
    (C c * p).degreeOf i ≤ p.degreeOf i 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (p : MvPolynomial σ R) (i : σ) (c : R)
Goal: MvPolynomial.degreeOf i (MvPolynomial.C c * p) ≤ MvPolynomial.degreeOf i p
-- MvPolynomial.degreeOf_mul_C_le
theorem degreeOf_mul_C_le (p : MvPolynomial σ R) (i : σ) (c : R) :
    (p * C c).degreeOf i ≤ p.degreeOf i 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (p : MvPolynomial σ R) (i : σ) (c : R)
Goal: MvPolynomial.degreeOf i (p * MvPolynomial.C c) ≤ MvPolynomial.degreeOf i p
-- MvPolynomial.degreeOf_rename_of_injective
theorem degreeOf_rename_of_injective {p : MvPolynomial σ R} {f : σ → τ} (h : Function.Injective f)
    (i : σ) : degreeOf (f i) (rename f p) = degreeOf i p 
Arguments: {R : Type u} {σ : Type u_1} {τ : Type u_2} [CommSemiring R] {p : MvPolynomial σ R} {f : σ → τ} (h : Function.Injective f) (i : σ)
Goal: MvPolynomial.degreeOf (f i) ((MvPolynomial.rename f) p) = MvPolynomial.degreeOf i p
-- MvPolynomial.totalDegree_eq
theorem totalDegree_eq (p : MvPolynomial σ R) :
    p.totalDegree = p.support.sup fun m => Multiset.card (toMultiset m) 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (p : MvPolynomial σ R)
Goal: p.totalDegree = p.support.sup fun m => Multiset.card (Finsupp.toMultiset m)
-- MvPolynomial.le_totalDegree
theorem le_totalDegree {p : MvPolynomial σ R} {s : σ →₀ ℕ} (h : s ∈ p.support) :
    (s.sum fun _ e => e) ≤ totalDegree p 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {p : MvPolynomial σ R} {s : σ →₀ ℕ} (h : s ∈ p.support)
Goal: (s.sum fun x e => e) ≤ p.totalDegree
-- MvPolynomial.totalDegree_le_degrees_card
theorem totalDegree_le_degrees_card (p : MvPolynomial σ R) :
    p.totalDegree ≤ Multiset.card p.degrees 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (p : MvPolynomial σ R)
Goal: p.totalDegree ≤ Multiset.card p.degrees
-- MvPolynomial.totalDegree_le_of_support_subset
theorem totalDegree_le_of_support_subset (h : p.support ⊆ q.support) :
    totalDegree p ≤ totalDegree q 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {p q : MvPolynomial σ R} (h : p.support ⊆ q.support)
Goal: p.totalDegree ≤ q.totalDegree
-- MvPolynomial.totalDegree_C
@[simp]
theorem totalDegree_C (a : R) : (C a : MvPolynomial σ R).totalDegree = 0 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (a : R)
Goal: (MvPolynomial.C a).totalDegree = 0
-- MvPolynomial.totalDegree_zero
@[simp]
theorem totalDegree_zero : (0 : MvPolynomial σ R).totalDegree = 0 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R]
Goal: MvPolynomial.totalDegree 0 = 0
-- MvPolynomial.totalDegree_one
@[simp]
theorem totalDegree_one : (1 : MvPolynomial σ R).totalDegree = 0 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R]
Goal: MvPolynomial.totalDegree 1 = 0
-- MvPolynomial.totalDegree_X
@[simp]
theorem totalDegree_X {R} [CommSemiring R] [Nontrivial R] (s : σ) :
    (X s : MvPolynomial σ R).totalDegree = 1 
Arguments: {σ : Type u_1} {R : Type u_3} [CommSemiring R] [Nontrivial R] (s : σ)
Goal: (MvPolynomial.X s).totalDegree = 1
-- MvPolynomial.totalDegree_add
theorem totalDegree_add (a b : MvPolynomial σ R) :
    (a + b).totalDegree ≤ max a.totalDegree b.totalDegree 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (a b : MvPolynomial σ R)
Goal: (a + b).totalDegree ≤ max a.totalDegree b.totalDegree
-- MvPolynomial.totalDegree_add_eq_left_of_totalDegree_lt
theorem totalDegree_add_eq_left_of_totalDegree_lt {p q : MvPolynomial σ R}
    (h : q.totalDegree < p.totalDegree) : (p + q).totalDegree = p.totalDegree 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {p q : MvPolynomial σ R} (h : q.totalDegree < p.totalDegree)
Goal: (p + q).totalDegree = p.totalDegree
-- MvPolynomial.totalDegree_add_eq_right_of_totalDegree_lt
theorem totalDegree_add_eq_right_of_totalDegree_lt {p q : MvPolynomial σ R}
    (h : q.totalDegree < p.totalDegree) : (q + p).totalDegree = p.totalDegree 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {p q : MvPolynomial σ R} (h : q.totalDegree < p.totalDegree)
Goal: (q + p).totalDegree = p.totalDegree
-- MvPolynomial.totalDegree_mul
theorem totalDegree_mul (a b : MvPolynomial σ R) :
    (a * b).totalDegree ≤ a.totalDegree + b.totalDegree 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (a b : MvPolynomial σ R)
Goal: (a * b).totalDegree ≤ a.totalDegree + b.totalDegree
-- MvPolynomial.totalDegree_smul_le
theorem totalDegree_smul_le [CommSemiring S] [DistribMulAction R S] (a : R) (f : MvPolynomial σ S) :
    (a • f).totalDegree ≤ f.totalDegree 
Arguments: {R : Type u} {S : Type v} {σ : Type u_1} [CommSemiring R] [CommSemiring S] [DistribMulAction R S] (a : R) (f : MvPolynomial σ S)
Goal: (a • f).totalDegree ≤ f.totalDegree
-- MvPolynomial.totalDegree_pow
theorem totalDegree_pow (a : MvPolynomial σ R) (n : ℕ) :
    (a ^ n).totalDegree ≤ n * a.totalDegree 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (a : MvPolynomial σ R) (n : ℕ)
Goal: (a ^ n).totalDegree ≤ n * a.totalDegree
-- MvPolynomial.totalDegree_monomial
@[simp]
theorem totalDegree_monomial (s : σ →₀ ℕ) {c : R} (hc : c ≠ 0) :
    (monomial s c : MvPolynomial σ R).totalDegree = s.sum fun _ e => e 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (s : σ →₀ ℕ) {c : R} (hc : c ≠ 0)
Goal: ((MvPolynomial.monomial s) c).totalDegree = s.sum fun x e => e
-- MvPolynomial.totalDegree_monomial_le
theorem totalDegree_monomial_le (s : σ →₀ ℕ) (c : R) :
    (monomial s c).totalDegree ≤ s.sum fun _ ↦ id 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (s : σ →₀ ℕ) (c : R)
Goal: ((MvPolynomial.monomial s) c).totalDegree ≤ s.sum fun x => id
-- MvPolynomial.totalDegree_X_pow
@[simp]
theorem totalDegree_X_pow [Nontrivial R] (s : σ) (n : ℕ) :
    (X s ^ n : MvPolynomial σ R).totalDegree = n 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] [Nontrivial R] (s : σ) (n : ℕ)
Goal: (MvPolynomial.X s ^ n).totalDegree = n
-- MvPolynomial.totalDegree_list_prod
theorem totalDegree_list_prod :
    ∀ s : List (MvPolynomial σ R), s.prod.totalDegree ≤ (s.map MvPolynomial.totalDegree).sum
  
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (s : List (MvPolynomial σ R))
Goal: s.prod.totalDegree ≤ (List.map MvPolynomial.totalDegree s).sum
-- MvPolynomial.totalDegree_multiset_prod
theorem totalDegree_multiset_prod (s : Multiset (MvPolynomial σ R)) :
    s.prod.totalDegree ≤ (s.map MvPolynomial.totalDegree).sum 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (s : Multiset (MvPolynomial σ R))
Goal: s.prod.totalDegree ≤ (Multiset.map MvPolynomial.totalDegree s).sum
-- MvPolynomial.totalDegree_finset_prod
theorem totalDegree_finset_prod {ι : Type*} (s : Finset ι) (f : ι → MvPolynomial σ R) :
    (s.prod f).totalDegree ≤ ∑ i ∈ s, (f i).totalDegree 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {ι : Type u_3} (s : Finset ι) (f : ι → MvPolynomial σ R)
Goal: (s.prod f).totalDegree ≤ ∑ i ∈ s, (f i).totalDegree
-- MvPolynomial.totalDegree_finset_sum
theorem totalDegree_finset_sum {ι : Type*} (s : Finset ι) (f : ι → MvPolynomial σ R) :
    (s.sum f).totalDegree ≤ Finset.sup s fun i => (f i).totalDegree 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {ι : Type u_3} (s : Finset ι) (f : ι → MvPolynomial σ R)
Goal: (s.sum f).totalDegree ≤ s.sup fun i => (f i).totalDegree
-- MvPolynomial.totalDegree_finsetSum_le
lemma totalDegree_finsetSum_le {ι : Type*} {s : Finset ι} {f : ι → MvPolynomial σ R} {d : ℕ}
    (hf : ∀ i ∈ s, (f i).totalDegree ≤ d) : (s.sum f).totalDegree ≤ d 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {ι : Type u_3} {s : Finset ι} {f : ι → MvPolynomial σ R} {d : ℕ} (hf : ∀ i ∈ s, (f i).totalDegree ≤ d)
Goal: (s.sum f).totalDegree ≤ d
-- MvPolynomial.degreeOf_le_totalDegree
lemma degreeOf_le_totalDegree (f : MvPolynomial σ R) (i : σ) : f.degreeOf i ≤ f.totalDegree 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (f : MvPolynomial σ R) (i : σ)
Goal: MvPolynomial.degreeOf i f ≤ f.totalDegree
-- MvPolynomial.exists_degree_lt
theorem exists_degree_lt [Fintype σ] (f : MvPolynomial σ R) (n : ℕ)
    (h : f.totalDegree < n * Fintype.card σ) {d : σ →₀ ℕ} (hd : d ∈ f.support) : ∃ i, d i < n 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] [Fintype σ] (f : MvPolynomial σ R) (n : ℕ) (h : f.totalDegree < n * Fintype.card σ) {d : σ →₀ ℕ} (hd : d ∈ f.support)
Goal: ∃ i, d i < n
-- MvPolynomial.coeff_eq_zero_of_totalDegree_lt
theorem coeff_eq_zero_of_totalDegree_lt {f : MvPolynomial σ R} {d : σ →₀ ℕ}
    (h : f.totalDegree < ∑ i ∈ d.support, d i) : coeff d f = 0 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {f : MvPolynomial σ R} {d : σ →₀ ℕ} (h : f.totalDegree < ∑ i ∈ d.support, d i)
Goal: MvPolynomial.coeff d f = 0
-- MvPolynomial.totalDegree_rename_le
theorem totalDegree_rename_le (f : σ → τ) (p : MvPolynomial σ R) :
    (rename f p).totalDegree ≤ p.totalDegree 
Arguments: {R : Type u} {σ : Type u_1} {τ : Type u_2} [CommSemiring R] (f : σ → τ) (p : MvPolynomial σ R)
Goal: ((MvPolynomial.rename f) p).totalDegree ≤ p.totalDegree
-- NonUnitalStarRingHom.map_star'
structure NonUnitalStarRingHom (A B : Type*) [NonUnitalNonAssocSemiring A]
    [Star A] [NonUnitalNonAssocSemiring B] [Star B] extends A →ₙ+* B where
    map_star' : ∀ a : A, toFun (star a) = star (toFun a)
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (self : A →⋆ₙ+* B) (a : A)
Goal: self.toFun (star a) = star (self.toFun a)
-- NonUnitalStarRingHom.coe_coe
@[simp]
protected theorem coe_coe {F : Type*} [FunLike F A B] [NonUnitalRingHomClass F A B]
    [NonUnitalStarRingHomClass F A B] (f : F) : ⇑(f : A →⋆ₙ+* B) = f 
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] {F : Type u_5} [FunLike F A B] [NonUnitalRingHomClass F A B] [NonUnitalStarRingHomClass F A B] (f : F)
Goal: ⇑↑f = ⇑f
-- NonUnitalStarRingHom.coe_toNonUnitalRingHom
@[simp]
theorem coe_toNonUnitalRingHom (f : A →⋆ₙ+* B) : ⇑f.toNonUnitalRingHom = f 
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (f : A →⋆ₙ+* B)
Goal: ⇑f.toNonUnitalRingHom = ⇑f
-- NonUnitalStarRingHom.ext
@[ext]
theorem ext {f g : A →⋆ₙ+* B} (h : ∀ x, f x = g x) : f = g 
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] {f g : A →⋆ₙ+* B} (h : ∀ (x : A), f x = g x)
Goal: f = g
-- NonUnitalStarRingHom.coe_copy
@[simp]
theorem coe_copy (f : A →⋆ₙ+* B) (f' : A → B) (h : f' = f) : ⇑(f.copy f' h) = f' 
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (f : A →⋆ₙ+* B) (f' : A → B) (h : f' = ⇑f)
Goal: ⇑(f.copy f' h) = f'
-- NonUnitalStarRingHom.copy_eq
theorem copy_eq (f : A →⋆ₙ+* B) (f' : A → B) (h : f' = f) : f.copy f' h = f 
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (f : A →⋆ₙ+* B) (f' : A → B) (h : f' = ⇑f)
Goal: f.copy f' h = f
-- NonUnitalStarRingHom.coe_mk
@[simp]
theorem coe_mk (f : A →ₙ+* B) (h) :
    ((⟨f, h⟩ : A  →⋆ₙ+* B) : A → B) = f 
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (f : A →ₙ+* B) (h : ∀ (a : A), f.toFun (star a) = star (f.toFun a))
Goal: ⇑{ toNonUnitalRingHom := f, map_star' := h } = ⇑f
-- NonUnitalStarRingHom.mk_coe
@[simp]
theorem mk_coe (f : A →⋆ₙ+* B) (h₁ h₂ h₃ h₄) :
    (⟨⟨⟨f, h₁⟩, h₂, h₃⟩, h₄⟩ : A →⋆ₙ+* B) = f 
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (f : A →⋆ₙ+* B) (h₁ : ∀ (x y : A), f (x * y) = f x * f y) (h₂ : { toFun := ⇑f, map_mul' := h₁ }.toFun 0 = 0) (h₃ :
  ∀ (x y : A),
    { toFun := ⇑f, map_mul' := h₁ }.toFun (x + y) =
      { toFun := ⇑f, map_mul' := h₁ }.toFun x + { toFun := ⇑f, map_mul' := h₁ }.toFun y) (h₄ :
  ∀ (a : A),
    { toFun := ⇑f, map_mul' := h₁, map_zero' := h₂, map_add' := h₃ }.toFun (star a) =
      star ({ toFun := ⇑f, map_mul' := h₁, map_zero' := h₂, map_add' := h₃ }.toFun a))
Goal: { toFun := ⇑f, map_mul' := h₁, map_zero' := h₂, map_add' := h₃, map_star' := h₄ } = f
-- NonUnitalStarRingHom.coe_id
@[simp]
theorem coe_id : ⇑(NonUnitalStarRingHom.id A) = id 
Arguments: (A : Type u_1) [NonUnitalNonAssocSemiring A] [Star A]
Goal: ⇑(NonUnitalStarRingHom.id A) = id
-- NonUnitalStarRingHom.coe_comp
@[simp]
theorem coe_comp (f : B →⋆ₙ+* C) (g : A →⋆ₙ+* B) : ⇑(comp f g) = f ∘ g 
Arguments: {A : Type u_1} {B : Type u_2} {C : Type u_3} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] [NonUnitalNonAssocSemiring C] [Star C] (f : B →⋆ₙ+* C) (g : A →⋆ₙ+* B)
Goal: ⇑(f.comp g) = ⇑f ∘ ⇑g
-- NonUnitalStarRingHom.comp_apply
@[simp]
theorem comp_apply (f : B →⋆ₙ+* C) (g : A →⋆ₙ+* B) (a : A) : comp f g a = f (g a) 
Arguments: {A : Type u_1} {B : Type u_2} {C : Type u_3} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] [NonUnitalNonAssocSemiring C] [Star C] (f : B →⋆ₙ+* C) (g : A →⋆ₙ+* B) (a : A)
Goal: (f.comp g) a = f (g a)
-- NonUnitalStarRingHom.comp_assoc
@[simp]
theorem comp_assoc (f : C →⋆ₙ+* D) (g : B →⋆ₙ+* C) (h : A →⋆ₙ+* B) :
    (f.comp g).comp h = f.comp (g.comp h) 
Arguments: {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] [NonUnitalNonAssocSemiring C] [Star C] [NonUnitalNonAssocSemiring D] [Star D] (f : C →⋆ₙ+* D) (g : B →⋆ₙ+* C) (h : A →⋆ₙ+* B)
Goal: (f.comp g).comp h = f.comp (g.comp h)
-- NonUnitalStarRingHom.id_comp
@[simp]
theorem id_comp (f : A →⋆ₙ+* B) : (NonUnitalStarRingHom.id _).comp f = f 
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (f : A →⋆ₙ+* B)
Goal: (NonUnitalStarRingHom.id B).comp f = f
-- NonUnitalStarRingHom.comp_id
@[simp]
theorem comp_id (f : A →⋆ₙ+* B) : f.comp (NonUnitalStarRingHom.id _) = f 
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (f : A →⋆ₙ+* B)
Goal: f.comp (NonUnitalStarRingHom.id A) = f
-- NonUnitalStarRingHom.coe_one
@[simp]
theorem coe_one : ((1 : A →⋆ₙ+* A) : A → A) = id 
Arguments: {A : Type u_1} [NonUnitalNonAssocSemiring A] [Star A]
Goal: ⇑1 = id
-- NonUnitalStarRingHom.one_apply
theorem one_apply (a : A) : (1 : A →⋆ₙ+* A) a = a 
Arguments: {A : Type u_1} [NonUnitalNonAssocSemiring A] [Star A] (a : A)
Goal: 1 a = a
-- NonUnitalStarRingHom.coe_zero
@[simp]
theorem coe_zero : ((0 : A →⋆ₙ+* B) : A → B) = 0 
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [StarAddMonoid A] [NonUnitalNonAssocSemiring B] [StarAddMonoid B]
Goal: ⇑0 = 0
-- NonUnitalStarRingHom.zero_apply
theorem zero_apply (a : A) : (0 : A →⋆ₙ+* B) a = 0 
Arguments: {A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [StarAddMonoid A] [NonUnitalNonAssocSemiring B] [StarAddMonoid B] (a : A)
Goal: 0 a = 0
-- StarRingEquiv.map_star'
structure StarRingEquiv (A B : Type*) [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B]
    extends A ≃+* B where
    map_star' : ∀ a : A, toFun (star a) = star (toFun a)
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (self : A ≃⋆+* B) (a : A)
Goal: self.toFun (star a) = star (self.toFun a)
-- StarRingEquivClass.map_star
class StarRingEquivClass (F : Type*) (A B : outParam Type*)
    [Add A] [Mul A] [Star A] [Add B] [Mul B] [Star B] [EquivLike F A B]
    extends RingEquivClass F A B : Prop where
    map_star : ∀ (f : F) (a : A), f (star a) = star (f a)
Arguments: {F : Type u_1} {A : outParam (Type u_2)} {B : outParam (Type u_3)} [Add A] [Mul A] [Star A] [Add B] [Mul B] [Star B] [EquivLike F A B] [self : StarRingEquivClass F A B] (f : F) (a : A)
Goal: f (star a) = star (f a)
-- StarRingEquiv.toRingEquiv_eq_coe
@[simp]
theorem toRingEquiv_eq_coe (e : A ≃⋆+* B) : e.toRingEquiv = e 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (e : A ≃⋆+* B)
Goal: e.toRingEquiv = ↑e
-- StarRingEquiv.ext
@[ext]
theorem ext {f g : A ≃⋆+* B} (h : ∀ a, f a = g a) : f = g 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] {f g : A ≃⋆+* B} (h : ∀ (a : A), f a = g a)
Goal: f = g
-- StarRingEquiv.ext_iff
theorem ext_iff {f g : A ≃⋆+* B} : f = g ↔ ∀ a, f a = g a 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] {f g : A ≃⋆+* B}
Goal: f = g ↔ ∀ (a : A), f a = g a
-- StarRingEquiv.coe_refl
@[simp]
theorem coe_refl : ⇑(refl : A ≃⋆+* A) = id 
Arguments: {A : Type u_1} [Add A] [Mul A] [Star A]
Goal: ⇑StarRingEquiv.refl = id
-- StarRingEquiv.invFun_eq_symm
@[simp]
theorem invFun_eq_symm {e : A ≃⋆+* B} : EquivLike.inv e = e.symm 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] {e : A ≃⋆+* B}
Goal: EquivLike.inv e = ⇑e.symm
-- StarRingEquiv.symm_symm
@[simp]
theorem symm_symm (e : A ≃⋆+* B) : e.symm.symm = e 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (e : A ≃⋆+* B)
Goal: e.symm.symm = e
-- StarRingEquiv.symm_bijective
theorem symm_bijective : Function.Bijective (symm : (A ≃⋆+* B) → B ≃⋆+* A) 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B]
Goal: Function.Bijective StarRingEquiv.symm
-- StarRingEquiv.coe_mk
theorem coe_mk (e h₁) : ⇑(⟨e, h₁⟩ : A ≃⋆+* B) = e 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (e : A ≃+* B) (h₁ : ∀ (a : A), e.toFun (star a) = star (e.toFun a))
Goal: ⇑{ toRingEquiv := e, map_star' := h₁ } = ⇑e
-- StarRingEquiv.mk_coe
@[simp]
theorem mk_coe (e : A ≃⋆+* B) (e' h₁ h₂ h₃ h₄ h₅) :
    (⟨⟨⟨e, e', h₁, h₂⟩, h₃, h₄⟩, h₅⟩ : A ≃⋆+* B) = e 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (e : A ≃⋆+* B) (e' : B → A) (h₁ : Function.LeftInverse e' ⇑e) (h₂ : Function.RightInverse e' ⇑e) (h₃ :
  ∀ (x y : A),
    { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun (x * y) =
      { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun x *
        { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun y) (h₄ :
  ∀ (x y : A),
    { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun (x + y) =
      { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun x +
        { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun y) (h₅ :
  ∀ (a : A),
    { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄ }.toFun (star a) =
      star ({ toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄ }.toFun a))
Goal: { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄, map_star' := h₅ } = e
-- StarRingEquiv.symm_mk
@[simp]
theorem symm_mk (f f') (h₁ h₂ h₃ h₄ h₅) :
    (⟨⟨⟨f, f', h₁, h₂⟩, h₃, h₄⟩, h₅⟩ : A ≃⋆+* B).symm =
      { symm_mk.aux f f' h₁ h₂ h₃ h₄ h₅ with
        toFun := f'
        invFun := f } 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (f : A → B) (f' : B → A) (h₁ : Function.LeftInverse f' f) (h₂ : Function.RightInverse f' f) (h₃ :
  ∀ (x y : A),
    { toFun := f, invFun := f', left_inv := h₁, right_inv := h₂ }.toFun (x * y) =
      { toFun := f, invFun := f', left_inv := h₁, right_inv := h₂ }.toFun x *
        { toFun := f, invFun := f', left_inv := h₁, right_inv := h₂ }.toFun y) (h₄ :
  ∀ (x y : A),
    { toFun := f, invFun := f', left_inv := h₁, right_inv := h₂ }.toFun (x + y) =
      { toFun := f, invFun := f', left_inv := h₁, right_inv := h₂ }.toFun x +
        { toFun := f, invFun := f', left_inv := h₁, right_inv := h₂ }.toFun y) (h₅ :
  ∀ (a : A),
    { toFun := f, invFun := f', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄ }.toFun (star a) =
      star ({ toFun := f, invFun := f', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄ }.toFun a))
Goal: { toFun := f, invFun := f', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄, map_star' := h₅ }.symm =
  let __src := StarRingEquiv.symm_mk.aux f f' h₁ h₂ h₃ h₄ h₅;
  { toFun := f', invFun := f, left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯, map_add' := ⋯, map_star' := ⋯ }
-- StarRingEquiv.refl_symm
@[simp]
theorem refl_symm : (StarRingEquiv.refl : A ≃⋆+* A).symm = StarRingEquiv.refl 
Arguments: {A : Type u_1} [Add A] [Mul A] [Star A]
Goal: StarRingEquiv.refl.symm = StarRingEquiv.refl
-- StarRingEquiv.apply_symm_apply
@[simp]
theorem apply_symm_apply (e : A ≃⋆+* B) : ∀ x, e (e.symm x) = x 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (e : A ≃⋆+* B) (x : B)
Goal: e (e.symm x) = x
-- StarRingEquiv.symm_apply_apply
@[simp]
theorem symm_apply_apply (e : A ≃⋆+* B) : ∀ x, e.symm (e x) = x 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (e : A ≃⋆+* B) (x : A)
Goal: e.symm (e x) = x
-- StarRingEquiv.symm_trans_apply
@[simp]
theorem symm_trans_apply (e₁ : A ≃⋆+* B) (e₂ : B≃⋆+* C) (x : C) :
    (e₁.trans e₂).symm x = e₁.symm (e₂.symm x) 
Arguments: {A : Type u_1} {B : Type u_2} {C : Type u_3} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] [Add C] [Mul C] [Star C] (e₁ : A ≃⋆+* B) (e₂ : B ≃⋆+* C) (x : C)
Goal: (e₁.trans e₂).symm x = e₁.symm (e₂.symm x)
-- StarRingEquiv.coe_trans
@[simp]
theorem coe_trans (e₁ : A ≃⋆+* B) (e₂ : B ≃⋆+* C) : ⇑(e₁.trans e₂) = e₂ ∘ e₁ 
Arguments: {A : Type u_1} {B : Type u_2} {C : Type u_3} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] [Add C] [Mul C] [Star C] (e₁ : A ≃⋆+* B) (e₂ : B ≃⋆+* C)
Goal: ⇑(e₁.trans e₂) = ⇑e₂ ∘ ⇑e₁