ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/MvPolynomial/Counit.lean

full_name: MvPolynomial.ACounit
code: /-- `MvPolynomial.ACounit A B` is the natural surjective algebra homomorphism
`MvPolynomial B A →ₐ[A] B` obtained by `X a ↦ a`.

See `MvPolynomial.counit` for the “absolute” variant with `A = ℤ`,
and `MvPolynomial.counitNat` for the “absolute” variant with `A = ℕ`. -/
noncomputable def ACounit : MvPolynomial B A →ₐ[A] B 
goal: MvPolynomial B A →ₐ[A] B

full_name: MvPolynomial.ACounit_X
code: @[simp]
theorem ACounit_X (b : B) : ACounit A B (X b) = b 
goal: (MvPolynomial.ACounit A B) (MvPolynomial.X b) = b

full_name: MvPolynomial.ACounit_C
code: theorem ACounit_C (a : A) : ACounit A B (C a) = algebraMap A B a 
goal: (MvPolynomial.ACounit A B) (MvPolynomial.C a) = (algebraMap A B) a

full_name: MvPolynomial.ACounit_surjective
code: theorem ACounit_surjective : Surjective (ACounit A B) 
goal: Function.Surjective ⇑(MvPolynomial.ACounit A B)

full_name: MvPolynomial.counit
code: /-- `MvPolynomial.counit R` is the natural surjective ring homomorphism
`MvPolynomial R ℤ →+* R` obtained by `X r ↦ r`.

See `MvPolynomial.ACounit` for a “relative” variant for algebras over a base ring,
and `MvPolynomial.counitNat` for the “absolute” variant with `R = ℕ`. -/
noncomputable def counit : MvPolynomial R ℤ →+* R 
goal: MvPolynomial R ℤ →+* R

full_name: MvPolynomial.counitNat
code: /-- `MvPolynomial.counitNat A` is the natural surjective ring homomorphism
`MvPolynomial A ℕ →+* A` obtained by `X a ↦ a`.

See `MvPolynomial.ACounit` for a “relative” variant for algebras over a base ring
and `MvPolynomial.counit` for the “absolute” variant with `A = ℤ`. -/
noncomputable def counitNat : MvPolynomial A ℕ →+* A 
goal: MvPolynomial A ℕ →+* A

full_name: MvPolynomial.counit_surjective
code: theorem counit_surjective : Surjective (counit R) 
goal: Function.Surjective ⇑(MvPolynomial.counit R)

full_name: MvPolynomial.counitNat_surjective
code: theorem counitNat_surjective : Surjective (counitNat A) 
goal: Function.Surjective ⇑(MvPolynomial.counitNat A)

full_name: MvPolynomial.counit_C
code: theorem counit_C (n : ℤ) : counit R (C n) = n 
goal: (MvPolynomial.counit R) (MvPolynomial.C n) = ↑n

full_name: MvPolynomial.counitNat_C
code: theorem counitNat_C (n : ℕ) : counitNat A (C n) = n 
goal: (MvPolynomial.counitNat A) (MvPolynomial.C n) = ↑n

full_name: MvPolynomial.counit_X
code: @[simp]
theorem counit_X (r : R) : counit R (X r) = r 
goal: (MvPolynomial.counit R) (MvPolynomial.X r) = r

full_name: MvPolynomial.counitNat_X
code: @[simp]
theorem counitNat_X (a : A) : counitNat A (X a) = a 
goal: (MvPolynomial.counitNat A) (MvPolynomial.X a) = a
File: Mathlib/Algebra/MvPolynomial/Cardinal.lean

full_name: MvPolynomial.cardinal_mk_eq_max_lift
code: @[simp]
theorem cardinal_mk_eq_max_lift [Nonempty σ] [Nontrivial R] :
    #(MvPolynomial σ R) = max (max (Cardinal.lift.{u} #R) <| Cardinal.lift.{v} #σ) ℵ₀ 
goal: #(MvPolynomial σ R) = max (max (Cardinal.lift.{u, v} #R) (Cardinal.lift.{v, u} #σ)) ℵ₀

full_name: MvPolynomial.cardinal_mk_eq_lift
code: @[simp]
theorem cardinal_mk_eq_lift [IsEmpty σ] : #(MvPolynomial σ R) = Cardinal.lift.{u} #R 
goal: #(MvPolynomial σ R) = Cardinal.lift.{u, v} #R

full_name: MvPolynomial.cardinal_lift_mk_le_max
code: theorem cardinal_lift_mk_le_max {σ : Type u} {R : Type v} [CommSemiring R] : #(MvPolynomial σ R) ≤
    max (max (Cardinal.lift.{u} #R) <| Cardinal.lift.{v} #σ) ℵ₀ 
goal: #(MvPolynomial σ R) ≤ max (max (Cardinal.lift.{u, v} #R) (Cardinal.lift.{v, u} #σ)) ℵ₀

full_name: MvPolynomial.cardinal_mk_eq_max
code: theorem cardinal_mk_eq_max [Nonempty σ] [Nontrivial R] :
    #(MvPolynomial σ R) = max (max #R #σ) ℵ₀ 
goal: #(MvPolynomial σ R) = max (max #R #σ) ℵ₀

full_name: MvPolynomial.cardinal_mk_le_max
code: /-- The cardinality of the multivariate polynomial ring, `MvPolynomial σ R` is at most the maximum
of `#R`, `#σ` and `ℵ₀` -/
theorem cardinal_mk_le_max : #(MvPolynomial σ R) ≤ max (max #R #σ) ℵ₀ 
goal: #(MvPolynomial σ R) ≤ max (max #R #σ) ℵ₀
File: Mathlib/Algebra/MvPolynomial/Invertible.lean

full_name: MvPolynomial.invertibleC
code: noncomputable instance MvPolynomial.invertibleC (σ : Type*) {R : Type*} [CommSemiring R] (r : R)
    [Invertible r] : Invertible (C r : MvPolynomial σ R) 
goal: Invertible (MvPolynomial.C r)

full_name: MvPolynomial.invertibleCoeNat
code: /-- A natural number that is invertible when coerced to a commutative semiring `R`
is also invertible when coerced to any polynomial ring with rational coefficients.

Short-cut for typeclass resolution. -/
noncomputable instance MvPolynomial.invertibleCoeNat (σ R : Type*) (p : ℕ) [CommSemiring R]
    [Invertible (p : R)] : Invertible (p : MvPolynomial σ R) 
goal: Invertible ↑p
File: Mathlib/Algebra/MvPolynomial/Polynomial.lean

full_name: MvPolynomial.polynomial_eval_eval₂
code: theorem polynomial_eval_eval₂ [CommSemiring R] [CommSemiring S]
    {x : S} (f : R →+* Polynomial S) (g : σ → Polynomial S) (p : MvPolynomial σ R) :
    Polynomial.eval x (eval₂ f g p) =
      eval₂ ((Polynomial.evalRingHom x).comp f) (fun s => Polynomial.eval x (g s)) p 
goal: Polynomial.eval x (MvPolynomial.eval₂ f g p) =
  MvPolynomial.eval₂ ((Polynomial.evalRingHom x).comp f) (fun s => Polynomial.eval x (g s)) p

full_name: MvPolynomial.eval_polynomial_eval_finSuccEquiv
code: theorem eval_polynomial_eval_finSuccEquiv {n : ℕ} {x : Fin n → R}
    [CommSemiring R] (f : MvPolynomial (Fin (n + 1)) R) (q : MvPolynomial (Fin n) R) :
    (eval x) (Polynomial.eval q (finSuccEquiv R n f)) = eval (Fin.cases (eval x q) x) f 
goal: (MvPolynomial.eval x) (Polynomial.eval q ((MvPolynomial.finSuccEquiv R n) f)) =
  (MvPolynomial.eval fun i => Fin.cases ((MvPolynomial.eval x) q) x i) f
File: Mathlib/Algebra/MvPolynomial/Expand.lean

full_name: MvPolynomial.expand
code: /-- Expand the polynomial by a factor of p, so `∑ aₙ xⁿ` becomes `∑ aₙ xⁿᵖ`.

See also `Polynomial.expand`. -/
noncomputable def expand (p : ℕ) : MvPolynomial σ R →ₐ[R] MvPolynomial σ R 
goal: MvPolynomial σ R →ₐ[R] MvPolynomial σ R

full_name: MvPolynomial.expand_C
code: theorem expand_C (p : ℕ) (r : R) : expand p (C r : MvPolynomial σ R) = C r 
goal: (MvPolynomial.expand p) (MvPolynomial.C r) = MvPolynomial.C r

full_name: MvPolynomial.expand_X
code: @[simp]
theorem expand_X (p : ℕ) (i : σ) : expand p (X i : MvPolynomial σ R) = X i ^ p 
goal: (MvPolynomial.expand p) (MvPolynomial.X i) = MvPolynomial.X i ^ p

full_name: MvPolynomial.expand_monomial
code: @[simp]
theorem expand_monomial (p : ℕ) (d : σ →₀ ℕ) (r : R) :
    expand p (monomial d r) = C r * ∏ i ∈ d.support, (X i ^ p) ^ d i 
goal: (MvPolynomial.expand p) ((MvPolynomial.monomial d) r) = MvPolynomial.C r * ∏ i ∈ d.support, (MvPolynomial.X i ^ p) ^ d i

full_name: MvPolynomial.expand_one_apply
code: theorem expand_one_apply (f : MvPolynomial σ R) : expand 1 f = f 
goal: (MvPolynomial.expand 1) f = f

full_name: MvPolynomial.expand_one
code: @[simp]
theorem expand_one : expand 1 = AlgHom.id R (MvPolynomial σ R) 
goal: MvPolynomial.expand 1 = AlgHom.id R (MvPolynomial σ R)

full_name: MvPolynomial.expand_comp_bind₁
code: theorem expand_comp_bind₁ (p : ℕ) (f : σ → MvPolynomial τ R) :
    (expand p).comp (bind₁ f) = bind₁ fun i ↦ expand p (f i) 
goal: (MvPolynomial.expand p).comp (MvPolynomial.bind₁ f) = MvPolynomial.bind₁ fun i => (MvPolynomial.expand p) (f i)

full_name: MvPolynomial.expand_bind₁
code: theorem expand_bind₁ (p : ℕ) (f : σ → MvPolynomial τ R) (φ : MvPolynomial σ R) :
    expand p (bind₁ f φ) = bind₁ (fun i ↦ expand p (f i)) φ 
goal: (MvPolynomial.expand p) ((MvPolynomial.bind₁ f) φ) = (MvPolynomial.bind₁ fun i => (MvPolynomial.expand p) (f i)) φ

full_name: MvPolynomial.map_expand
code: @[simp]
theorem map_expand (f : R →+* S) (p : ℕ) (φ : MvPolynomial σ R) :
    map f (expand p φ) = expand p (map f φ) 
goal: (MvPolynomial.map f) ((MvPolynomial.expand p) φ) = (MvPolynomial.expand p) ((MvPolynomial.map f) φ)

full_name: MvPolynomial.rename_expand
code: @[simp]
theorem rename_expand (f : σ → τ) (p : ℕ) (φ : MvPolynomial σ R) :
    rename f (expand p φ) = expand p (rename f φ) 
goal: (MvPolynomial.rename f) ((MvPolynomial.expand p) φ) = (MvPolynomial.expand p) ((MvPolynomial.rename f) φ)

full_name: MvPolynomial.rename_comp_expand
code: @[simp]
theorem rename_comp_expand (f : σ → τ) (p : ℕ) :
    (rename f).comp (expand p) =
      (expand p).comp (rename f : MvPolynomial σ R →ₐ[R] MvPolynomial τ R) 
goal: (MvPolynomial.rename f).comp (MvPolynomial.expand p) = (MvPolynomial.expand p).comp (MvPolynomial.rename f)
File: Mathlib/Algebra/FreeMonoid/Count.lean

full_name: FreeAddMonoid.countP
code: /-- `List.countP` as a bundled additive monoid homomorphism. -/
def countP : FreeAddMonoid α →+ ℕ 
goal: FreeAddMonoid α →+ ℕ

full_name: FreeAddMonoid.countP_of
code: theorem countP_of (x : α) : countP p (of x) = if p x = true then 1 else 0 
goal: (FreeAddMonoid.countP p) (FreeAddMonoid.of x) = if p x = (true = true) then 1 else 0

full_name: FreeAddMonoid.countP_apply
code: theorem countP_apply (l : FreeAddMonoid α) : countP p l = List.countP p l 
goal: (FreeAddMonoid.countP p) l = List.countP (fun b => decide (p b)) l

full_name: FreeAddMonoid.count
code: /-- `List.count` as a bundled additive monoid homomorphism. -/
-- Porting note: was (x = ·)
def count [DecidableEq α] (x : α) : FreeAddMonoid α →+ ℕ 
goal: FreeAddMonoid α →+ ℕ

full_name: FreeAddMonoid.count_of
code: theorem count_of [DecidableEq α] (x y : α) : count x (of y) = (Pi.single x 1 : α → ℕ) y 
goal: (FreeAddMonoid.count x) (FreeAddMonoid.of y) = Pi.single x 1 y

full_name: FreeAddMonoid.count_apply
code: theorem count_apply [DecidableEq α] (x : α) (l : FreeAddMonoid α) : count x l = List.count x l 
goal: (FreeAddMonoid.count x) l = List.count x l

full_name: FreeMonoid.countP
code: /-- `List.countP` as a bundled multiplicative monoid homomorphism. -/
def countP : FreeMonoid α →* Multiplicative ℕ 
goal: FreeMonoid α →* Multiplicative ℕ

full_name: FreeMonoid.countP_of'
code: theorem countP_of' (x : α) :
    countP p (of x) = if p x then Multiplicative.ofAdd 1 else Multiplicative.ofAdd 0 
goal: (FreeMonoid.countP p) (FreeMonoid.of x) = if p x then Multiplicative.ofAdd 1 else Multiplicative.ofAdd 0

full_name: FreeMonoid.countP_of
code: theorem countP_of (x : α) : countP p (of x) = if p x then Multiplicative.ofAdd 1 else 1 
goal: (FreeMonoid.countP p) (FreeMonoid.of x) = if p x then Multiplicative.ofAdd 1 else 1

full_name: FreeMonoid.countP_apply
code: theorem countP_apply (l : FreeAddMonoid α) : countP p l = Multiplicative.ofAdd (List.countP p l) 
goal: (FreeMonoid.countP p) l = Multiplicative.ofAdd (List.countP (fun b => decide (p b)) l)

full_name: FreeMonoid.count
code: /-- `List.count` as a bundled additive monoid homomorphism. -/
def count [DecidableEq α] (x : α) : FreeMonoid α →* Multiplicative ℕ 
goal: FreeMonoid α →* Multiplicative ℕ

full_name: FreeMonoid.count_apply
code: theorem count_apply [DecidableEq α] (x : α) (l : FreeAddMonoid α) :
    count x l = Multiplicative.ofAdd (List.count x l) 
goal: (FreeMonoid.count x) l = Multiplicative.ofAdd (List.count x l)

full_name: FreeMonoid.count_of
code: theorem count_of [DecidableEq α] (x y : α) :
    count x (of y) = @Pi.mulSingle α (fun _ => Multiplicative ℕ) _ _ x (Multiplicative.ofAdd 1) y 
goal: (FreeMonoid.count x) (FreeMonoid.of y) = Pi.mulSingle x (Multiplicative.ofAdd 1) y
File: Mathlib/Algebra/Star/BigOperators.lean

full_name: star_prod
code: @[simp]
theorem star_prod [CommMonoid R] [StarMul R] {α : Type*} (s : Finset α) (f : α → R) :
    star (∏ x ∈ s, f x) = ∏ x ∈ s, star (f x) 
goal: star (∏ x ∈ s, f x) = ∏ x ∈ s, star (f x)

full_name: star_sum
code: @[simp]
theorem star_sum [AddCommMonoid R] [StarAddMonoid R] {α : Type*} (s : Finset α) (f : α → R) :
    star (∑ x ∈ s, f x) = ∑ x ∈ s, star (f x) 
goal: star (∑ x ∈ s, f x) = ∑ x ∈ s, star (f x)
File: Mathlib/Algebra/Star/Rat.lean

full_name: Rat.instStarRing
code: instance Rat.instStarRing : StarRing ℚ 
goal: StarRing ℚ

full_name: NNRat.instStarRing
code: instance NNRat.instStarRing : StarRing ℚ≥0 
goal: StarRing ℚ≥0

full_name: Rat.instTrivialStar
code: instance Rat.instTrivialStar : TrivialStar ℚ 
goal: TrivialStar ℚ

full_name: NNRat.instTrivialStar
code: instance NNRat.instTrivialStar : TrivialStar ℚ≥0 
goal: TrivialStar ℚ≥0

full_name: star_nnratCast
code: @[simp, norm_cast]
lemma star_nnratCast [DivisionSemiring R] [StarRing R] (q : ℚ≥0) : star (q : R) = q 
goal: star ↑q = ↑q

full_name: star_ratCast
code: @[simp, norm_cast]
theorem star_ratCast [DivisionRing R] [StarRing R] (r : ℚ) : star (r : R) = r 
goal: star ↑r = ↑r
File: Mathlib/Algebra/Star/Center.lean

full_name: Set.star_mem_center
code: theorem Set.star_mem_center (ha : a ∈ Set.center R) : star a ∈ Set.center R 
goal: star a ∈ Set.center R

full_name: Set.star_mem_centralizer'
code: theorem Set.star_mem_centralizer' (h : ∀ a : R, a ∈ s → star a ∈ s) (ha : a ∈ Set.centralizer s) :
    star a ∈ Set.centralizer s 
goal: star a ∈ s.centralizer

full_name: Set.star_mem_centralizer
code: theorem Set.star_mem_centralizer (ha : a ∈ Set.centralizer (s ∪ star s)) :
    star a ∈ Set.centralizer (s ∪ star s) 
goal: star a ∈ (s ∪ star s).centralizer
File: Mathlib/Algebra/Star/Pi.lean

full_name: Pi.instStarForall
code: instance [∀ i, Star (f i)] : Star (∀ i, f i) 
goal: Star ((i : I) → f i)

full_name: Pi.star_apply
code: @[simp]
theorem star_apply [∀ i, Star (f i)] (x : ∀ i, f i) (i : I) : star x i = star (x i) 
goal: star x i = star (x i)

full_name: Pi.star_def
code: theorem star_def [∀ i, Star (f i)] (x : ∀ i, f i) : star x = fun i => star (x i) 
goal: star x = fun i => star (x i)

full_name: Pi.instTrivialStarForall
code: instance [∀ i, Star (f i)] [∀ i, TrivialStar (f i)] : TrivialStar (∀ i, f i) 
goal: TrivialStar ((i : I) → f i)

full_name: Pi.instInvolutiveStarForall
code: instance [∀ i, InvolutiveStar (f i)] : InvolutiveStar (∀ i, f i) 
goal: InvolutiveStar ((i : I) → f i)

full_name: Pi.instStarMulForall
code: instance [∀ i, Mul (f i)] [∀ i, StarMul (f i)] : StarMul (∀ i, f i) 
goal: StarMul ((i : I) → f i)

full_name: Pi.instStarAddMonoidForall
code: instance [∀ i, AddMonoid (f i)] [∀ i, StarAddMonoid (f i)] : StarAddMonoid (∀ i, f i) 
goal: StarAddMonoid ((i : I) → f i)

full_name: Pi.instStarRingForall
code: instance [∀ i, NonUnitalSemiring (f i)] [∀ i, StarRing (f i)] : StarRing (∀ i, f i)
  
goal: StarRing ((i : I) → f i)

full_name: Pi.instStarModuleForall
code: instance {R : Type w} [∀ i, SMul R (f i)] [Star R] [∀ i, Star (f i)]
    [∀ i, StarModule R (f i)] : StarModule R (∀ i, f i) 
goal: StarModule R ((i : I) → f i)

full_name: Pi.single_star
code: theorem single_star [∀ i, AddMonoid (f i)] [∀ i, StarAddMonoid (f i)] [DecidableEq I] (i : I)
    (a : f i) : Pi.single i (star a) = star (Pi.single i a) 
goal: Pi.single i (star a) = star (Pi.single i a)

full_name: Pi.conj_apply
code: @[simp]
lemma conj_apply {ι : Type*} {α : ι → Type*} [∀ i, CommSemiring (α i)] [∀ i, StarRing (α i)]
    (f : ∀ i, α i) (i : ι) : conj f i = conj (f i) 
goal: (starRingEnd ((i : ι) → α i)) f i = (starRingEnd (α i)) (f i)

full_name: Function.update_star
code: theorem update_star [∀ i, Star (f i)] [DecidableEq I] (h : ∀ i : I, f i) (i : I) (a : f i) :
    Function.update (star h) i (star a) = star (Function.update h i a) 
goal: Function.update (star h) i (star a) = star (Function.update h i a)

full_name: Function.star_sum_elim
code: theorem star_sum_elim {I J α : Type*} (x : I → α) (y : J → α) [Star α] :
    star (Sum.elim x y) = Sum.elim (star x) (star y) 
goal: star (Sum.elim x y) = Sum.elim (star x) (star y)
File: Mathlib/Algebra/Star/Prod.lean

full_name: Prod.instStar
code: instance [Star R] [Star S] : Star (R × S) 
goal: Star (R × S)

full_name: Prod.fst_star
code: @[simp]
theorem fst_star [Star R] [Star S] (x : R × S) : (star x).1 = star x.1 
goal: (star x).1 = star x.1

full_name: Prod.snd_star
code: @[simp]
theorem snd_star [Star R] [Star S] (x : R × S) : (star x).2 = star x.2 
goal: (star x).2 = star x.2

full_name: Prod.star_def
code: theorem star_def [Star R] [Star S] (x : R × S) : star x = (star x.1, star x.2) 
goal: star x = (star x.1, star x.2)

full_name: Prod.instTrivialStar
code: instance [Star R] [Star S] [TrivialStar R] [TrivialStar S] : TrivialStar (R × S) 
goal: TrivialStar (R × S)

full_name: Prod.instInvolutiveStar
code: instance [InvolutiveStar R] [InvolutiveStar S] : InvolutiveStar (R × S) 
goal: InvolutiveStar (R × S)

full_name: Prod.instStarMul
code: instance [Mul R] [Mul S] [StarMul R] [StarMul S] : StarMul (R × S) 
goal: StarMul (R × S)

full_name: Prod.instStarAddMonoid
code: instance [AddMonoid R] [AddMonoid S] [StarAddMonoid R] [StarAddMonoid S] :
    StarAddMonoid (R × S) 
goal: StarAddMonoid (R × S)

full_name: Prod.instStarRing
code: instance [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S] [StarRing R] [StarRing S] :
    StarRing (R × S) 
goal: StarRing (R × S)

full_name: Prod.instStarModule
code: instance {α : Type w} [SMul α R] [SMul α S] [Star α] [Star R] [Star S]
    [StarModule α R] [StarModule α S] : StarModule α (R × S) 
goal: StarModule α (R × S)

full_name: Units.embed_product_star
code: theorem Units.embed_product_star [Monoid R] [StarMul R] (u : Rˣ) :
    Units.embedProduct R (star u) = star (Units.embedProduct R u) 
goal: (Units.embedProduct R) (star u) = star ((Units.embedProduct R) u)
File: Mathlib/Algebra/Star/RingQuot.lean

full_name: RingQuot.Rel.star
code: theorem Rel.star (hr : ∀ a b, r a b → r (star a) (star b))
    ⦃a b : R⦄ (h : Rel r a b) : Rel r (star a) (star b) 
goal: RingQuot.Rel r (star a) (star b)

full_name: RingQuot.wrapped._@.Mathlib.Algebra.Star.RingQuot._hyg.234
code: private irreducible_def star' (hr : ∀ a b, r a b → r (star a) (star b)) : RingQuot r → RingQuot r
  
goal: Subtype (Eq @RingQuot.definition✝)

full_name: _private.Mathlib.Algebra.Star.RingQuot.0.RingQuot.star'
code: private irreducible_def star' (hr : ∀ a b, r a b → r (star a) (star b)) : RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r

full_name: _private.Mathlib.Algebra.Star.RingQuot.0.RingQuot.star'_def
code: private irreducible_def star' (hr : ∀ a b, r a b → r (star a) (star b)) : RingQuot r → RingQuot r
  
goal: ∀ (x : RingQuot r),
  RingQuot.star' r hr x =
    match x with
    | { toQuot := a } => { toQuot := Quot.map star ⋯ a }

full_name: RingQuot.definition._@.Mathlib.Algebra.Star.RingQuot._hyg.234
code: private irreducible_def star' (hr : ∀ a b, r a b → r (star a) (star b)) : RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r

full_name: RingQuot.star'_quot
code: theorem star'_quot (hr : ∀ a b, r a b → r (star a) (star b)) {a} :
    (star' r hr ⟨Quot.mk _ a⟩ : RingQuot r) = ⟨Quot.mk _ (star a)⟩ 
goal: RingQuot.star' r hr { toQuot := Quot.mk (RingQuot.Rel r) a } = { toQuot := Quot.mk (RingQuot.Rel r) (star a) }

full_name: RingQuot.starRing
code: /-- Transfer a star_ring instance through a quotient, if the quotient is invariant to `star` -/
def starRing {R : Type u} [Semiring R] [StarRing R] (r : R → R → Prop)
    (hr : ∀ a b, r a b → r (star a) (star b)) : StarRing (RingQuot r) 
goal: StarRing (RingQuot r)
File: Mathlib/Algebra/Star/Free.lean

full_name: FreeMonoid.instStarMul
code: instance : StarMul (FreeMonoid α) 
goal: StarMul (FreeMonoid α)

full_name: FreeMonoid.star_of
code: @[simp]
theorem star_of (x : α) : star (of x) = of x 
goal: star (FreeMonoid.of x) = FreeMonoid.of x

full_name: FreeMonoid.star_one
code: /-- Note that `star_one` is already a global simp lemma, but this one works with dsimp too -/
@[simp]
theorem star_one : star (1 : FreeMonoid α) = 1 
goal: star 1 = 1

full_name: FreeAlgebra.instStarRing
code: /-- The star ring formed by reversing the elements of products -/
instance : StarRing (FreeAlgebra R X) 
goal: StarRing (FreeAlgebra R X)

full_name: FreeAlgebra.star_ι
code: @[simp]
theorem star_ι (x : X) : star (ι R x) = ι R x 
goal: star (FreeAlgebra.ι R x) = FreeAlgebra.ι R x

full_name: FreeAlgebra.star_algebraMap
code: @[simp]
theorem star_algebraMap (r : R) : star (algebraMap R (FreeAlgebra R X) r) = algebraMap R _ r 
goal: star ((algebraMap R (FreeAlgebra R X)) r) = (algebraMap R (FreeAlgebra R X)) r

full_name: FreeAlgebra.starHom
code: /-- `star` as an `AlgEquiv` -/
def starHom : FreeAlgebra R X ≃ₐ[R] (FreeAlgebra R X)ᵐᵒᵖ 
goal: FreeAlgebra R X ≃ₐ[R] (FreeAlgebra R X)ᵐᵒᵖ
File: Mathlib/Algebra/CharZero/Infinite.lean

full_name: CharZero.infinite
code: instance (priority := 100) CharZero.infinite : Infinite M 
goal: Infinite M
File: Mathlib/Algebra/CharZero/Lemmas.lean

full_name: Nat.castEmbedding_apply
code: /-- `Nat.cast` as an embedding into monoids of characteristic `0`. -/
@[simps]
def castEmbedding : ℕ ↪ R 
goal: ∀ (a : ℕ), Nat.castEmbedding a = ↑a

full_name: Nat.castEmbedding
code: /-- `Nat.cast` as an embedding into monoids of characteristic `0`. -/
@[simps]
def castEmbedding : ℕ ↪ R 
goal: ℕ ↪ R

full_name: Nat.cast_pow_eq_one
code: @[simp]
theorem cast_pow_eq_one {R : Type*} [Semiring R] [CharZero R] (q : ℕ) (n : ℕ) (hn : n ≠ 0) :
    (q : R) ^ n = 1 ↔ q = 1 
goal: ↑q ^ n = 1 ↔ q = 1

full_name: Nat.cast_div_charZero
code: @[simp, norm_cast]
theorem cast_div_charZero {k : Type*} [DivisionSemiring k] [CharZero k] {m n : ℕ} (n_dvd : n ∣ m) :
    ((m / n : ℕ) : k) = m / n 
goal: ↑(m / n) = ↑m / ↑n

full_name: CharZero.NeZero.two
code: instance CharZero.NeZero.two : NeZero (2 : M) 
goal: NeZero 2

full_name: Function.support_natCast
code: lemma support_natCast (hn : n ≠ 0) : support (n : α → M) = univ 
goal: Function.support ↑n = Set.univ

full_name: Function.mulSupport_natCast
code: lemma mulSupport_natCast (hn : n ≠ 1) : mulSupport (n : α → M) = univ 
goal: Function.mulSupport ↑n = Set.univ

full_name: add_self_eq_zero
code: @[simp]
theorem add_self_eq_zero {a : R} : a + a = 0 ↔ a = 0 
goal: a + a = 0 ↔ a = 0

full_name: neg_eq_self_iff
code: @[simp] theorem neg_eq_self_iff {a : R} : -a = a ↔ a = 0 
goal: -a = a ↔ a = 0

full_name: eq_neg_self_iff
code: @[simp] theorem eq_neg_self_iff {a : R} : a = -a ↔ a = 0 
goal: a = -a ↔ a = 0

full_name: nat_mul_inj
code: theorem nat_mul_inj {n : ℕ} {a b : R} (h : (n : R) * a = (n : R) * b) : n = 0 ∨ a = b 
goal: n = 0 ∨ a = b

full_name: nat_mul_inj'
code: theorem nat_mul_inj' {n : ℕ} {a b : R} (h : (n : R) * a = (n : R) * b) (w : n ≠ 0) : a = b 
goal: a = b

full_name: add_self_div_two
code: @[simp] lemma add_self_div_two (a : R) : (a + a) / 2 = a 
goal: (a + a) / 2 = a

full_name: add_halves
code: @[simp]
theorem add_halves (a : R) : a / 2 + a / 2 = a 
goal: a / 2 + a / 2 = a

full_name: sub_half
code: theorem sub_half (a : R) : a - a / 2 = a / 2 
goal: a - a / 2 = a / 2

full_name: half_sub
code: theorem half_sub (a : R) : a / 2 - a = -(a / 2) 
goal: a / 2 - a = -(a / 2)

full_name: WithTop.instCharZero
code: instance {R : Type*} [AddMonoidWithOne R] [CharZero R] :
    CharZero (WithTop R) 
goal: CharZero (WithTop R)

full_name: WithBot.instCharZero
code: instance {R : Type*} [AddMonoidWithOne R] [CharZero R] :
    CharZero (WithBot R) 
goal: CharZero (WithBot R)

full_name: RingHom.charZero
code: theorem RingHom.charZero (ϕ : R →+* S) [CharZero S] : CharZero R 
goal: CharZero R

full_name: RingHom.charZero_iff
code: theorem RingHom.charZero_iff {ϕ : R →+* S} (hϕ : Function.Injective ϕ) : CharZero R ↔ CharZero S 
goal: CharZero R ↔ CharZero S

full_name: RingHom.injective_nat
code: theorem RingHom.injective_nat (f : ℕ →+* R) [CharZero R] : Function.Injective f 
goal: Function.Injective ⇑f

full_name: units_ne_neg_self
code: @[simp]
theorem units_ne_neg_self (u : Rˣ) : u ≠ -u 
goal: u ≠ -u

full_name: neg_units_ne_self
code: @[simp]
theorem neg_units_ne_self (u : Rˣ) : -u ≠ u 
goal: -u ≠ u