ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- val_unitsEquivProdSubtype_symm_apply
@[simps]
def unitsEquivProdSubtype [Monoid α] : αˣ ≃ {p : α × α // p.1 * p.2 = 1 ∧ p.2 * p.1 = 1} 
Arguments: (α : Type u_2) [Monoid α] (p : { p // p.1 * p.2 = 1 ∧ p.2 * p.1 = 1 })
Goal: ↑((unitsEquivProdSubtype α).symm p) = (↑p).1
-- MulEquiv.inv_apply
@[to_additive (attr := simps apply)
  "When the `AddGroup` is commutative, `Equiv.neg` is an `AddEquiv`."]
def MulEquiv.inv (G : Type*) [DivisionCommMonoid G] : G ≃* G 
Arguments: (G : Type u_12) [DivisionCommMonoid G]
Goal: ∀ (a : G), (MulEquiv.inv G) a = a⁻¹
-- AddEquiv.neg_apply
@[to_additive (attr := simps apply)
  "When the `AddGroup` is commutative, `Equiv.neg` is an `AddEquiv`."]
def MulEquiv.inv (G : Type*) [DivisionCommMonoid G] : G ≃* G 
Arguments: (G : Type u_12) [SubtractionCommMonoid G]
Goal: ∀ (a : G), (AddEquiv.neg G) a = -a
-- AddEquiv.neg_symm
@[to_additive (attr := simp)]
theorem MulEquiv.inv_symm (G : Type*) [DivisionCommMonoid G] :
    (MulEquiv.inv G).symm = MulEquiv.inv G 
Arguments: (G : Type u_12) [SubtractionCommMonoid G]
Goal: (AddEquiv.neg G).symm = AddEquiv.neg G
-- MulEquiv.inv_symm
@[to_additive (attr := simp)]
theorem MulEquiv.inv_symm (G : Type*) [DivisionCommMonoid G] :
    (MulEquiv.inv G).symm = MulEquiv.inv G 
Arguments: (G : Type u_12) [DivisionCommMonoid G]
Goal: (MulEquiv.inv G).symm = MulEquiv.inv G
-- AddEquiv.map_isAddUnit_iff
@[to_additive]
protected
theorem MulEquiv.map_isUnit_iff {M N} [Monoid M] [Monoid N] [EquivLike F M N] [MonoidHomClass F M N]
    (f : F) {m : M} : IsUnit (f m) ↔ IsUnit m 
Arguments: {F : Type u_1} {M : Type u_12} {N : Type u_13} [AddMonoid M] [AddMonoid N] [EquivLike F M N] [AddMonoidHomClass F M N] (f : F) {m : M}
Goal: IsAddUnit (f m) ↔ IsAddUnit m
-- MulEquiv.map_isUnit_iff
@[to_additive]
protected
theorem MulEquiv.map_isUnit_iff {M N} [Monoid M] [Monoid N] [EquivLike F M N] [MonoidHomClass F M N]
    (f : F) {m : M} : IsUnit (f m) ↔ IsUnit m 
Arguments: {F : Type u_1} {M : Type u_12} {N : Type u_13} [Monoid M] [Monoid N] [EquivLike F M N] [MonoidHomClass F M N] (f : F) {m : M}
Goal: IsUnit (f m) ↔ IsUnit m
-- LinearMap.toMatrix_directSum_collectedBasis_eq_blockDiagonal'
lemma toMatrix_directSum_collectedBasis_eq_blockDiagonal' {R M₁ M₂ : Type*} [CommSemiring R]
    [AddCommMonoid M₁] [Module R M₁] {N₁ : ι → Submodule R M₁} (h₁ : IsInternal N₁)
    [AddCommMonoid M₂] [Module R M₂] {N₂ : ι → Submodule R M₂} (h₂ : IsInternal N₂)
    {κ₁ κ₂ : ι → Type*} [∀ i, Fintype (κ₁ i)] [∀ i, Finite (κ₂ i)] [∀ i, DecidableEq (κ₁ i)]
    [Fintype ι] (b₁ : (i : ι) → Basis (κ₁ i) R (N₁ i)) (b₂ : (i : ι) → Basis (κ₂ i) R (N₂ i))
    {f : M₁ →ₗ[R] M₂} (hf : ∀ i, MapsTo f (N₁ i) (N₂ i)) :
    toMatrix (h₁.collectedBasis b₁) (h₂.collectedBasis b₂) f =
    Matrix.blockDiagonal' fun i ↦ toMatrix (b₁ i) (b₂ i) (f.restrict (hf i)) 
Arguments: {ι : Type u_1} [DecidableEq ι] {R : Type u_4} {M₁ : Type u_5} {M₂ : Type u_6} [CommSemiring R] [AddCommMonoid M₁] [Module R M₁] {N₁ : ι → Submodule R M₁} (h₁ : DirectSum.IsInternal N₁) [AddCommMonoid M₂] [Module R M₂] {N₂ : ι → Submodule R M₂} (h₂ : DirectSum.IsInternal N₂) {κ₁ : ι → Type u_7} {κ₂ : ι → Type u_8} [(i : ι) → Fintype (κ₁ i)] [∀ (i : ι), Finite (κ₂ i)] [(i : ι) → DecidableEq (κ₁ i)] [Fintype ι] (b₁ : (i : ι) → Basis (κ₁ i) R ↥(N₁ i)) (b₂ : (i : ι) → Basis (κ₂ i) R ↥(N₂ i)) {f : M₁ →ₗ[R] M₂} (hf : ∀ (i : ι), Set.MapsTo ⇑f ↑(N₁ i) ↑(N₂ i))
Goal: (LinearMap.toMatrix (h₁.collectedBasis b₁) (h₂.collectedBasis b₂)) f =
  Matrix.blockDiagonal' fun i => (LinearMap.toMatrix (b₁ i) (b₂ i)) (f.restrict ⋯)
-- LinearMap.diag_toMatrix_directSum_collectedBasis_eq_zero_of_mapsTo_ne
lemma diag_toMatrix_directSum_collectedBasis_eq_zero_of_mapsTo_ne
    {κ : ι → Type*} [∀ i, Fintype (κ i)] [∀ i, DecidableEq (κ i)]
    {s : Finset ι} (h : IsInternal fun i : s ↦ N i)
    (b : (i : s) → Basis (κ i) R (N i)) (σ : ι → ι) (hσ : ∀ i, σ i ≠ i)
    {f : Module.End R M} (hf : ∀ i, MapsTo f (N i) (N <| σ i)) (hN : ∀ i, i ∉ s → N i = ⊥) :
    Matrix.diag (toMatrix (h.collectedBasis b) (h.collectedBasis b) f) = 0 
Arguments: {ι : Type u_1} {R : Type u_2} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {N : ι → Submodule R M} [DecidableEq ι] {κ : ι → Type u_4} [(i : ι) → Fintype (κ i)] [(i : ι) → DecidableEq (κ i)] {s : Finset ι} (h : DirectSum.IsInternal fun i => N ↑i) (b : (i : { x // x ∈ s }) → Basis (κ ↑i) R ↥(N ↑i)) (σ : ι → ι) (hσ : ∀ (i : ι), σ i ≠ i) {f : Module.End R M} (hf : ∀ (i : ι), Set.MapsTo ⇑f ↑(N i) ↑(N (σ i))) (hN : ∀ i ∉ s, N i = ⊥)
Goal: ((LinearMap.toMatrix (h.collectedBasis b) (h.collectedBasis b)) f).diag = 0
-- LinearMap.trace_eq_sum_trace_restrict
lemma trace_eq_sum_trace_restrict [Fintype ι]
    {f : M →ₗ[R] M} (hf : ∀ i, MapsTo f (N i) (N i)) :
    trace R M f = ∑ i, trace R (N i) (f.restrict (hf i)) 
Arguments: {ι : Type u_1} {R : Type u_2} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {N : ι → Submodule R M} [DecidableEq ι] (h : DirectSum.IsInternal N) [∀ (i : ι), Module.Finite R ↥(N i)] [∀ (i : ι), Module.Free R ↥(N i)] [Fintype ι] {f : M →ₗ[R] M} (hf : ∀ (i : ι), Set.MapsTo ⇑f ↑(N i) ↑(N i))
Goal: (LinearMap.trace R M) f = ∑ i : ι, (LinearMap.trace R ↥(N i)) (f.restrict ⋯)
-- LinearMap.trace_eq_sum_trace_restrict'
lemma trace_eq_sum_trace_restrict' (hN : {i | N i ≠ ⊥}.Finite)
    {f : M →ₗ[R] M} (hf : ∀ i, MapsTo f (N i) (N i)) :
    trace R M f = ∑ i ∈ hN.toFinset, trace R (N i) (f.restrict (hf i)) 
Arguments: {ι : Type u_1} {R : Type u_2} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {N : ι → Submodule R M} [DecidableEq ι] (h : DirectSum.IsInternal N) [∀ (i : ι), Module.Finite R ↥(N i)] [∀ (i : ι), Module.Free R ↥(N i)] (hN : {i | N i ≠ ⊥}.Finite) {f : M →ₗ[R] M} (hf : ∀ (i : ι), Set.MapsTo ⇑f ↑(N i) ↑(N i))
Goal: (LinearMap.trace R M) f = ∑ i ∈ hN.toFinset, (LinearMap.trace R ↥(N i)) (f.restrict ⋯)
-- LinearMap.trace_eq_zero_of_mapsTo_ne
lemma trace_eq_zero_of_mapsTo_ne [IsNoetherian R M]
    (σ : ι → ι) (hσ : ∀ i, σ i ≠ i) {f : Module.End R M}
    (hf : ∀ i, MapsTo f (N i) (N <| σ i)) :
    trace R M f = 0 
Arguments: {ι : Type u_1} {R : Type u_2} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {N : ι → Submodule R M} [DecidableEq ι] (h : DirectSum.IsInternal N) [∀ (i : ι), Module.Finite R ↥(N i)] [∀ (i : ι), Module.Free R ↥(N i)] [IsNoetherian R M] (σ : ι → ι) (hσ : ∀ (i : ι), σ i ≠ i) {f : Module.End R M} (hf : ∀ (i : ι), Set.MapsTo ⇑f ↑(N i) ↑(N (σ i)))
Goal: (LinearMap.trace R M) f = 0
-- LinearMap.trace_comp_eq_zero_of_commute_of_trace_restrict_eq_zero
lemma trace_comp_eq_zero_of_commute_of_trace_restrict_eq_zero
    [IsDomain R] [IsPrincipalIdealRing R] [Module.Free R M] [Module.Finite R M]
    {f g : Module.End R M}
    (h_comm : Commute f g)
    (hf : ⨆ μ, ⨆ k, f.genEigenspace μ k = ⊤)
    (hg : ∀ μ, trace R _ (g.restrict (f.mapsTo_iSup_genEigenspace_of_comm h_comm μ)) = 0) :
    trace R _ (g ∘ₗ f) = 0 
Arguments: {R : Type u_2} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] [IsDomain R] [IsPrincipalIdealRing R] [Module.Free R M] [Module.Finite R M] {f g : Module.End R M} (h_comm : Commute f g) (hf : ⨆ μ, ⨆ k, (f.genEigenspace μ) k = ⊤) (hg : ∀ (μ : R), (LinearMap.trace R ↥(⨆ k, (f.genEigenspace μ) k)) (LinearMap.restrict g ⋯) = 0)
Goal: (LinearMap.trace R M) (g ∘ₗ f) = 0
-- LinearMap.mapsTo_biSup_of_mapsTo
lemma mapsTo_biSup_of_mapsTo (s : Set ι) {f : Module.End R M} (hf : ∀ i, MapsTo f (N i) (N i)) :
    MapsTo f ↑(⨆ i ∈ s, N i) ↑(⨆ i ∈ s, N i) 
Arguments: {ι : Type u_1} {R : Type u_2} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {N : ι → Submodule R M} (s : Set ι) {f : Module.End R M} (hf : ∀ (i : ι), Set.MapsTo ⇑f ↑(N i) ↑(N i))
Goal: Set.MapsTo ⇑f ↑(⨆ i ∈ s, N i) ↑(⨆ i ∈ s, N i)
-- LinearMap.trace_eq_sum_trace_restrict_of_eq_biSup
lemma trace_eq_sum_trace_restrict_of_eq_biSup
    [∀ i, Module.Finite R (N i)] [∀ i, Module.Free R (N i)]
    (s : Finset ι) (h : CompleteLattice.Independent <| fun i : s ↦ N i)
    {f : Module.End R M} (hf : ∀ i, MapsTo f (N i) (N i))
    (p : Submodule R M) (hp : p = ⨆ i ∈ s, N i)
    (hp' : MapsTo f p p := hp ▸ mapsTo_biSup_of_mapsTo (s : Set ι) hf) :
    trace R p (f.restrict hp') = ∑ i ∈ s, trace R (N i) (f.restrict (hf i)) 
Arguments: {ι : Type u_1} {R : Type u_2} {M : Type u_3} [CommRing R] [AddCommGroup M] [Module R M] {N : ι → Submodule R M} [∀ (i : ι), Module.Finite R ↥(N i)] [∀ (i : ι), Module.Free R ↥(N i)] (s : Finset ι) (h : CompleteLattice.Independent fun i => N ↑i) {f : Module.End R M} (hf : ∀ (i : ι), Set.MapsTo ⇑f ↑(N i) ↑(N i)) (p : Submodule R M) (hp : p = ⨆ i ∈ s, N i) (hp' : Set.MapsTo ⇑f ↑p ↑p := ⋯)
Goal: (LinearMap.trace R ↥p) (LinearMap.restrict f hp') = ∑ i ∈ s, (LinearMap.trace R ↥(N i)) (LinearMap.restrict f ⋯)
-- ModuleCat.restrictScalars.map_apply
@[simp]
theorem restrictScalars.map_apply {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S)
    {M M' : ModuleCat.{v} S} (g : M ⟶ M') (x) : (restrictScalars f).map g x = g x 
Arguments: {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) {M M' : ModuleCat S} (g : M ⟶ M') (x : ↑((ModuleCat.restrictScalars f).obj M))
Goal: ((ModuleCat.restrictScalars f).map g) x = g x
-- ModuleCat.restrictScalars.smul_def
@[simp]
theorem restrictScalars.smul_def {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S)
    {M : ModuleCat.{v} S} (r : R) (m : (restrictScalars f).obj M) : r • m = (f r • m : M) 
Arguments: {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) {M : ModuleCat S} (r : R) (m : ↑((ModuleCat.restrictScalars f).obj M))
Goal: r • m = f r • m
-- ModuleCat.restrictScalars.smul_def'
theorem restrictScalars.smul_def' {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S)
    {M : ModuleCat.{v} S} (r : R) (m : M) :
    -- Porting note: clumsy way to coerce
    let m' : (restrictScalars f).obj M := m
    (r • m' : (restrictScalars f).obj M) = (f r • m : M) 
Arguments: {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) {M : ModuleCat S} (r : R) (m : ↑M)
Goal: let m' := m;
r • m' = f r • m
-- ModuleCat.semilinearMapAddEquiv_apply_apply
@[simps]
def semilinearMapAddEquiv {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S)
    (M : ModuleCat.{v} R) (N : ModuleCat.{v} S) :
    (M →ₛₗ[f] N) ≃+ (M ⟶ (ModuleCat.restrictScalars f).obj N) 
Arguments: {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) (M : ModuleCat R) (N : ModuleCat S) (g : ↑M →ₛₗ[f] ↑N) (a : ↑M)
Goal: ((ModuleCat.semilinearMapAddEquiv f M N) g) a = g a
-- ModuleCat.semilinearMapAddEquiv_symm_apply_apply
@[simps]
def semilinearMapAddEquiv {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S)
    (M : ModuleCat.{v} R) (N : ModuleCat.{v} S) :
    (M →ₛₗ[f] N) ≃+ (M ⟶ (ModuleCat.restrictScalars f).obj N) 
Arguments: {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) (M : ModuleCat R) (N : ModuleCat S) (g : M ⟶ (ModuleCat.restrictScalars f).obj N) (a : ↑M)
Goal: ((ModuleCat.semilinearMapAddEquiv f M N).symm g) a = g a
-- ModuleCat.restrictScalarsId'App_hom_apply
lemma restrictScalarsId'App_hom_apply (M : ModuleCat R) (x : M) :
    (restrictScalarsId'App f hf M).hom x = x 
Arguments: {R : Type u₁} [Ring R] (f : R →+* R) (hf : f = RingHom.id R) (M : ModuleCat R) (x : ↑M)
Goal: (ModuleCat.restrictScalarsId'App f hf M).hom x = x
-- ModuleCat.restrictScalarsId'App_inv_apply
lemma restrictScalarsId'App_inv_apply (M : ModuleCat R) (x : M) :
    (restrictScalarsId'App f hf M).inv x = x 
Arguments: {R : Type u₁} [Ring R] (f : R →+* R) (hf : f = RingHom.id R) (M : ModuleCat R) (x : ↑M)
Goal: (ModuleCat.restrictScalarsId'App f hf M).inv x = x
-- ModuleCat.restrictScalarsId'_inv_app
@[simps! hom_app inv_app]
def restrictScalarsId' : ModuleCat.restrictScalars.{v} f ≅ 𝟭 _ 
Arguments: {R : Type u₁} [Ring R] (f : R →+* R) (hf : f = RingHom.id R) (X : ModuleCat R)
Goal: (ModuleCat.restrictScalarsId' f hf).inv.app X = (ModuleCat.restrictScalarsId'App f hf X).inv
-- ModuleCat.restrictScalarsId'_hom_app
@[simps! hom_app inv_app]
def restrictScalarsId' : ModuleCat.restrictScalars.{v} f ≅ 𝟭 _ 
Arguments: {R : Type u₁} [Ring R] (f : R →+* R) (hf : f = RingHom.id R) (X : ModuleCat R)
Goal: (ModuleCat.restrictScalarsId' f hf).hom.app X = (ModuleCat.restrictScalarsId'App f hf X).hom
-- ModuleCat.restrictScalarsId'App_hom_naturality
@[reassoc]
lemma restrictScalarsId'App_hom_naturality {M N : ModuleCat R} (φ : M ⟶ N) :
    (restrictScalars f).map φ ≫ (restrictScalarsId'App f hf N).hom =
      (restrictScalarsId'App f hf M).hom ≫ φ 
Arguments: {R : Type u₁} [Ring R] (f : R →+* R) (hf : f = RingHom.id R) {M N : ModuleCat R} (φ : M ⟶ N)
Goal: (ModuleCat.restrictScalars f).map φ ≫ (ModuleCat.restrictScalarsId'App f hf N).hom =
  (ModuleCat.restrictScalarsId'App f hf M).hom ≫ φ
-- ModuleCat.restrictScalarsId'App_inv_naturality
@[reassoc]
lemma restrictScalarsId'App_inv_naturality {M N : ModuleCat R} (φ : M ⟶ N) :
    φ ≫ (restrictScalarsId'App f hf N).inv =
      (restrictScalarsId'App f hf M).inv ≫ (restrictScalars f).map φ 
Arguments: {R : Type u₁} [Ring R] (f : R →+* R) (hf : f = RingHom.id R) {M N : ModuleCat R} (φ : M ⟶ N)
Goal: φ ≫ (ModuleCat.restrictScalarsId'App f hf N).inv =
  (ModuleCat.restrictScalarsId'App f hf M).inv ≫ (ModuleCat.restrictScalars f).map φ
-- ModuleCat.restrictScalarsComp'App_hom_apply
lemma restrictScalarsComp'App_hom_apply (M : ModuleCat R₃) (x : M) :
    (restrictScalarsComp'App f g gf hgf M).hom x = x 
Arguments: {R₁ : Type u₁} {R₂ : Type u₂} {R₃ : Type u₃} [Ring R₁] [Ring R₂] [Ring R₃] (f : R₁ →+* R₂) (g : R₂ →+* R₃) (gf : R₁ →+* R₃) (hgf : gf = g.comp f) (M : ModuleCat R₃) (x : ↑M)
Goal: (ModuleCat.restrictScalarsComp'App f g gf hgf M).hom x = x
-- ModuleCat.restrictScalarsComp'App_inv_apply
lemma restrictScalarsComp'App_inv_apply (M : ModuleCat R₃) (x : M) :
    (restrictScalarsComp'App f g gf hgf M).inv x = x 
Arguments: {R₁ : Type u₁} {R₂ : Type u₂} {R₃ : Type u₃} [Ring R₁] [Ring R₂] [Ring R₃] (f : R₁ →+* R₂) (g : R₂ →+* R₃) (gf : R₁ →+* R₃) (hgf : gf = g.comp f) (M : ModuleCat R₃) (x : ↑M)
Goal: (ModuleCat.restrictScalarsComp'App f g gf hgf M).inv x = x
-- ModuleCat.restrictScalarsComp'_inv_app
@[simps! hom_app inv_app]
def restrictScalarsComp' :
    ModuleCat.restrictScalars.{v} gf ≅
      ModuleCat.restrictScalars g ⋙ ModuleCat.restrictScalars f 
Arguments: {R₁ : Type u₁} {R₂ : Type u₂} {R₃ : Type u₃} [Ring R₁] [Ring R₂] [Ring R₃] (f : R₁ →+* R₂) (g : R₂ →+* R₃) (gf : R₁ →+* R₃) (hgf : gf = g.comp f) (X : ModuleCat R₃)
Goal: (ModuleCat.restrictScalarsComp' f g gf hgf).inv.app X = (ModuleCat.restrictScalarsComp'App f g gf hgf X).inv
-- ModuleCat.restrictScalarsComp'_hom_app
@[simps! hom_app inv_app]
def restrictScalarsComp' :
    ModuleCat.restrictScalars.{v} gf ≅
      ModuleCat.restrictScalars g ⋙ ModuleCat.restrictScalars f 
Arguments: {R₁ : Type u₁} {R₂ : Type u₂} {R₃ : Type u₃} [Ring R₁] [Ring R₂] [Ring R₃] (f : R₁ →+* R₂) (g : R₂ →+* R₃) (gf : R₁ →+* R₃) (hgf : gf = g.comp f) (X : ModuleCat R₃)
Goal: (ModuleCat.restrictScalarsComp' f g gf hgf).hom.app X = (ModuleCat.restrictScalarsComp'App f g gf hgf X).hom
-- ModuleCat.restrictScalarsComp'App_hom_naturality
@[reassoc]
lemma restrictScalarsComp'App_hom_naturality {M N : ModuleCat R₃} (φ : M ⟶ N) :
    (restrictScalars gf).map φ ≫ (restrictScalarsComp'App f g gf hgf N).hom =
      (restrictScalarsComp'App f g gf hgf M).hom ≫
        (restrictScalars f).map ((restrictScalars g).map φ) 
Arguments: {R₁ : Type u₁} {R₂ : Type u₂} {R₃ : Type u₃} [Ring R₁] [Ring R₂] [Ring R₃] (f : R₁ →+* R₂) (g : R₂ →+* R₃) (gf : R₁ →+* R₃) (hgf : gf = g.comp f) {M N : ModuleCat R₃} (φ : M ⟶ N)
Goal: (ModuleCat.restrictScalars gf).map φ ≫ (ModuleCat.restrictScalarsComp'App f g gf hgf N).hom =
  (ModuleCat.restrictScalarsComp'App f g gf hgf M).hom ≫
    (ModuleCat.restrictScalars f).map ((ModuleCat.restrictScalars g).map φ)
-- ModuleCat.restrictScalarsComp'App_inv_naturality
@[reassoc]
lemma restrictScalarsComp'App_inv_naturality {M N : ModuleCat R₃} (φ : M ⟶ N) :
    (restrictScalars f).map ((restrictScalars g).map φ) ≫
        (restrictScalarsComp'App f g gf hgf N).inv =
      (restrictScalarsComp'App f g gf hgf M).inv ≫ (restrictScalars gf).map φ 
Arguments: {R₁ : Type u₁} {R₂ : Type u₂} {R₃ : Type u₃} [Ring R₁] [Ring R₂] [Ring R₃] (f : R₁ →+* R₂) (g : R₂ →+* R₃) (gf : R₁ →+* R₃) (hgf : gf = g.comp f) {M N : ModuleCat R₃} (φ : M ⟶ N)
Goal: (ModuleCat.restrictScalars f).map ((ModuleCat.restrictScalars g).map φ) ≫
    (ModuleCat.restrictScalarsComp'App f g gf hgf N).inv =
  (ModuleCat.restrictScalarsComp'App f g gf hgf M).inv ≫ (ModuleCat.restrictScalars gf).map φ
-- ModuleCat.ExtendScalars.map'_id
theorem map'_id {M : ModuleCat.{v} R} : map' f (𝟙 M) = 𝟙 _ 
Arguments: {R : Type u₁} {S : Type u₂} [CommRing R] [CommRing S] (f : R →+* S) {M : ModuleCat R}
Goal: ModuleCat.ExtendScalars.map' f (𝟙 M) = 𝟙 (ModuleCat.ExtendScalars.obj' f M)
-- ModuleCat.ExtendScalars.map'_comp
theorem map'_comp {M₁ M₂ M₃ : ModuleCat.{v} R} (l₁₂ : M₁ ⟶ M₂) (l₂₃ : M₂ ⟶ M₃) :
    map' f (l₁₂ ≫ l₂₃) = map' f l₁₂ ≫ map' f l₂₃ 
Arguments: {R : Type u₁} {S : Type u₂} [CommRing R] [CommRing S] (f : R →+* S) {M₁ M₂ M₃ : ModuleCat R} (l₁₂ : M₁ ⟶ M₂) (l₂₃ : M₂ ⟶ M₃)
Goal: ModuleCat.ExtendScalars.map' f (l₁₂ ≫ l₂₃) = ModuleCat.ExtendScalars.map' f l₁₂ ≫ ModuleCat.ExtendScalars.map' f l₂₃
-- ModuleCat.ExtendScalars.smul_tmul
@[simp]
protected theorem smul_tmul {M : ModuleCat.{v} R} (s s' : S) (m : M) :
    s • (s'⊗ₜ[R,f]m : (extendScalars f).obj M) = (s * s')⊗ₜ[R,f]m 
Arguments: {R : Type u₁} {S : Type u₂} [CommRing R] [CommRing S] (f : R →+* S) {M : ModuleCat R} (s s' : S) (m : ↑M)
Goal: s • s' ⊗ₜ[R] m = (s * s') ⊗ₜ[R] m
-- ModuleCat.ExtendScalars.map_tmul
@[simp]
theorem map_tmul {M M' : ModuleCat.{v} R} (g : M ⟶ M') (s : S) (m : M) :
    (extendScalars f).map g (s⊗ₜ[R,f]m) = s⊗ₜ[R,f]g m 
Arguments: {R : Type u₁} {S : Type u₂} [CommRing R] [CommRing S] (f : R →+* S) {M M' : ModuleCat R} (g : M ⟶ M') (s : S) (m : ↑M)
Goal: ((ModuleCat.extendScalars f).map g) (s ⊗ₜ[R] m) = s ⊗ₜ[R] g m
-- ModuleCat.CoextendScalars.smul_apply'
@[simp]
theorem smul_apply' (s : S) (g : (restrictScalars f).obj ⟨S⟩ →ₗ[R] M) (s' : S) :
    (s • g) s' = g (s' * s : S) 
Arguments: {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) (M : Type v) [AddCommMonoid M] [Module R M] (s : S) (g : ↑((ModuleCat.restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M) (s' : S)
Goal: (s • g) s' = g (s' * s)
-- ModuleCat.CoextendScalars.map'_apply
@[simps]
def map' {M M' : ModuleCat R} (g : M ⟶ M') : obj' f M ⟶ obj' f M' 
Arguments: {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) {M M' : ModuleCat R} (g : M ⟶ M') (h : ↑(ModuleCat.CoextendScalars.obj' f M))
Goal: (ModuleCat.CoextendScalars.map' f g) h = g ∘ₗ h
-- ModuleCat.CoextendScalars.smul_apply
theorem smul_apply (M : ModuleCat R) (g : (coextendScalars f).obj M) (s s' : S) :
    (s • g) s' = g (s' * s) 
Arguments: {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) (M : ModuleCat R) (g : ↑((ModuleCat.coextendScalars f).obj M)) (s s' : S)
Goal: (s • g).toFun s' = g.toFun (s' * s)
-- ModuleCat.CoextendScalars.map_apply
@[simp]
theorem map_apply {M M' : ModuleCat R} (g : M ⟶ M') (x) (s : S) :
    (coextendScalars f).map g x s = g (x s) 
Arguments: {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) {M M' : ModuleCat R} (g : M ⟶ M') (x : ↑((ModuleCat.coextendScalars f).obj M)) (s : S)
Goal: (((ModuleCat.coextendScalars f).map g) x).toFun s = g (x.toFun s)
-- ModuleCat.RestrictionCoextensionAdj.HomEquiv.fromRestriction_apply_apply
@[simps apply_apply]
def HomEquiv.fromRestriction {X : ModuleCat R} {Y : ModuleCat S}
    (g : (restrictScalars f).obj Y ⟶ X) : Y ⟶ (coextendScalars f).obj X 
Arguments: {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) {X : ModuleCat R} {Y : ModuleCat S} (g : (ModuleCat.restrictScalars f).obj Y ⟶ X) (y : ↑Y) (s : S)
Goal: ((ModuleCat.RestrictionCoextensionAdj.HomEquiv.fromRestriction f g) y) s = g (s • y)
-- ModuleCat.RestrictionCoextensionAdj.HomEquiv.toRestriction_apply
@[simps apply]
def HomEquiv.toRestriction {X Y} (g : Y ⟶ (coextendScalars f).obj X) :
    (restrictScalars f).obj Y ⟶ X 
Arguments: {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S) {X : ModuleCat R} {Y : ModuleCat S} (g : Y ⟶ (ModuleCat.coextendScalars f).obj X) (y : ↑Y)
Goal: (ModuleCat.RestrictionCoextensionAdj.HomEquiv.toRestriction f g) y = (g y).toFun 1
-- ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.toRestrictScalars_apply
@[simps apply]
def HomEquiv.toRestrictScalars {X Y} (g : (extendScalars f).obj X ⟶ Y) :
    X ⟶ (restrictScalars f).obj Y 
Arguments: {R : Type u₁} {S : Type u₂} [CommRing R] [CommRing S] (f : R →+* S) {X : ModuleCat R} {Y : ModuleCat S} (g : (ModuleCat.extendScalars f).obj X ⟶ Y) (x : ↑X)
Goal: (ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.toRestrictScalars f g) x = g (1 ⊗ₜ[R] x)
-- ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.evalAt_apply
@[simps]
def HomEquiv.evalAt {X : ModuleCat R} {Y : ModuleCat S} (s : S)
    (g : X ⟶ (restrictScalars f).obj Y) : have : Module R Y := Module.compHom Y f
    X →ₗ[R] Y 
Arguments: {R : Type u₁} {S : Type u₂} [CommRing R] [CommRing S] (f : R →+* S) {X : ModuleCat R} {Y : ModuleCat S} (s : S) (g : X ⟶ (ModuleCat.restrictScalars f).obj Y) (x : ↑X)
Goal: (ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.evalAt f s g) x = s • g x
-- ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.fromExtendScalars_apply
@[simps apply]
def HomEquiv.fromExtendScalars {X Y} (g : X ⟶ (restrictScalars f).obj Y) :
    (extendScalars f).obj X ⟶ Y 
Arguments: {R : Type u₁} {S : Type u₂} [CommRing R] [CommRing S] (f : R →+* S) {X : ModuleCat R} {Y : ModuleCat S} (g : X ⟶ (ModuleCat.restrictScalars f).obj Y) (z : ↑((ModuleCat.extendScalars f).obj X))
Goal: (ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.fromExtendScalars f g) z =
  (TensorProduct.lift
      { toFun := fun s => ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.evalAt f s g, map_add' := ⋯, map_smul' := ⋯ })
    z
-- ModuleCat.ExtendRestrictScalarsAdj.homEquiv_symm_apply
@[simps symm_apply]
def homEquiv {X Y} :
    ((extendScalars f).obj X ⟶ Y) ≃ (X ⟶ (restrictScalars.{max v u₂,u₁,u₂} f).obj Y) 
Arguments: {R : Type u₁} {S : Type u₂} [CommRing R] [CommRing S] (f : R →+* S) {X : ModuleCat R} {Y : ModuleCat S} (g : X ⟶ (ModuleCat.restrictScalars f).obj Y)
Goal: (ModuleCat.ExtendRestrictScalarsAdj.homEquiv f).symm g =
  ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.fromExtendScalars f g
-- ModuleCat.ExtendRestrictScalarsAdj.unit_app
@[simps]
def unit : 𝟭 (ModuleCat R) ⟶ extendScalars f ⋙ restrictScalars.{max v u₂,u₁,u₂} f 
Arguments: {R : Type u₁} {S : Type u₂} [CommRing R] [CommRing S] (f : R →+* S)
Goal: ∀ (x : ModuleCat R), (ModuleCat.ExtendRestrictScalarsAdj.unit f).app x = ModuleCat.ExtendRestrictScalarsAdj.Unit.map f
-- ModuleCat.ExtendRestrictScalarsAdj.Counit.map_apply
@[simps apply]
def Counit.map {Y} : (restrictScalars f ⋙ extendScalars f).obj Y ⟶ Y 
Arguments: {R : Type u₁} {S : Type u₂} [CommRing R] [CommRing S] (f : R →+* S) {Y : ModuleCat S} (a : TensorProduct R S ↑Y)
Goal: (ModuleCat.ExtendRestrictScalarsAdj.Counit.map f) a =
  (TensorProduct.lift
      { toFun := fun s => { toFun := fun y => s • y, map_add' := ⋯, map_smul' := ⋯ }, map_add' := ⋯, map_smul' := ⋯ })
    a
-- ModuleCat.ExtendRestrictScalarsAdj.counit_app
@[simps app]
def counit : restrictScalars.{max v u₂,u₁,u₂} f ⋙ extendScalars f ⟶ 𝟭 (ModuleCat S) 
Arguments: {R : Type u₁} {S : Type u₂} [CommRing R] [CommRing S] (f : R →+* S)
Goal: ∀ (x : ModuleCat S),
  (ModuleCat.ExtendRestrictScalarsAdj.counit f).app x = ModuleCat.ExtendRestrictScalarsAdj.Counit.map f
-- IsUnit.eq_on_inv
@[to_additive
  "If two homomorphisms from a subtraction monoid to an additive monoid are equal at an
  additive unit `x`, then they are equal at `-x`."]
theorem IsUnit.eq_on_inv {F G N} [DivisionMonoid G] [Monoid N] [FunLike F G N]
    [MonoidHomClass F G N] {x : G} (hx : IsUnit x) (f g : F) (h : f x = g x) : f x⁻¹ = g x⁻¹ 
Arguments: {F : Type u_1} {G : Type u_2} {N : Type u_3} [DivisionMonoid G] [Monoid N] [FunLike F G N] [MonoidHomClass F G N] {x : G} (hx : IsUnit x) (f g : F) (h : f x = g x)
Goal: f x⁻¹ = g x⁻¹