ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/Algebra/Subalgebra/Tower.lean

full_name: Algebra.lmul_algebraMap
code: theorem lmul_algebraMap (x : R) : Algebra.lmul R A (algebraMap R A x) = Algebra.lsmul R R A x 
goal: (Algebra.lmul R A) ((algebraMap R A) x) = (Algebra.lsmul R R A) x

full_name: IsScalarTower.subalgebra
code: instance subalgebra (S₀ : Subalgebra R S) : IsScalarTower S₀ S A 
goal: IsScalarTower (↥S₀) S A

full_name: IsScalarTower.subalgebra'
code: instance subalgebra' (S₀ : Subalgebra R S) : IsScalarTower R S₀ A 
goal: IsScalarTower R (↥S₀) A

full_name: Subalgebra.restrictScalars
code: /-- Given a tower `A / ↥U / S / R` of algebras, where `U` is an `S`-subalgebra of `A`, reinterpret
`U` as an `R`-subalgebra of `A`. -/
def restrictScalars (U : Subalgebra S A) : Subalgebra R A 
goal: Subalgebra R A

full_name: Subalgebra.coe_restrictScalars
code: @[simp]
theorem coe_restrictScalars {U : Subalgebra S A} : (restrictScalars R U : Set A) = (U : Set A) 
goal: ↑(Subalgebra.restrictScalars R U) = ↑U

full_name: Subalgebra.restrictScalars_top
code: @[simp]
theorem restrictScalars_top : restrictScalars R (⊤ : Subalgebra S A) = ⊤ 
goal: Subalgebra.restrictScalars R ⊤ = ⊤

full_name: Subalgebra.restrictScalars_toSubmodule
code: @[simp]
theorem restrictScalars_toSubmodule {U : Subalgebra S A} :
    Subalgebra.toSubmodule (U.restrictScalars R) = U.toSubmodule.restrictScalars R 
goal: Subalgebra.toSubmodule (Subalgebra.restrictScalars R U) = Submodule.restrictScalars R (Subalgebra.toSubmodule U)

full_name: Subalgebra.mem_restrictScalars
code: @[simp]
theorem mem_restrictScalars {U : Subalgebra S A} {x : A} : x ∈ restrictScalars R U ↔ x ∈ U 
goal: x ∈ Subalgebra.restrictScalars R U ↔ x ∈ U

full_name: Subalgebra.restrictScalars_injective
code: theorem restrictScalars_injective :
    Function.Injective (restrictScalars R : Subalgebra S A → Subalgebra R A) 
goal: Function.Injective (Subalgebra.restrictScalars R)

full_name: Subalgebra.ofRestrictScalars
code: /-- Produces an `R`-algebra map from `U.restrictScalars R` given an `S`-algebra map from `U`.

This is a special case of `AlgHom.restrictScalars` that can be helpful in elaboration. -/
@[simp]
def ofRestrictScalars (U : Subalgebra S A) (f : U →ₐ[S] B) : U.restrictScalars R →ₐ[R] B 
goal: ↥(Subalgebra.restrictScalars R U) →ₐ[R] B

full_name: Subalgebra.range_isScalarTower_toAlgHom
code: @[simp]
lemma range_isScalarTower_toAlgHom [CommSemiring R] [CommSemiring A]
    [Algebra R A] (S : Subalgebra R A) :
    LinearMap.range (IsScalarTower.toAlgHom R S A) = Subalgebra.toSubmodule S 
goal: LinearMap.range (IsScalarTower.toAlgHom R (↥S) A) = Subalgebra.toSubmodule S

full_name: IsScalarTower.adjoin_range_toAlgHom
code: theorem adjoin_range_toAlgHom (t : Set A) :
    (Algebra.adjoin (toAlgHom R S A).range t).restrictScalars R =
      (Algebra.adjoin S t).restrictScalars R 
goal: Subalgebra.restrictScalars R (Algebra.adjoin (↥(IsScalarTower.toAlgHom R S A).range) t) =
  Subalgebra.restrictScalars R (Algebra.adjoin S t)
File: Mathlib/Algebra/Algebra/Subalgebra/Prod.lean

full_name: Subalgebra.prod
code: /-- The product of two subalgebras is a subalgebra. -/
def prod : Subalgebra R (A × B) 
goal: Subalgebra R (A × B)

full_name: Subalgebra.coe_prod
code: @[simp]
theorem coe_prod : (prod S S₁ : Set (A × B)) = (S : Set A) ×ˢ (S₁ : Set B) 
goal: ↑(S.prod S₁) = ↑S ×ˢ ↑S₁

full_name: Subalgebra.prod_toSubmodule
code: theorem prod_toSubmodule : toSubmodule (S.prod S₁) = (toSubmodule S).prod (toSubmodule S₁) 
goal: Subalgebra.toSubmodule (S.prod S₁) = (Subalgebra.toSubmodule S).prod (Subalgebra.toSubmodule S₁)

full_name: Subalgebra.mem_prod
code: @[simp]
theorem mem_prod {S : Subalgebra R A} {S₁ : Subalgebra R B} {x : A × B} :
    x ∈ prod S S₁ ↔ x.1 ∈ S ∧ x.2 ∈ S₁ 
goal: x ∈ S.prod S₁ ↔ x.1 ∈ S ∧ x.2 ∈ S₁

full_name: Subalgebra.prod_top
code: @[simp]
theorem prod_top : (prod ⊤ ⊤ : Subalgebra R (A × B)) = ⊤ 
goal: ⊤.prod ⊤ = ⊤

full_name: Subalgebra.prod_mono
code: theorem prod_mono {S T : Subalgebra R A} {S₁ T₁ : Subalgebra R B} :
    S ≤ T → S₁ ≤ T₁ → prod S S₁ ≤ prod T T₁ 
goal: S ≤ T → S₁ ≤ T₁ → S.prod S₁ ≤ T.prod T₁

full_name: Subalgebra.prod_inf_prod
code: @[simp]
theorem prod_inf_prod {S T : Subalgebra R A} {S₁ T₁ : Subalgebra R B} :
    S.prod S₁ ⊓ T.prod T₁ = (S ⊓ T).prod (S₁ ⊓ T₁) 
goal: S.prod S₁ ⊓ T.prod T₁ = (S ⊓ T).prod (S₁ ⊓ T₁)
File: Mathlib/Algebra/Algebra/Prod.lean

full_name: Prod.algebra
code: instance algebra : Algebra R (A × B) 
goal: Algebra R (A × B)

full_name: Prod.algebraMap_apply
code: @[simp]
theorem algebraMap_apply (r : R) : algebraMap R (A × B) r = (algebraMap R A r, algebraMap R B r) 
goal: (algebraMap R (A × B)) r = ((algebraMap R A) r, (algebraMap R B) r)

full_name: AlgHom.fst
code: /-- First projection as `AlgHom`. -/
def fst : A × B →ₐ[R] A 
goal: A × B →ₐ[R] A

full_name: AlgHom.snd
code: /-- Second projection as `AlgHom`. -/
def snd : A × B →ₐ[R] B 
goal: A × B →ₐ[R] B

full_name: AlgHom.prod_apply
code: /-- The `Pi.prod` of two morphisms is a morphism. -/
@[simps!]
def prod (f : A →ₐ[R] B) (g : A →ₐ[R] C) : A →ₐ[R] B × C 
goal: (f.prod g) x = (f x, g x)

full_name: AlgHom.prod
code: /-- The `Pi.prod` of two morphisms is a morphism. -/
@[simps!]
def prod (f : A →ₐ[R] B) (g : A →ₐ[R] C) : A →ₐ[R] B × C 
goal: A →ₐ[R] B × C

full_name: AlgHom.coe_prod
code: theorem coe_prod (f : A →ₐ[R] B) (g : A →ₐ[R] C) : ⇑(f.prod g) = Pi.prod f g 
goal: ⇑(f.prod g) = Pi.prod ⇑f ⇑g

full_name: AlgHom.fst_prod
code: @[simp]
theorem fst_prod (f : A →ₐ[R] B) (g : A →ₐ[R] C) : (fst R B C).comp (prod f g) = f 
goal: (AlgHom.fst R B C).comp (f.prod g) = f

full_name: AlgHom.snd_prod
code: @[simp]
theorem snd_prod (f : A →ₐ[R] B) (g : A →ₐ[R] C) : (snd R B C).comp (prod f g) = g 
goal: (AlgHom.snd R B C).comp (f.prod g) = g

full_name: AlgHom.prod_fst_snd
code: @[simp]
theorem prod_fst_snd : prod (fst R A B) (snd R A B) = 1 
goal: (AlgHom.fst R A B).prod (AlgHom.snd R A B) = 1

full_name: AlgHom.prodEquiv_symm_apply
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →ₐ[R] B) × (A →ₐ[R] C) ≃ (A →ₐ[R] B × C) 
goal: AlgHom.prodEquiv.symm f = ((AlgHom.fst R B C).comp f, (AlgHom.snd R B C).comp f)

full_name: AlgHom.prodEquiv
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →ₐ[R] B) × (A →ₐ[R] C) ≃ (A →ₐ[R] B × C) 
goal: (A →ₐ[R] B) × (A →ₐ[R] C) ≃ (A →ₐ[R] B × C)

full_name: AlgHom.prodEquiv_apply
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →ₐ[R] B) × (A →ₐ[R] C) ≃ (A →ₐ[R] B × C) 
goal: AlgHom.prodEquiv f = f.1.prod f.2

full_name: AlgHom.prodMap
code: /-- `Prod.map` of two algebra homomorphisms. -/
def prodMap {D : Type*} [Semiring D] [Algebra R D] (f : A →ₐ[R] B) (g : C →ₐ[R] D) :
    A × C →ₐ[R] B × D 
goal: A × C →ₐ[R] B × D
File: Mathlib/Algebra/Algebra/Subalgebra/Operations.lean

full_name: AlgHom.ker_rangeRestrict
code: theorem ker_rangeRestrict (f : A →ₐ[R] B) : RingHom.ker f.rangeRestrict = RingHom.ker f 
goal: RingHom.ker f.rangeRestrict = RingHom.ker f

full_name: Subalgebra.mem_of_finset_sum_eq_one_of_pow_smul_mem
code: /-- Suppose we are given `∑ i, lᵢ * sᵢ = 1` ∈ `S`, and `S'` a subalgebra of `S` that contains
`lᵢ` and `sᵢ`. To check that an `x : S` falls in `S'`, we only need to show that
`sᵢ ^ n • x ∈ S'` for some `n` for each `sᵢ`. -/
theorem mem_of_finset_sum_eq_one_of_pow_smul_mem
    {ι : Type*} (ι' : Finset ι) (s : ι → S) (l : ι → S)
    (e : ∑ i ∈ ι', l i * s i = 1) (hs : ∀ i, s i ∈ S') (hl : ∀ i, l i ∈ S') (x : S)
    (H : ∀ i, ∃ n : ℕ, (s i ^ n : S) • x ∈ S') : x ∈ S' 
goal: x ∈ S'

full_name: Subalgebra.mem_of_span_eq_top_of_smul_pow_mem
code: theorem mem_of_span_eq_top_of_smul_pow_mem
    (s : Set S) (l : s →₀ S) (hs : Finsupp.total s S S (↑) l = 1)
    (hs' : s ⊆ S') (hl : ∀ i, l i ∈ S') (x : S) (H : ∀ r : s, ∃ n : ℕ, (r : S) ^ n • x ∈ S') :
    x ∈ S' 
goal: x ∈ S'
File: Mathlib/Algebra/Ring/Hom/Basic.lean

full_name: RingHom.codomain_trivial_iff_range_eq_singleton_zero
code: /-- `f : α →+* β` has a trivial codomain iff its range is `{0}`. -/
theorem codomain_trivial_iff_range_eq_singleton_zero : (0 : β) = 1 ↔ Set.range f = {0} 
goal: ∀ {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} (f : α →+* β), 0 = 1 ↔ Set.range ⇑f = {0}

full_name: RingHom.isUnit_map
code: theorem isUnit_map (f : α →+* β) {a : α} : IsUnit a → IsUnit (f a) 
goal: IsUnit a → IsUnit (f a)

full_name: RingHom.map_dvd
code: protected theorem map_dvd (f : α →+* β) {a b : α} : a ∣ b → f a ∣ f b 
goal: a ∣ b → f a ∣ f b

full_name: Function.Injective.isDomain
code: /-- Pullback `IsDomain` instance along an injective function. -/
protected theorem Function.Injective.isDomain [Ring α] [IsDomain α] [Ring β] (f : β →+* α)
    (hf : Injective f) : IsDomain β 
goal: IsDomain β
File: Mathlib/Algebra/Algebra/Subalgebra/Pointwise.lean

full_name: Subalgebra.mul_toSubmodule_le
code: theorem mul_toSubmodule_le (S T : Subalgebra R A) :
    (Subalgebra.toSubmodule S)* (Subalgebra.toSubmodule T) ≤ Subalgebra.toSubmodule (S ⊔ T) 
goal: Subalgebra.toSubmodule S * Subalgebra.toSubmodule T ≤ Subalgebra.toSubmodule (S ⊔ T)

full_name: Subalgebra.mul_self
code: /-- As submodules, subalgebras are idempotent. -/
@[simp]
theorem mul_self (S : Subalgebra R A) : (Subalgebra.toSubmodule S) * (Subalgebra.toSubmodule S)
    = (Subalgebra.toSubmodule S) 
goal: Subalgebra.toSubmodule S * Subalgebra.toSubmodule S = Subalgebra.toSubmodule S

full_name: Subalgebra.mul_toSubmodule
code: /-- When `A` is commutative, `Subalgebra.mul_toSubmodule_le` is strict. -/
theorem mul_toSubmodule {R : Type*} {A : Type*} [CommSemiring R] [CommSemiring A] [Algebra R A]
    (S T : Subalgebra R A) : (Subalgebra.toSubmodule S) * (Subalgebra.toSubmodule T)
        = Subalgebra.toSubmodule (S ⊔ T) 
goal: Subalgebra.toSubmodule S * Subalgebra.toSubmodule T = Subalgebra.toSubmodule (S ⊔ T)

full_name: Subalgebra.pointwiseMulAction
code: /-- The action on a subalgebra corresponding to applying the action to every element.

This is available as an instance in the `Pointwise` locale. -/
protected def pointwiseMulAction : MulAction R' (Subalgebra R A) 
goal: MulAction R' (Subalgebra R A)

full_name: Subalgebra.coe_pointwise_smul
code: @[simp]
theorem coe_pointwise_smul (m : R') (S : Subalgebra R A) : ↑(m • S) = m • (S : Set A) 
goal: ↑(m • S) = m • ↑S

full_name: Subalgebra.pointwise_smul_toSubsemiring
code: @[simp]
theorem pointwise_smul_toSubsemiring (m : R') (S : Subalgebra R A) :
    (m • S).toSubsemiring = m • S.toSubsemiring 
goal: (m • S).toSubsemiring = m • S.toSubsemiring

full_name: Subalgebra.pointwise_smul_toSubmodule
code: @[simp]
theorem pointwise_smul_toSubmodule (m : R') (S : Subalgebra R A) :
    Subalgebra.toSubmodule (m • S) = m • Subalgebra.toSubmodule S 
goal: Subalgebra.toSubmodule (m • S) = m • Subalgebra.toSubmodule S

full_name: Subalgebra.pointwise_smul_toSubring
code: @[simp]
theorem pointwise_smul_toSubring {R' R A : Type*} [Semiring R'] [CommRing R] [Ring A]
    [MulSemiringAction R' A] [Algebra R A] [SMulCommClass R' R A] (m : R') (S : Subalgebra R A) :
    (m • S).toSubring = m • S.toSubring 
goal: (m • S).toSubring = m • S.toSubring

full_name: Subalgebra.smul_mem_pointwise_smul
code: theorem smul_mem_pointwise_smul (m : R') (r : A) (S : Subalgebra R A) : r ∈ S → m • r ∈ m • S 
goal: r ∈ S → m • r ∈ m • S

full_name: Subalgebra.instCovariantClassHSMulLe
code: instance : CovariantClass R' (Subalgebra R A) HSMul.hSMul LE.le 
goal: CovariantClass R' (Subalgebra R A) HSMul.hSMul LE.le
File: Mathlib/Algebra/Algebra/Subalgebra/Directed.lean

full_name: Subalgebra.coe_iSup_of_directed
code: theorem coe_iSup_of_directed (dir : Directed (· ≤ ·) K) : ↑(iSup K) = ⋃ i, (K i : Set A) 
goal: ↑(iSup K) = ⋃ i, ↑(K i)

full_name: Subalgebra.iSupLift
code: /-- Define an algebra homomorphism on a directed supremum of subalgebras by defining
it on each subalgebra, and proving that it agrees on the intersection of subalgebras. -/
noncomputable def iSupLift (dir : Directed (· ≤ ·) K) (f : ∀ i, K i →ₐ[R] B)
    (hf : ∀ (i j : ι) (h : K i ≤ K j), f i = (f j).comp (inclusion h))
    (T : Subalgebra R A) (hT : T = iSup K): ↥T →ₐ[R] B 
goal: ↥T →ₐ[R] B

full_name: Subalgebra.iSupLift_inclusion
code: @[simp]
theorem iSupLift_inclusion {dir : Directed (· ≤ ·) K} {f : ∀ i, K i →ₐ[R] B}
    {hf : ∀ (i j : ι) (h : K i ≤ K j), f i = (f j).comp (inclusion h)}
    {T : Subalgebra R A} {hT : T = iSup K} {i : ι} (x : K i) (h : K i ≤ T) :
    iSupLift K dir f hf T hT (inclusion h x) = f i x 
goal: (Subalgebra.iSupLift K dir f hf T hT) ((Subalgebra.inclusion h) x) = (f i) x

full_name: Subalgebra.iSupLift_comp_inclusion
code: @[simp]
theorem iSupLift_comp_inclusion {dir : Directed (· ≤ ·) K} {f : ∀ i, K i →ₐ[R] B}
    {hf : ∀ (i j : ι) (h : K i ≤ K j), f i = (f j).comp (inclusion h)}
    {T : Subalgebra R A} {hT : T = iSup K} {i : ι} (h : K i ≤ T) :
    (iSupLift K dir f hf T hT).comp (inclusion h) = f i 
goal: (Subalgebra.iSupLift K dir f hf T hT).comp (Subalgebra.inclusion h) = f i

full_name: Subalgebra.iSupLift_mk
code: @[simp]
theorem iSupLift_mk {dir : Directed (· ≤ ·) K} {f : ∀ i, K i →ₐ[R] B}
    {hf : ∀ (i j : ι) (h : K i ≤ K j), f i = (f j).comp (inclusion h)}
    {T : Subalgebra R A} {hT : T = iSup K} {i : ι} (x : K i) (hx : (x : A) ∈ T) :
    iSupLift K dir f hf T hT ⟨x, hx⟩ = f i x 
goal: (Subalgebra.iSupLift K dir f hf T hT) ⟨↑x, hx⟩ = (f i) x

full_name: Subalgebra.iSupLift_of_mem
code: theorem iSupLift_of_mem {dir : Directed (· ≤ ·) K} {f : ∀ i, K i →ₐ[R] B}
    {hf : ∀ (i j : ι) (h : K i ≤ K j), f i = (f j).comp (inclusion h)}
    {T : Subalgebra R A} {hT : T = iSup K} {i : ι} (x : T) (hx : (x : A) ∈ K i) :
    iSupLift K dir f hf T hT x = f i ⟨x, hx⟩ 
goal: (Subalgebra.iSupLift K dir f hf T hT) x = (f i) ⟨↑x, hx⟩
File: Mathlib/Algebra/Ring/Subring/Units.lean

full_name: Units.posSubgroup
code: /-- The subgroup of positive units of a linear ordered semiring. -/
def Units.posSubgroup (R : Type*) [LinearOrderedSemiring R] : Subgroup Rˣ 
goal: Subgroup Rˣ

full_name: Units.mem_posSubgroup
code: @[simp]
theorem Units.mem_posSubgroup {R : Type*} [LinearOrderedSemiring R] (u : Rˣ) :
    u ∈ Units.posSubgroup R ↔ (0 : R) < u 
goal: u ∈ Units.posSubgroup R ↔ 0 < ↑u
File: Mathlib/Algebra/Ring/Fin.lean

full_name: RingEquiv.piFinTwo
code: /-- The product over `Fin 2` of some rings is just the cartesian product of these rings. -/
@[simps]
def RingEquiv.piFinTwo (R : Fin 2 → Type*) [∀ i, Semiring (R i)] :
    (∀ i : Fin 2, R i) ≃+* R 0 × R 1 
goal: ((i : Fin 2) → R i) ≃+* R 0 × R 1

full_name: RingEquiv.piFinTwo_symm_apply
code: /-- The product over `Fin 2` of some rings is just the cartesian product of these rings. -/
@[simps]
def RingEquiv.piFinTwo (R : Fin 2 → Type*) [∀ i, Semiring (R i)] :
    (∀ i : Fin 2, R i) ≃+* R 0 × R 1 
goal: ∀ (a : R 0 × R 1) (i : Fin 2), (RingEquiv.piFinTwo R).symm a i = (piFinTwoEquiv R).invFun a i

full_name: RingEquiv.piFinTwo_apply
code: /-- The product over `Fin 2` of some rings is just the cartesian product of these rings. -/
@[simps]
def RingEquiv.piFinTwo (R : Fin 2 → Type*) [∀ i, Semiring (R i)] :
    (∀ i : Fin 2, R i) ≃+* R 0 × R 1 
goal: (RingEquiv.piFinTwo R) a = (piFinTwoEquiv R) a
File: Mathlib/Algebra/Ring/Idempotents.lean

full_name: IsIdempotentElem
code: /-- An element `p` is said to be idempotent if `p * p = p`
-/
def IsIdempotentElem (p : M) : Prop 
goal: Prop

full_name: IsIdempotentElem.of_isIdempotent
code: theorem of_isIdempotent [Std.IdempotentOp (α := M) (· * ·)] (a : M) : IsIdempotentElem a 
goal: IsIdempotentElem a

full_name: IsIdempotentElem.eq
code: theorem eq {p : M} (h : IsIdempotentElem p) : p * p = p 
goal: p * p = p

full_name: IsIdempotentElem.mul_of_commute
code: theorem mul_of_commute {p q : S} (h : Commute p q) (h₁ : IsIdempotentElem p)
    (h₂ : IsIdempotentElem q) : IsIdempotentElem (p * q) 
goal: IsIdempotentElem (p * q)

full_name: IsIdempotentElem.zero
code: theorem zero : IsIdempotentElem (0 : M₀) 
goal: IsIdempotentElem 0

full_name: IsIdempotentElem.one
code: theorem one : IsIdempotentElem (1 : M₁) 
goal: IsIdempotentElem 1

full_name: IsIdempotentElem.one_sub
code: theorem one_sub {p : R} (h : IsIdempotentElem p) : IsIdempotentElem (1 - p) 
goal: IsIdempotentElem (1 - p)

full_name: IsIdempotentElem.one_sub_iff
code: @[simp]
theorem one_sub_iff {p : R} : IsIdempotentElem (1 - p) ↔ IsIdempotentElem p 
goal: IsIdempotentElem (1 - p) ↔ IsIdempotentElem p

full_name: IsIdempotentElem.pow
code: theorem pow {p : N} (n : ℕ) (h : IsIdempotentElem p) : IsIdempotentElem (p ^ n) 
goal: IsIdempotentElem (p ^ n)

full_name: IsIdempotentElem.pow_succ_eq
code: theorem pow_succ_eq {p : N} (n : ℕ) (h : IsIdempotentElem p) : p ^ (n + 1) = p 
goal: p ^ (n + 1) = p

full_name: IsIdempotentElem.iff_eq_one
code: @[simp]
theorem iff_eq_one {p : G} : IsIdempotentElem p ↔ p = 1 
goal: IsIdempotentElem p ↔ p = 1

full_name: IsIdempotentElem.iff_eq_zero_or_one
code: @[simp]
theorem iff_eq_zero_or_one {p : G₀} : IsIdempotentElem p ↔ p = 0 ∨ p = 1 
goal: IsIdempotentElem p ↔ p = 0 ∨ p = 1

full_name: IsIdempotentElem.instZeroSubtype
code: instance : Zero { p : M₀ // IsIdempotentElem p } 
goal: Zero { p // IsIdempotentElem p }

full_name: IsIdempotentElem.coe_zero
code: @[simp]
theorem coe_zero : ↑(0 : { p : M₀ // IsIdempotentElem p }) = (0 : M₀) 
goal: ↑0 = 0

full_name: IsIdempotentElem.instOneSubtype
code: instance : One { p : M₁ // IsIdempotentElem p } 
goal: One { p // IsIdempotentElem p }

full_name: IsIdempotentElem.coe_one
code: @[simp]
theorem coe_one : ↑(1 : { p : M₁ // IsIdempotentElem p }) = (1 : M₁) 
goal: ↑1 = 1

full_name: IsIdempotentElem.instHasComplSubtype
code: instance : HasCompl { p : R // IsIdempotentElem p } 
goal: HasCompl { p // IsIdempotentElem p }

full_name: IsIdempotentElem.coe_compl
code: @[simp]
theorem coe_compl (p : { p : R // IsIdempotentElem p }) : ↑pᶜ = (1 : R) - ↑p 
goal: ↑pᶜ = 1 - ↑p

full_name: IsIdempotentElem.compl_compl
code: @[simp]
theorem compl_compl (p : { p : R // IsIdempotentElem p }) : pᶜᶜ = p 
goal: pᶜᶜ = p

full_name: IsIdempotentElem.zero_compl
code: @[simp]
theorem zero_compl : (0 : { p : R // IsIdempotentElem p })ᶜ = 1 
goal: 0ᶜ = 1

full_name: IsIdempotentElem.one_compl
code: @[simp]
theorem one_compl : (1 : { p : R // IsIdempotentElem p })ᶜ = 0 
goal: 1ᶜ = 0
File: Mathlib/Algebra/Ring/Semiconj.lean

full_name: SemiconjBy.add_right
code: @[simp]
theorem add_right [Distrib R] {a x y x' y' : R} (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
    SemiconjBy a (x + x') (y + y') 
goal: SemiconjBy a (x + x') (y + y')

full_name: SemiconjBy.add_left
code: @[simp]
theorem add_left [Distrib R] {a b x y : R} (ha : SemiconjBy a x y) (hb : SemiconjBy b x y) :
    SemiconjBy (a + b) x y 
goal: SemiconjBy (a + b) x y

full_name: SemiconjBy.neg_right
code: theorem neg_right (h : SemiconjBy a x y) : SemiconjBy a (-x) (-y) 
goal: SemiconjBy a (-x) (-y)

full_name: SemiconjBy.neg_right_iff
code: @[simp]
theorem neg_right_iff : SemiconjBy a (-x) (-y) ↔ SemiconjBy a x y 
goal: SemiconjBy a (-x) (-y) ↔ SemiconjBy a x y

full_name: SemiconjBy.neg_left
code: theorem neg_left (h : SemiconjBy a x y) : SemiconjBy (-a) x y 
goal: SemiconjBy (-a) x y

full_name: SemiconjBy.neg_left_iff
code: @[simp]
theorem neg_left_iff : SemiconjBy (-a) x y ↔ SemiconjBy a x y 
goal: SemiconjBy (-a) x y ↔ SemiconjBy a x y

full_name: SemiconjBy.neg_one_right
code: theorem neg_one_right (a : R) : SemiconjBy a (-1) (-1) 
goal: SemiconjBy a (-1) (-1)

full_name: SemiconjBy.neg_one_left
code: theorem neg_one_left (x : R) : SemiconjBy (-1) x x 
goal: SemiconjBy (-1) x x

full_name: SemiconjBy.sub_right
code: @[simp]
theorem sub_right (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
    SemiconjBy a (x - x') (y - y') 
goal: SemiconjBy a (x - x') (y - y')

full_name: SemiconjBy.sub_left
code: @[simp]
theorem sub_left (ha : SemiconjBy a x y) (hb : SemiconjBy b x y) :
    SemiconjBy (a - b) x y 
goal: SemiconjBy (a - b) x y
File: Mathlib/Algebra/Ring/Rat.lean

full_name: Rat.commRing
code: instance commRing : CommRing ℚ 
goal: CommRing ℚ

full_name: Rat.commGroupWithZero
code: instance commGroupWithZero : CommGroupWithZero ℚ 
goal: CommGroupWithZero ℚ

full_name: Rat.isDomain
code: instance isDomain : IsDomain ℚ 
goal: IsDomain ℚ

full_name: Rat.instCharZero
code: instance instCharZero : CharZero ℚ 
goal: CharZero ℚ

full_name: Rat.commSemiring
code: instance commSemiring : CommSemiring ℚ 
goal: CommSemiring ℚ

full_name: Rat.semiring
code: instance semiring     : Semiring ℚ     
goal: Semiring ℚ

full_name: Rat.mkRat_eq_div
code: lemma mkRat_eq_div (n : ℤ) (d : ℕ) : mkRat n d = n / d 
goal: mkRat n d = ↑n / ↑d

full_name: Rat.divInt_div_divInt_cancel_left
code: lemma divInt_div_divInt_cancel_left {x : ℤ} (hx : x ≠ 0) (n d : ℤ) :
    n /. x / (d /. x) = n /. d 
goal: Rat.divInt n x / Rat.divInt d x = Rat.divInt n d

full_name: Rat.divInt_div_divInt_cancel_right
code: lemma divInt_div_divInt_cancel_right {x : ℤ} (hx : x ≠ 0) (n d : ℤ) :
    x /. n / (x /. d) = d /. n 
goal: Rat.divInt x n / Rat.divInt x d = Rat.divInt d n

full_name: Rat.num_div_den
code: lemma num_div_den (r : ℚ) : (r.num : ℚ) / (r.den : ℚ) = r 
goal: ↑r.num / ↑r.den = r

full_name: Rat.divInt_pow
code: @[simp] lemma divInt_pow (num : ℕ) (den : ℤ) (n : ℕ) : (num /. den) ^ n = num ^ n /. den ^ n 
goal: Rat.divInt (↑num) den ^ n = Rat.divInt (↑num ^ n) (den ^ n)

full_name: Rat.mkRat_pow
code: @[simp] lemma mkRat_pow (num den : ℕ) (n : ℕ) : mkRat num den ^ n = mkRat (num ^ n) (den ^ n) 
goal: mkRat (↑num) den ^ n = mkRat (↑num ^ n) (den ^ n)

full_name: Rat.natCast_eq_divInt
code: lemma natCast_eq_divInt (n : ℕ) : ↑n = n /. 1 
goal: ↑n = Rat.divInt (↑n) 1

full_name: Rat.mul_den_eq_num
code: @[simp] lemma mul_den_eq_num (q : ℚ) : q * q.den = q.num 
goal: q * ↑q.den = ↑q.num

full_name: Rat.den_mul_eq_num
code: @[simp] lemma den_mul_eq_num (q : ℚ) : q.den * q = q.num 
goal: ↑q.den * q = ↑q.num
File: Mathlib/Algebra/Ring/Action/Subobjects.lean

full_name: Submonoid.mulSemiringAction
code: /-- A stronger version of `Submonoid.distribMulAction`. -/
instance Submonoid.mulSemiringAction [MulSemiringAction M R] (H : Submonoid M) :
    MulSemiringAction H R 
goal: MulSemiringAction (↥H) R

full_name: Subgroup.mulSemiringAction
code: /-- A stronger version of `Subgroup.distribMulAction`. -/
instance Subgroup.mulSemiringAction [MulSemiringAction G R] (H : Subgroup G) :
    MulSemiringAction H R 
goal: MulSemiringAction (↥H) R
File: Mathlib/Algebra/Ring/Action/Field.lean

full_name: smul_inv''
code: /-- Note that `smul_inv'` refers to the group case, and `smul_inv` has an additional inverse
on `x`. -/
@[simp]
theorem smul_inv'' [MulSemiringAction M F] (x : M) (m : F) : x • m⁻¹ = (x • m)⁻¹ 
goal: x • m⁻¹ = (x • m)⁻¹
File: Mathlib/Algebra/Ring/Action/Invariant.lean

full_name: IsInvariantSubring
code: /-- A typeclass for subrings invariant under a `MulSemiringAction`. -/
class IsInvariantSubring : Prop where
  smul_mem : ∀ (m : M) {x : R}, x ∈ S → m • x ∈ S
goal: Prop

full_name: IsInvariantSubring.smul_mem
code: /-- A typeclass for subrings invariant under a `MulSemiringAction`. -/
class IsInvariantSubring : Prop where
  smul_mem : ∀ (m : M) {x : R}, x ∈ S → m • x ∈ S
goal: x ∈ S → m • x ∈ S

full_name: IsInvariantSubring.toMulSemiringAction
code: instance IsInvariantSubring.toMulSemiringAction [IsInvariantSubring M S] :
    MulSemiringAction M S 
goal: MulSemiringAction M ↥S

full_name: IsInvariantSubring.subtypeHom
code: /-- The canonical inclusion from an invariant subring. -/
def IsInvariantSubring.subtypeHom : U →+*[M] R' 
goal: ↥U →+*[M] R'

full_name: IsInvariantSubring.coe_subtypeHom
code: @[simp]
theorem IsInvariantSubring.coe_subtypeHom :
    (IsInvariantSubring.subtypeHom M U : U → R') = Subtype.val 
goal: ⇑(IsInvariantSubring.subtypeHom M U) = Subtype.val

full_name: IsInvariantSubring.coe_subtypeHom'
code: @[simp]
theorem IsInvariantSubring.coe_subtypeHom' :
    ((IsInvariantSubring.subtypeHom M U).toRingHom : U →+* R') = U.subtype 
goal: (IsInvariantSubring.subtypeHom M U).toRingHom = U.subtype