[GOAL]
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X✝ Y✝ : ModuleCat S
a₁✝ a₂✝ : X✝ ⟶ Y✝
h : (restrictScalars f).map a₁✝ = (restrictScalars f).map a₂✝
x : ↑X✝
⊢ ↑a₁✝ x = ↑a₂✝ x
[PROOFSTEP]
simpa only using FunLike.congr_fun h x
[GOAL]
R : Type u₁
S : Type u₂
inst✝² : Ring R
inst✝¹ : CommRing S
f : R →+* S
M : Type v
I : AddCommGroup M
inst✝ : Module S M
this : SMul R M
r : R
s : S
m : M
⊢ ↑f r • s • m = s • ↑f r • m
[PROOFSTEP]
simp [← mul_smul, mul_comm]
[GOAL]
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M M1 M2 : ModuleCat R
l : M1 ⟶ M2
⊢ obj' f M1 ⟶ obj' f M2
[PROOFSTEP]
apply @LinearMap.baseChange R S M1 M2 _ _ ((algebraMap S _).comp f).toAlgebra _ _ _ _ l
[GOAL]
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M✝ M : ModuleCat R
x : ↑(obj' f M)
⊢ ↑(map' f (𝟙 M)) x = ↑(𝟙 (obj' f M)) x
[PROOFSTEP]
dsimp only [map']
  -- Porting note: this got put in the dsimp by mathport
[GOAL]
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M✝ M : ModuleCat R
x : ↑(obj' f M)
⊢ ↑(LinearMap.baseChange S (𝟙 M)) x = ↑(𝟙 (obj' f M)) x
[PROOFSTEP]
rw [ModuleCat.id_apply]
[GOAL]
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M✝ M : ModuleCat R
x : ↑(obj' f M)
⊢ ↑(LinearMap.baseChange S (𝟙 M)) x = x
[PROOFSTEP]
induction' x using TensorProduct.induction_on with _ _ m s ihx ihy
[GOAL]
case zero
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M✝ M : ModuleCat R
⊢ ↑(LinearMap.baseChange S (𝟙 M)) 0 = 0
[PROOFSTEP]
rw [map_zero]
  -- Porting note: simp only [map_zero] failed
[GOAL]
case tmul
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M✝ M : ModuleCat R
x✝ : ↑((restrictScalars f).obj (ModuleCat.mk S))
y✝ : ↑M
⊢ ↑(LinearMap.baseChange S (𝟙 M)) (x✝ ⊗ₜ[R] y✝) = x✝ ⊗ₜ[R] y✝
[PROOFSTEP]
erw [@LinearMap.baseChange_tmul R S M M _ _ (_), ModuleCat.id_apply]
[GOAL]
case add
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M✝ M : ModuleCat R
m s : ↑((restrictScalars f).obj (ModuleCat.mk S)) ⊗[R] ↑M
ihx : ↑(LinearMap.baseChange S (𝟙 M)) m = m
ihy : ↑(LinearMap.baseChange S (𝟙 M)) s = s
⊢ ↑(LinearMap.baseChange S (𝟙 M)) (m + s) = m + s
[PROOFSTEP]
rw [map_add, ihx, ihy]
[GOAL]
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M M₁ M₂ M₃ : ModuleCat R
l₁₂ : M₁ ⟶ M₂
l₂₃ : M₂ ⟶ M₃
x : ↑(obj' f M₁)
⊢ ↑(map' f (l₁₂ ≫ l₂₃)) x = ↑(map' f l₁₂ ≫ map' f l₂₃) x
[PROOFSTEP]
dsimp only [map']
[GOAL]
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M M₁ M₂ M₃ : ModuleCat R
l₁₂ : M₁ ⟶ M₂
l₂₃ : M₂ ⟶ M₃
x : ↑(obj' f M₁)
⊢ ↑(LinearMap.baseChange S (l₁₂ ≫ l₂₃)) x = ↑(LinearMap.baseChange S l₁₂ ≫ LinearMap.baseChange S l₂₃) x
[PROOFSTEP]
induction' x using TensorProduct.induction_on with _ _ x y ihx ihy
[GOAL]
case zero
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M M₁ M₂ M₃ : ModuleCat R
l₁₂ : M₁ ⟶ M₂
l₂₃ : M₂ ⟶ M₃
⊢ ↑(LinearMap.baseChange S (l₁₂ ≫ l₂₃)) 0 = ↑(LinearMap.baseChange S l₁₂ ≫ LinearMap.baseChange S l₂₃) 0
[PROOFSTEP]
rfl
[GOAL]
case tmul
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M M₁ M₂ M₃ : ModuleCat R
l₁₂ : M₁ ⟶ M₂
l₂₃ : M₂ ⟶ M₃
x✝ : ↑((restrictScalars f).obj (ModuleCat.mk S))
y✝ : ↑M₁
⊢ ↑(LinearMap.baseChange S (l₁₂ ≫ l₂₃)) (x✝ ⊗ₜ[R] y✝) =
    ↑(LinearMap.baseChange S l₁₂ ≫ LinearMap.baseChange S l₂₃) (x✝ ⊗ₜ[R] y✝)
[PROOFSTEP]
rfl
[GOAL]
case add
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
M M₁ M₂ M₃ : ModuleCat R
l₁₂ : M₁ ⟶ M₂
l₂₃ : M₂ ⟶ M₃
x y : ↑((restrictScalars f).obj (ModuleCat.mk S)) ⊗[R] ↑M₁
ihx : ↑(LinearMap.baseChange S (l₁₂ ≫ l₂₃)) x = ↑(LinearMap.baseChange S l₁₂ ≫ LinearMap.baseChange S l₂₃) x
ihy : ↑(LinearMap.baseChange S (l₁₂ ≫ l₂₃)) y = ↑(LinearMap.baseChange S l₁₂ ≫ LinearMap.baseChange S l₂₃) y
⊢ ↑(LinearMap.baseChange S (l₁₂ ≫ l₂₃)) (x + y) = ↑(LinearMap.baseChange S l₁₂ ≫ LinearMap.baseChange S l₂₃) (x + y)
[PROOFSTEP]
rw [map_add, map_add, ihx, ihy]
  -- Porting note: simp again failing where rw succeeds
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝⁵ : CommRing R✝
inst✝⁴ : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝³ : Ring R
inst✝² : Ring S
f : R →+* S
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : S
g : ↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M
x y : S
⊢ (fun s' => ↑g (s' * s)) (x + y) = (fun s' => ↑g (s' * s)) x + (fun s' => ↑g (s' * s)) y
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝⁵ : CommRing R✝
inst✝⁴ : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝³ : Ring R
inst✝² : Ring S
f : R →+* S
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : S
g : ↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M
x y : S
⊢ ↑g ((x + y) * s) = ↑g (x * s) + ↑g (y * s)
[PROOFSTEP]
rw [add_mul, map_add]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝⁵ : CommRing R✝
inst✝⁴ : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝³ : Ring R
inst✝² : Ring S
f : R →+* S
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : S
g : ↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M
r : R
t : S
⊢ AddHom.toFun
      { toFun := fun s' => ↑g (s' * s),
        map_add' :=
          (_ : ∀ (x y : S), (fun s' => ↑g (s' * s)) (x + y) = (fun s' => ↑g (s' * s)) x + (fun s' => ↑g (s' * s)) y) }
      (r • t) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun s' => ↑g (s' * s),
          map_add' :=
            (_ : ∀ (x y : S), (fun s' => ↑g (s' * s)) (x + y) = (fun s' => ↑g (s' * s)) x + (fun s' => ↑g (s' * s)) y) }
        t
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝⁵ : CommRing R✝
inst✝⁴ : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝³ : Ring R
inst✝² : Ring S
f : R →+* S
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : S
g : ↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M
r : R
t : S
⊢ ↑g (r • t * s) = r • ↑g (t * s)
[PROOFSTEP]
rw [← LinearMap.map_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝⁵ : CommRing R✝
inst✝⁴ : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝³ : Ring R
inst✝² : Ring S
f : R →+* S
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : S
g : ↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M
r : R
t : S
⊢ ↑g (r • t * s) = ↑g (r • (t * s))
[PROOFSTEP]
erw [smul_eq_mul, smul_eq_mul, mul_assoc]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝⁵ : CommRing R✝
inst✝⁴ : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝³ : Ring R
inst✝² : Ring S
f : R →+* S
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
src✝ : SMul S (↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M) := hasSMul f M
g : ↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M
s : S
⊢ ↑(1 • g) s = ↑g s
[PROOFSTEP]
simp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝⁵ : CommRing R✝
inst✝⁴ : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝³ : Ring R
inst✝² : Ring S
f : R →+* S
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
src✝ : SMul S (↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M) := hasSMul f M
s t : S
g : ↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M
x : S
⊢ ↑((s * t) • g) x = ↑(s • t • g) x
[PROOFSTEP]
simp [mul_assoc]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝⁵ : CommRing R✝
inst✝⁴ : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝³ : Ring R
inst✝² : Ring S
f : R →+* S
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
src✝ : MulAction S (↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M) := mulAction f M
s t : S
⊢ ↑(s • 0) t = ↑0 t
[PROOFSTEP]
simp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝⁵ : CommRing R✝
inst✝⁴ : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝³ : Ring R
inst✝² : Ring S
f : R →+* S
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
src✝ : MulAction S (↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M) := mulAction f M
s : S
g h : ↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M
t : S
⊢ ↑(s • (g + h)) t = ↑(s • g + s • h) t
[PROOFSTEP]
simp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝⁵ : CommRing R✝
inst✝⁴ : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝³ : Ring R
inst✝² : Ring S
f : R →+* S
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
src✝ : DistribMulAction S (↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M) := distribMulAction f M
s1 s2 : S
g : ↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M
x : S
⊢ ↑((s1 + s2) • g) x = ↑(s1 • g + s2 • g) x
[PROOFSTEP]
simp [mul_add, LinearMap.map_add]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝⁵ : CommRing R✝
inst✝⁴ : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝³ : Ring R
inst✝² : Ring S
f : R →+* S
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
src✝ : DistribMulAction S (↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M) := distribMulAction f M
g : ↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] M
x : S
⊢ ↑(0 • g) x = ↑0 x
[PROOFSTEP]
simp [LinearMap.map_zero]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
M✝ : ModuleCat R
M M' : ModuleCat R
g : M ⟶ M'
s : S
h : ↑(obj' f M)
t : S
⊢ ↑(AddHom.toFun
          { toFun := fun h => LinearMap.comp g h,
            map_add' :=
              (_ : ∀ (x x_1 : ↑(obj' f M)), LinearMap.comp g (x + x_1) = LinearMap.comp g x + LinearMap.comp g x_1) }
          (s • h))
      t =
    ↑(↑(RingHom.id S) s •
          AddHom.toFun
            { toFun := fun h => LinearMap.comp g h,
              map_add' :=
                (_ : ∀ (x x_1 : ↑(obj' f M)), LinearMap.comp g (x + x_1) = LinearMap.comp g x + LinearMap.comp g x_1) }
            h)
      t
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
M✝ : ModuleCat R
M M' : ModuleCat R
g : M ⟶ M'
s : S
h : ↑(obj' f M)
t : S
⊢ ↑g (↑(s • h) t) = ↑(s • LinearMap.comp g h) t
[PROOFSTEP]
rw [smul_apply', smul_apply']
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
M✝ : ModuleCat R
M M' : ModuleCat R
g : M ⟶ M'
s : S
h : ↑(obj' f M)
t : S
⊢ ↑g (↑h (t * s)) = ↑(LinearMap.comp g h) (t * s)
[PROOFSTEP]
simp
  -- Porting note: smul_apply' not working in simp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
y : ↑Y
s1 s2 : S
⊢ (fun s => ↑g (s • y)) (s1 + s2) = (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2
[PROOFSTEP]
simp only [add_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
y : ↑Y
s1 s2 : S
⊢ ↑g (s1 • y + s2 • y) = ↑g (s1 • y) + ↑g (s2 • y)
[PROOFSTEP]
rw [LinearMap.map_add]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
y : ↑Y
r : R
s : S
⊢ AddHom.toFun
      { toFun := fun s => ↑g (s • y),
        map_add' :=
          (_ : ∀ (s1 s2 : S), (fun s => ↑g (s • y)) (s1 + s2) = (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
      (r • s) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun s => ↑g (s • y),
          map_add' :=
            (_ : ∀ (s1 s2 : S), (fun s => ↑g (s • y)) (s1 + s2) = (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
        s
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
y : ↑Y
r : R
s : S
⊢ ↑g ((r • s) • y) = r • ↑g (s • y)
[PROOFSTEP]
rw [← g.map_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
y : ↑Y
r : R
s : S
⊢ ↑g ((r • s) • y) = ↑g (r • s • y)
[PROOFSTEP]
erw [smul_eq_mul, mul_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
y : ↑Y
r : R
s : S
⊢ ↑g (↑f r • s • y) = ↑g (r • s • y)
[PROOFSTEP]
rfl
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
y1 y2 : ↑Y
s : S
⊢ ↑((fun y =>
            {
              toAddHom :=
                { toFun := fun s => ↑g (s • y),
                  map_add' :=
                    (_ :
                      ∀ (s1 s2 : S),
                        (fun s => ↑g (s • y)) (s1 + s2) = (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => ↑g (s • y),
                          map_add' :=
                            (_ :
                              ∀ (s1 s2 : S),
                                (fun s => ↑g (s • y)) (s1 + s2) = (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => ↑g (s • y),
                            map_add' :=
                              (_ :
                                ∀ (s1 s2 : S),
                                  (fun s => ↑g (s • y)) (s1 + s2) =
                                    (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                          s) })
          (y1 + y2))
      s =
    ↑((fun y =>
              {
                toAddHom :=
                  { toFun := fun s => ↑g (s • y),
                    map_add' :=
                      (_ :
                        ∀ (s1 s2 : S),
                          (fun s => ↑g (s • y)) (s1 + s2) = (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          { toFun := fun s => ↑g (s • y),
                            map_add' :=
                              (_ :
                                ∀ (s1 s2 : S),
                                  (fun s => ↑g (s • y)) (s1 + s2) =
                                    (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun s => ↑g (s • y),
                              map_add' :=
                                (_ :
                                  ∀ (s1 s2 : S),
                                    (fun s => ↑g (s • y)) (s1 + s2) =
                                      (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                            s) })
            y1 +
          (fun y =>
              {
                toAddHom :=
                  { toFun := fun s => ↑g (s • y),
                    map_add' :=
                      (_ :
                        ∀ (s1 s2 : S),
                          (fun s => ↑g (s • y)) (s1 + s2) = (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          { toFun := fun s => ↑g (s • y),
                            map_add' :=
                              (_ :
                                ∀ (s1 s2 : S),
                                  (fun s => ↑g (s • y)) (s1 + s2) =
                                    (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun s => ↑g (s • y),
                              map_add' :=
                                (_ :
                                  ∀ (s1 s2 : S),
                                    (fun s => ↑g (s • y)) (s1 + s2) =
                                      (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                            s) })
            y2)
      s
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
y1 y2 : ↑Y
s : S
⊢ ↑g (s • (y1 + y2)) =
    ↑({
            toAddHom :=
              { toFun := fun s => ↑g (s • y1),
                map_add' := (_ : ∀ (s1 s2 : S), ↑g ((s1 + s2) • y1) = ↑g (s1 • y1) + ↑g (s2 • y1)) },
            map_smul' := (_ : ∀ (r : R) (s : S), ↑g ((r • s) • y1) = r • ↑g (s • y1)) } +
          {
            toAddHom :=
              { toFun := fun s => ↑g (s • y2),
                map_add' := (_ : ∀ (s1 s2 : S), ↑g ((s1 + s2) • y2) = ↑g (s1 • y2) + ↑g (s2 • y2)) },
            map_smul' := (_ : ∀ (r : R) (s : S), ↑g ((r • s) • y2) = r • ↑g (s • y2)) })
      s
[PROOFSTEP]
rw [LinearMap.add_apply, LinearMap.coe_mk, LinearMap.coe_mk]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
y1 y2 : ↑Y
s : S
⊢ ↑g (s • (y1 + y2)) =
    ↑{ toFun := fun s => ↑g (s • y1),
            map_add' := (_ : ∀ (s1 s2 : S), ↑g ((s1 + s2) • y1) = ↑g (s1 • y1) + ↑g (s2 • y1)) }
        s +
      ↑{ toFun := fun s => ↑g (s • y2),
            map_add' := (_ : ∀ (s1 s2 : S), ↑g ((s1 + s2) • y2) = ↑g (s1 • y2) + ↑g (s2 • y2)) }
        s
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
y1 y2 : ↑Y
s : S
⊢ ↑g (s • (y1 + y2)) = ↑g (s • y1) + ↑g (s • y2)
[PROOFSTEP]
rw [smul_add, map_add]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
s : S
y : ↑Y
t : S
⊢ ↑(AddHom.toFun
          {
            toFun := fun y =>
              {
                toAddHom :=
                  { toFun := fun s => ↑g (s • y),
                    map_add' :=
                      (_ :
                        ∀ (s1 s2 : S),
                          (fun s => ↑g (s • y)) (s1 + s2) = (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          { toFun := fun s => ↑g (s • y),
                            map_add' :=
                              (_ :
                                ∀ (s1 s2 : S),
                                  (fun s => ↑g (s • y)) (s1 + s2) =
                                    (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun s => ↑g (s • y),
                              map_add' :=
                                (_ :
                                  ∀ (s1 s2 : S),
                                    (fun s => ↑g (s • y)) (s1 + s2) =
                                      (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                            s) },
            map_add' :=
              (_ :
                ∀ (y1 y2 : ↑Y),
                  (fun y =>
                        {
                          toAddHom :=
                            { toFun := fun s => ↑g (s • y),
                              map_add' :=
                                (_ :
                                  ∀ (s1 s2 : S),
                                    (fun s => ↑g (s • y)) (s1 + s2) =
                                      (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (s : S),
                                AddHom.toFun
                                    { toFun := fun s => ↑g (s • y),
                                      map_add' :=
                                        (_ :
                                          ∀ (s1 s2 : S),
                                            (fun s => ↑g (s • y)) (s1 + s2) =
                                              (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                    (r • s) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun s => ↑g (s • y),
                                        map_add' :=
                                          (_ :
                                            ∀ (s1 s2 : S),
                                              (fun s => ↑g (s • y)) (s1 + s2) =
                                                (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                      s) })
                      (y1 + y2) =
                    (fun y =>
                          {
                            toAddHom :=
                              { toFun := fun s => ↑g (s • y),
                                map_add' :=
                                  (_ :
                                    ∀ (s1 s2 : S),
                                      (fun s => ↑g (s • y)) (s1 + s2) =
                                        (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      { toFun := fun s => ↑g (s • y),
                                        map_add' :=
                                          (_ :
                                            ∀ (s1 s2 : S),
                                              (fun s => ↑g (s • y)) (s1 + s2) =
                                                (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun s => ↑g (s • y),
                                          map_add' :=
                                            (_ :
                                              ∀ (s1 s2 : S),
                                                (fun s => ↑g (s • y)) (s1 + s2) =
                                                  (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                        s) })
                        y1 +
                      (fun y =>
                          {
                            toAddHom :=
                              { toFun := fun s => ↑g (s • y),
                                map_add' :=
                                  (_ :
                                    ∀ (s1 s2 : S),
                                      (fun s => ↑g (s • y)) (s1 + s2) =
                                        (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      { toFun := fun s => ↑g (s • y),
                                        map_add' :=
                                          (_ :
                                            ∀ (s1 s2 : S),
                                              (fun s => ↑g (s • y)) (s1 + s2) =
                                                (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun s => ↑g (s • y),
                                          map_add' :=
                                            (_ :
                                              ∀ (s1 s2 : S),
                                                (fun s => ↑g (s • y)) (s1 + s2) =
                                                  (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                        s) })
                        y2) }
          (s • y))
      t =
    ↑(↑(RingHom.id S) s •
          AddHom.toFun
            {
              toFun := fun y =>
                {
                  toAddHom :=
                    { toFun := fun s => ↑g (s • y),
                      map_add' :=
                        (_ :
                          ∀ (s1 s2 : S),
                            (fun s => ↑g (s • y)) (s1 + s2) = (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) },
                  map_smul' :=
                    (_ :
                      ∀ (r : R) (s : S),
                        AddHom.toFun
                            { toFun := fun s => ↑g (s • y),
                              map_add' :=
                                (_ :
                                  ∀ (s1 s2 : S),
                                    (fun s => ↑g (s • y)) (s1 + s2) =
                                      (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                            (r • s) =
                          ↑(RingHom.id R) r •
                            AddHom.toFun
                              { toFun := fun s => ↑g (s • y),
                                map_add' :=
                                  (_ :
                                    ∀ (s1 s2 : S),
                                      (fun s => ↑g (s • y)) (s1 + s2) =
                                        (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                              s) },
              map_add' :=
                (_ :
                  ∀ (y1 y2 : ↑Y),
                    (fun y =>
                          {
                            toAddHom :=
                              { toFun := fun s => ↑g (s • y),
                                map_add' :=
                                  (_ :
                                    ∀ (s1 s2 : S),
                                      (fun s => ↑g (s • y)) (s1 + s2) =
                                        (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      { toFun := fun s => ↑g (s • y),
                                        map_add' :=
                                          (_ :
                                            ∀ (s1 s2 : S),
                                              (fun s => ↑g (s • y)) (s1 + s2) =
                                                (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun s => ↑g (s • y),
                                          map_add' :=
                                            (_ :
                                              ∀ (s1 s2 : S),
                                                (fun s => ↑g (s • y)) (s1 + s2) =
                                                  (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                        s) })
                        (y1 + y2) =
                      (fun y =>
                            {
                              toAddHom :=
                                { toFun := fun s => ↑g (s • y),
                                  map_add' :=
                                    (_ :
                                      ∀ (s1 s2 : S),
                                        (fun s => ↑g (s • y)) (s1 + s2) =
                                          (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (s : S),
                                    AddHom.toFun
                                        { toFun := fun s => ↑g (s • y),
                                          map_add' :=
                                            (_ :
                                              ∀ (s1 s2 : S),
                                                (fun s => ↑g (s • y)) (s1 + s2) =
                                                  (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                        (r • s) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun s => ↑g (s • y),
                                            map_add' :=
                                              (_ :
                                                ∀ (s1 s2 : S),
                                                  (fun s => ↑g (s • y)) (s1 + s2) =
                                                    (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                          s) })
                          y1 +
                        (fun y =>
                            {
                              toAddHom :=
                                { toFun := fun s => ↑g (s • y),
                                  map_add' :=
                                    (_ :
                                      ∀ (s1 s2 : S),
                                        (fun s => ↑g (s • y)) (s1 + s2) =
                                          (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (s : S),
                                    AddHom.toFun
                                        { toFun := fun s => ↑g (s • y),
                                          map_add' :=
                                            (_ :
                                              ∀ (s1 s2 : S),
                                                (fun s => ↑g (s • y)) (s1 + s2) =
                                                  (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                        (r • s) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun s => ↑g (s • y),
                                            map_add' :=
                                              (_ :
                                                ∀ (s1 s2 : S),
                                                  (fun s => ↑g (s • y)) (s1 + s2) =
                                                    (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
                                          s) })
                          y2) }
            y)
      t
[PROOFSTEP]
rw [RingHom.id_apply, LinearMap.coe_mk, CategoryTheory.ModuleCat.CoextendScalars.smul_apply', LinearMap.coe_mk]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
s : S
y : ↑Y
t : S
⊢ ↑{ toFun := fun s_1 => ↑g (s_1 • s • y),
          map_add' :=
            (_ :
              ∀ (s1 s2 : S),
                (fun s_1 => ↑g (s_1 • s • y)) (s1 + s2) =
                  (fun s_1 => ↑g (s_1 • s • y)) s1 + (fun s_1 => ↑g (s_1 • s • y)) s2) }
      t =
    ↑{ toFun := fun s => ↑g (s • y),
          map_add' :=
            (_ : ∀ (s1 s2 : S), (fun s => ↑g (s • y)) (s1 + s2) = (fun s => ↑g (s • y)) s1 + (fun s => ↑g (s • y)) s2) }
      (t * s)
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (restrictScalars f).obj Y ⟶ X
s : S
y : ↑Y
t : S
⊢ ↑g (t • s • y) = ↑g ((t * s) • y)
[PROOFSTEP]
rw [mul_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : Y ⟶ (coextendScalars f).obj X
x y : ↑((restrictScalars f).obj Y)
⊢ (fun y => AddHom.toFun (↑g y).toAddHom 1) (x + y) =
    (fun y => AddHom.toFun (↑g y).toAddHom 1) x + (fun y => AddHom.toFun (↑g y).toAddHom 1) y
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : Y ⟶ (coextendScalars f).obj X
x y : ↑((restrictScalars f).obj Y)
⊢ ↑(↑g (x + y)) 1 = ↑(↑g x) 1 + ↑(↑g y) 1
[PROOFSTEP]
rw [g.map_add, LinearMap.add_apply]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : Y ⟶ (coextendScalars f).obj X
r : R
y : ↑Y
⊢ AddHom.toFun
      { toFun := fun y => AddHom.toFun (↑g y).toAddHom 1,
        map_add' :=
          (_ :
            ∀ (x y : ↑((restrictScalars f).obj Y)),
              (fun y => AddHom.toFun (↑g y).toAddHom 1) (x + y) =
                (fun y => AddHom.toFun (↑g y).toAddHom 1) x + (fun y => AddHom.toFun (↑g y).toAddHom 1) y) }
      (r • y) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun y => AddHom.toFun (↑g y).toAddHom 1,
          map_add' :=
            (_ :
              ∀ (x y : ↑((restrictScalars f).obj Y)),
                (fun y => AddHom.toFun (↑g y).toAddHom 1) (x + y) =
                  (fun y => AddHom.toFun (↑g y).toAddHom 1) x + (fun y => AddHom.toFun (↑g y).toAddHom 1) y) }
        y
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : Y ⟶ (coextendScalars f).obj X
r : R
y : ↑Y
⊢ ↑(↑g (↑f r • y)) 1 = r • ↑(↑g y) 1
[PROOFSTEP]
rw [← LinearMap.map_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : Y ⟶ (coextendScalars f).obj X
r : R
y : ↑Y
⊢ ↑(↑g (↑f r • y)) 1 = ↑(↑g y) (r • 1)
[PROOFSTEP]
erw [smul_eq_mul, mul_one, LinearMap.map_smul]
  -- Porting note: should probably change CoeFun for obj above
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : Y ⟶ (coextendScalars f).obj X
r : R
y : ↑Y
⊢ ↑(↑f r • ↑g y) 1 = ↑(↑g y) (↑f r)
[PROOFSTEP]
rw [← LinearMap.coe_toAddHom, ← AddHom.toFun_eq_coe]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : Y ⟶ (coextendScalars f).obj X
r : R
y : ↑Y
⊢ AddHom.toFun (↑f r • ↑g y).toAddHom 1 = ↑(↑g y) (↑f r)
[PROOFSTEP]
rw [CoextendScalars.smul_apply (s := f r) (g := g y) (s' := 1), one_mul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : Y ⟶ (coextendScalars f).obj X
r : R
y : ↑Y
⊢ AddHom.toFun (↑g y).toAddHom (↑f r) = ↑(↑g y) (↑f r)
[PROOFSTEP]
rw [AddHom.toFun_eq_coe, LinearMap.coe_toAddHom]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y : ModuleCat S
y : ↑Y
r : R
s : S
⊢ AddHom.toFun
      { toFun := fun s => s • y,
        map_add' := (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) }
      (r • s) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun s => s • y,
          map_add' := (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) }
        s
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y : ModuleCat S
y : ↑Y
r : R
s : S
⊢ (r • s) • y = ↑f r • s • y
[PROOFSTEP]
erw [smul_eq_mul, mul_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y : ModuleCat S
y1 y2 : ↑Y
s : S
⊢ ↑((fun y =>
            {
              toAddHom :=
                { toFun := fun s => s • y,
                  map_add' :=
                    (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => s • y,
                          map_add' :=
                            (_ :
                              ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => s • y,
                            map_add' :=
                              (_ :
                                ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) }
                          s) })
          (y1 + y2))
      s =
    ↑((fun y =>
              {
                toAddHom :=
                  { toFun := fun s => s • y,
                    map_add' :=
                      (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          { toFun := fun s => s • y,
                            map_add' :=
                              (_ :
                                ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun s => s • y,
                              map_add' :=
                                (_ :
                                  ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                    (s + s') • y = s • y + s' • y) }
                            s) })
            y1 +
          (fun y =>
              {
                toAddHom :=
                  { toFun := fun s => s • y,
                    map_add' :=
                      (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          { toFun := fun s => s • y,
                            map_add' :=
                              (_ :
                                ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun s => s • y,
                              map_add' :=
                                (_ :
                                  ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                    (s + s') • y = s • y + s' • y) }
                            s) })
            y2)
      s
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y : ModuleCat S
y1 y2 : ↑Y
s : S
⊢ ↑{
          toAddHom :=
            { toFun := fun s => s • (y1 + y2),
              map_add' :=
                (_ :
                  ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                    (s + s') • (y1 + y2) = s • (y1 + y2) + s' • (y1 + y2)) },
          map_smul' := (_ : ∀ (r : R) (s : S), (↑f r * s) • (y1 + y2) = ↑f r • s • (y1 + y2)) }
      s =
    ↑({
            toAddHom :=
              { toFun := fun s => s • y1,
                map_add' :=
                  (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y1 = s • y1 + s' • y1) },
            map_smul' := (_ : ∀ (r : R) (s : S), (↑f r * s) • y1 = ↑f r • s • y1) } +
          {
            toAddHom :=
              { toFun := fun s => s • y2,
                map_add' :=
                  (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y2 = s • y2 + s' • y2) },
            map_smul' := (_ : ∀ (r : R) (s : S), (↑f r * s) • y2 = ↑f r • s • y2) })
      s
[PROOFSTEP]
rw [LinearMap.add_apply, LinearMap.coe_mk, LinearMap.coe_mk, LinearMap.coe_mk]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y : ModuleCat S
y1 y2 : ↑Y
s : S
⊢ ↑{ toFun := fun s => s • (y1 + y2),
          map_add' :=
            (_ :
              ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                (s + s') • (y1 + y2) = s • (y1 + y2) + s' • (y1 + y2)) }
      s =
    ↑{ toFun := fun s => s • y1,
            map_add' := (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y1 = s • y1 + s' • y1) }
        s +
      ↑{ toFun := fun s => s • y2,
            map_add' := (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y2 = s • y2 + s' • y2) }
        s
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y : ModuleCat S
y1 y2 : ↑Y
s : S
⊢ s • (y1 + y2) = s • y1 + s • y2
[PROOFSTEP]
rw [smul_add]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y : ModuleCat S
s : S
y : ↑Y
t : S
⊢ ↑(AddHom.toFun
          {
            toFun := fun y =>
              {
                toAddHom :=
                  { toFun := fun s => s • y,
                    map_add' :=
                      (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          { toFun := fun s => s • y,
                            map_add' :=
                              (_ :
                                ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun s => s • y,
                              map_add' :=
                                (_ :
                                  ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                    (s + s') • y = s • y + s' • y) }
                            s) },
            map_add' :=
              (_ :
                ∀ (y1 y2 : ↑Y),
                  (fun y =>
                        {
                          toAddHom :=
                            { toFun := fun s => s • y,
                              map_add' :=
                                (_ :
                                  ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                    (s + s') • y = s • y + s' • y) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (s : S),
                                AddHom.toFun
                                    { toFun := fun s => s • y,
                                      map_add' :=
                                        (_ :
                                          ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                            (s + s') • y = s • y + s' • y) }
                                    (r • s) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun s => s • y,
                                        map_add' :=
                                          (_ :
                                            ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                              (s + s') • y = s • y + s' • y) }
                                      s) })
                      (y1 + y2) =
                    (fun y =>
                          {
                            toAddHom :=
                              { toFun := fun s => s • y,
                                map_add' :=
                                  (_ :
                                    ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                      (s + s') • y = s • y + s' • y) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      { toFun := fun s => s • y,
                                        map_add' :=
                                          (_ :
                                            ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                              (s + s') • y = s • y + s' • y) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun s => s • y,
                                          map_add' :=
                                            (_ :
                                              ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                                (s + s') • y = s • y + s' • y) }
                                        s) })
                        y1 +
                      (fun y =>
                          {
                            toAddHom :=
                              { toFun := fun s => s • y,
                                map_add' :=
                                  (_ :
                                    ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                      (s + s') • y = s • y + s' • y) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      { toFun := fun s => s • y,
                                        map_add' :=
                                          (_ :
                                            ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                              (s + s') • y = s • y + s' • y) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun s => s • y,
                                          map_add' :=
                                            (_ :
                                              ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                                (s + s') • y = s • y + s' • y) }
                                        s) })
                        y2) }
          (s • y))
      t =
    ↑(↑(RingHom.id S) s •
          AddHom.toFun
            {
              toFun := fun y =>
                {
                  toAddHom :=
                    { toFun := fun s => s • y,
                      map_add' :=
                        (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) },
                  map_smul' :=
                    (_ :
                      ∀ (r : R) (s : S),
                        AddHom.toFun
                            { toFun := fun s => s • y,
                              map_add' :=
                                (_ :
                                  ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                    (s + s') • y = s • y + s' • y) }
                            (r • s) =
                          ↑(RingHom.id R) r •
                            AddHom.toFun
                              { toFun := fun s => s • y,
                                map_add' :=
                                  (_ :
                                    ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                      (s + s') • y = s • y + s' • y) }
                              s) },
              map_add' :=
                (_ :
                  ∀ (y1 y2 : ↑Y),
                    (fun y =>
                          {
                            toAddHom :=
                              { toFun := fun s => s • y,
                                map_add' :=
                                  (_ :
                                    ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                      (s + s') • y = s • y + s' • y) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      { toFun := fun s => s • y,
                                        map_add' :=
                                          (_ :
                                            ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                              (s + s') • y = s • y + s' • y) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun s => s • y,
                                          map_add' :=
                                            (_ :
                                              ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                                (s + s') • y = s • y + s' • y) }
                                        s) })
                        (y1 + y2) =
                      (fun y =>
                            {
                              toAddHom :=
                                { toFun := fun s => s • y,
                                  map_add' :=
                                    (_ :
                                      ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                        (s + s') • y = s • y + s' • y) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (s : S),
                                    AddHom.toFun
                                        { toFun := fun s => s • y,
                                          map_add' :=
                                            (_ :
                                              ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                                (s + s') • y = s • y + s' • y) }
                                        (r • s) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun s => s • y,
                                            map_add' :=
                                              (_ :
                                                ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                                  (s + s') • y = s • y + s' • y) }
                                          s) })
                          y1 +
                        (fun y =>
                            {
                              toAddHom :=
                                { toFun := fun s => s • y,
                                  map_add' :=
                                    (_ :
                                      ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                        (s + s') • y = s • y + s' • y) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (s : S),
                                    AddHom.toFun
                                        { toFun := fun s => s • y,
                                          map_add' :=
                                            (_ :
                                              ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                                (s + s') • y = s • y + s' • y) }
                                        (r • s) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun s => s • y,
                                            map_add' :=
                                              (_ :
                                                ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))),
                                                  (s + s') • y = s • y + s' • y) }
                                          s) })
                          y2) }
            y)
      t
[PROOFSTEP]
rw [RingHom.id_apply, LinearMap.coe_mk, CoextendScalars.smul_apply', LinearMap.coe_mk]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y : ModuleCat S
s : S
y : ↑Y
t : S
⊢ ↑{ toFun := fun s_1 => s_1 • s • y,
          map_add' :=
            (_ :
              ∀ (s_1 s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s_1 + s') • s • y = s_1 • s • y + s' • s • y) }
      t =
    ↑{ toFun := fun s => s • y,
          map_add' := (_ : ∀ (s s' : ↑((restrictScalars f).obj (ModuleCat.mk S))), (s + s') • y = s • y + s' • y) }
      (t * s)
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y : ModuleCat S
s : S
y : ↑Y
t : S
⊢ t • s • y = (t * s) • y
[PROOFSTEP]
rw [mul_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
y : ↑Y
s : S
⊢ ↑(↑((𝟭 (ModuleCat S)).map g ≫ (fun Y => app' f Y) Y') y) s =
    ↑(↑((fun Y => app' f Y) Y ≫ (restrictScalars f ⋙ coextendScalars f).map g) y) s
[PROOFSTEP]
simp only [ModuleCat.coe_comp, Functor.id_map, Functor.id_obj, Functor.comp_obj, Functor.comp_map]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
y : ↑Y
s : S
⊢ ↑(↑(g ≫ app' f Y') y) s = ↑(↑(app' f Y ≫ (coextendScalars f).map ((restrictScalars f).map g)) y) s
[PROOFSTEP]
rw [coe_comp, coe_comp, Function.comp, Function.comp]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
y : ↑Y
s : S
⊢ ↑(↑(app' f Y') (↑g y)) s = ↑(↑((coextendScalars f).map ((restrictScalars f).map g)) (↑(app' f Y) y)) s
[PROOFSTEP]
conv_rhs => rw [← LinearMap.coe_toAddHom, ← AddHom.toFun_eq_coe]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
y : ↑Y
s : S
| ↑(↑((coextendScalars f).map ((restrictScalars f).map g)) (↑(app' f Y) y)) s
[PROOFSTEP]
rw [← LinearMap.coe_toAddHom, ← AddHom.toFun_eq_coe]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
y : ↑Y
s : S
| ↑(↑((coextendScalars f).map ((restrictScalars f).map g)) (↑(app' f Y) y)) s
[PROOFSTEP]
rw [← LinearMap.coe_toAddHom, ← AddHom.toFun_eq_coe]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
y : ↑Y
s : S
| ↑(↑((coextendScalars f).map ((restrictScalars f).map g)) (↑(app' f Y) y)) s
[PROOFSTEP]
rw [← LinearMap.coe_toAddHom, ← AddHom.toFun_eq_coe]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
y : ↑Y
s : S
⊢ ↑(↑(app' f Y') (↑g y)) s =
    AddHom.toFun (↑((coextendScalars f).map ((restrictScalars f).map g)) (↑(app' f Y) y)).toAddHom s
[PROOFSTEP]
erw [CoextendScalars.map_apply, AddHom.toFun_eq_coe, LinearMap.coe_toAddHom, restrictScalars.map_apply f]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
y : ↑Y
s : S
⊢ ↑(↑(app' f Y') (↑g y)) s = ↑((restrictScalars f).map g) (↑(↑(app' f Y) y).toAddHom s)
[PROOFSTEP]
change s • (g y) = g (s • y)
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
y : ↑Y
s : S
⊢ s • ↑g y = ↑g (s • y)
[PROOFSTEP]
rw [map_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)
⊢ (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
    (fun g => AddHom.toFun g.toAddHom 1) x1 + (fun g => AddHom.toFun g.toAddHom 1) x2
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)
⊢ ↑(x1 + x2) 1 = ↑x1 1 + ↑x2 1
[PROOFSTEP]
rw [LinearMap.add_apply]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
r : R
g : ↑((restrictScalars f).obj ((coextendScalars f).obj X))
⊢ AddHom.toFun
      { toFun := fun g => AddHom.toFun g.toAddHom 1,
        map_add' :=
          (_ :
            ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
              (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                (fun g => AddHom.toFun g.toAddHom 1) x1 + (fun g => AddHom.toFun g.toAddHom 1) x2) }
      (r • g) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun g => AddHom.toFun g.toAddHom 1,
          map_add' :=
            (_ :
              ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                  (fun g => AddHom.toFun g.toAddHom 1) x1 + (fun g => AddHom.toFun g.toAddHom 1) x2) }
        g
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
r : R
g : ↑((restrictScalars f).obj ((coextendScalars f).obj X))
⊢ ↑(↑f r • g) 1 = r • ↑g 1
[PROOFSTEP]
rw [← LinearMap.coe_toAddHom, ← AddHom.toFun_eq_coe]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
r : R
g : ↑((restrictScalars f).obj ((coextendScalars f).obj X))
⊢ AddHom.toFun (↑f r • g).toAddHom 1 = r • ↑g 1
[PROOFSTEP]
rw [CoextendScalars.smul_apply (s := f r) (g := g) (s' := 1), one_mul, ← LinearMap.map_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
r : R
g : ↑((restrictScalars f).obj ((coextendScalars f).obj X))
⊢ AddHom.toFun g.toAddHom (↑f r) = ↑g (r • 1)
[PROOFSTEP]
rw [← LinearMap.coe_toAddHom, ← AddHom.toFun_eq_coe]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
r : R
g : ↑((restrictScalars f).obj ((coextendScalars f).obj X))
⊢ AddHom.toFun g.toAddHom (↑f r) = AddHom.toFun g.toAddHom (r • 1)
[PROOFSTEP]
congr
[GOAL]
case e_a
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
r : R
g : ↑((restrictScalars f).obj ((coextendScalars f).obj X))
⊢ ↑f r = r • 1
[PROOFSTEP]
change f r = (f r) • (1 : S)
[GOAL]
case e_a
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat R
r : R
g : ↑((restrictScalars f).obj ((coextendScalars f).obj X))
⊢ ↑f r = ↑f r • 1
[PROOFSTEP]
rw [smul_eq_mul (a := f r) (a' := 1), mul_one]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X X' : ModuleCat R
g : X ⟶ X'
h : ↑((coextendScalars f ⋙ restrictScalars f).obj X)
⊢ ↑((coextendScalars f ⋙ restrictScalars f).map g ≫
          (fun X =>
              {
                toAddHom :=
                  { toFun := fun g => AddHom.toFun g.toAddHom 1,
                    map_add' :=
                      (_ :
                        ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                          (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                            (fun g => AddHom.toFun g.toAddHom 1) x1 + (fun g => AddHom.toFun g.toAddHom 1) x2) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (g : ↑((restrictScalars f).obj ((coextendScalars f).obj X))),
                      AddHom.toFun
                          { toFun := fun g => AddHom.toFun g.toAddHom 1,
                            map_add' :=
                              (_ :
                                ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                                  (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                                    (fun g => AddHom.toFun g.toAddHom 1) x1 + (fun g => AddHom.toFun g.toAddHom 1) x2) }
                          (r • g) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun g => AddHom.toFun g.toAddHom 1,
                              map_add' :=
                                (_ :
                                  ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                                    (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                                      (fun g => AddHom.toFun g.toAddHom 1) x1 +
                                        (fun g => AddHom.toFun g.toAddHom 1) x2) }
                            g) })
            X')
      h =
    ↑((fun X =>
              {
                toAddHom :=
                  { toFun := fun g => AddHom.toFun g.toAddHom 1,
                    map_add' :=
                      (_ :
                        ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                          (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                            (fun g => AddHom.toFun g.toAddHom 1) x1 + (fun g => AddHom.toFun g.toAddHom 1) x2) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (g : ↑((restrictScalars f).obj ((coextendScalars f).obj X))),
                      AddHom.toFun
                          { toFun := fun g => AddHom.toFun g.toAddHom 1,
                            map_add' :=
                              (_ :
                                ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                                  (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                                    (fun g => AddHom.toFun g.toAddHom 1) x1 + (fun g => AddHom.toFun g.toAddHom 1) x2) }
                          (r • g) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun g => AddHom.toFun g.toAddHom 1,
                              map_add' :=
                                (_ :
                                  ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                                    (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                                      (fun g => AddHom.toFun g.toAddHom 1) x1 +
                                        (fun g => AddHom.toFun g.toAddHom 1) x2) }
                            g) })
            X ≫
          (𝟭 (ModuleCat R)).map g)
      h
[PROOFSTEP]
rw [ModuleCat.coe_comp]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X X' : ModuleCat R
g : X ⟶ X'
h : ↑((coextendScalars f ⋙ restrictScalars f).obj X)
⊢ (↑((fun X =>
              {
                toAddHom :=
                  { toFun := fun g => AddHom.toFun g.toAddHom 1,
                    map_add' :=
                      (_ :
                        ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                          (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                            (fun g => AddHom.toFun g.toAddHom 1) x1 + (fun g => AddHom.toFun g.toAddHom 1) x2) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (g : ↑((restrictScalars f).obj ((coextendScalars f).obj X))),
                      AddHom.toFun
                          { toFun := fun g => AddHom.toFun g.toAddHom 1,
                            map_add' :=
                              (_ :
                                ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                                  (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                                    (fun g => AddHom.toFun g.toAddHom 1) x1 + (fun g => AddHom.toFun g.toAddHom 1) x2) }
                          (r • g) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun g => AddHom.toFun g.toAddHom 1,
                              map_add' :=
                                (_ :
                                  ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                                    (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                                      (fun g => AddHom.toFun g.toAddHom 1) x1 +
                                        (fun g => AddHom.toFun g.toAddHom 1) x2) }
                            g) })
            X') ∘
        ↑((coextendScalars f ⋙ restrictScalars f).map g))
      h =
    ↑((fun X =>
              {
                toAddHom :=
                  { toFun := fun g => AddHom.toFun g.toAddHom 1,
                    map_add' :=
                      (_ :
                        ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                          (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                            (fun g => AddHom.toFun g.toAddHom 1) x1 + (fun g => AddHom.toFun g.toAddHom 1) x2) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (g : ↑((restrictScalars f).obj ((coextendScalars f).obj X))),
                      AddHom.toFun
                          { toFun := fun g => AddHom.toFun g.toAddHom 1,
                            map_add' :=
                              (_ :
                                ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                                  (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                                    (fun g => AddHom.toFun g.toAddHom 1) x1 + (fun g => AddHom.toFun g.toAddHom 1) x2) }
                          (r • g) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun g => AddHom.toFun g.toAddHom 1,
                              map_add' :=
                                (_ :
                                  ∀ (x1 x2 : ↑((coextendScalars f ⋙ restrictScalars f).obj X)),
                                    (fun g => AddHom.toFun g.toAddHom 1) (x1 + x2) =
                                      (fun g => AddHom.toFun g.toAddHom 1) x1 +
                                        (fun g => AddHom.toFun g.toAddHom 1) x2) }
                            g) })
            X ≫
          (𝟭 (ModuleCat R)).map g)
      h
[PROOFSTEP]
rfl
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat S
Y : ModuleCat R
g : (restrictScalars f).obj X ⟶ Y
x : ↑X
⊢ ↑(RestrictionCoextensionAdj.HomEquiv.toRestriction f (RestrictionCoextensionAdj.HomEquiv.fromRestriction f g)) x =
    ↑g x
[PROOFSTEP]
rw [RestrictionCoextensionAdj.HomEquiv.toRestriction_apply, AddHom.toFun_eq_coe, LinearMap.coe_toAddHom,
  RestrictionCoextensionAdj.HomEquiv.fromRestriction_apply_apply, one_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat S
Y : ModuleCat R
g : X ⟶ (coextendScalars f).obj Y
x : ↑X
s : S
⊢ ↑(↑(RestrictionCoextensionAdj.HomEquiv.fromRestriction f (RestrictionCoextensionAdj.HomEquiv.toRestriction f g)) x)
      s =
    ↑(↑g x) s
[PROOFSTEP]
rw [RestrictionCoextensionAdj.HomEquiv.fromRestriction_apply_apply,
  RestrictionCoextensionAdj.HomEquiv.toRestriction_apply, AddHom.toFun_eq_coe, LinearMap.coe_toAddHom,
  LinearMap.map_smulₛₗ, RingHom.id_apply, CoextendScalars.smul_apply', one_mul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat S
Y : ModuleCat R
g : X ⟶ (coextendScalars f).obj Y
⊢ ∀ (x : ↑((restrictScalars f).obj X)),
    ↑(↑((fun X Y =>
                    { toFun := RestrictionCoextensionAdj.HomEquiv.fromRestriction f,
                      invFun := RestrictionCoextensionAdj.HomEquiv.toRestriction f,
                      left_inv :=
                        (_ :
                          ∀ (g : (restrictScalars f).obj X ⟶ Y),
                            RestrictionCoextensionAdj.HomEquiv.toRestriction f
                                (RestrictionCoextensionAdj.HomEquiv.fromRestriction f g) =
                              g),
                      right_inv :=
                        (_ :
                          ∀ (g : X ⟶ (coextendScalars f).obj Y),
                            RestrictionCoextensionAdj.HomEquiv.fromRestriction f
                                (RestrictionCoextensionAdj.HomEquiv.toRestriction f g) =
                              g) })
                  X Y).symm
            g)
        x =
      ↑((restrictScalars f).map g ≫ NatTrans.app (RestrictionCoextensionAdj.counit' f) Y) x
[PROOFSTEP]
intro x
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat S
Y : ModuleCat R
g : X ⟶ (coextendScalars f).obj Y
x : ↑((restrictScalars f).obj X)
⊢ ↑(↑((fun X Y =>
                  { toFun := RestrictionCoextensionAdj.HomEquiv.fromRestriction f,
                    invFun := RestrictionCoextensionAdj.HomEquiv.toRestriction f,
                    left_inv :=
                      (_ :
                        ∀ (g : (restrictScalars f).obj X ⟶ Y),
                          RestrictionCoextensionAdj.HomEquiv.toRestriction f
                              (RestrictionCoextensionAdj.HomEquiv.fromRestriction f g) =
                            g),
                    right_inv :=
                      (_ :
                        ∀ (g : X ⟶ (coextendScalars f).obj Y),
                          RestrictionCoextensionAdj.HomEquiv.fromRestriction f
                              (RestrictionCoextensionAdj.HomEquiv.toRestriction f g) =
                            g) })
                X Y).symm
          g)
      x =
    ↑((restrictScalars f).map g ≫ NatTrans.app (RestrictionCoextensionAdj.counit' f) Y) x
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat S
Y : ModuleCat R
g : X ⟶ (coextendScalars f).obj Y
x : ↑((restrictScalars f).obj X)
⊢ ↑(↑g x) 1 = ↑((restrictScalars f).map g ≫ NatTrans.app (RestrictionCoextensionAdj.counit' f) Y) x
[PROOFSTEP]
rw [coe_comp, Function.comp]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat S
Y : ModuleCat R
g : X ⟶ (coextendScalars f).obj Y
x : ↑((restrictScalars f).obj X)
⊢ ↑(↑g x) 1 = ↑(NatTrans.app (RestrictionCoextensionAdj.counit' f) Y) (↑((restrictScalars f).map g) x)
[PROOFSTEP]
change _ = (((restrictScalars f).map g) x).toFun (1 : S)
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
X : ModuleCat S
Y : ModuleCat R
g : X ⟶ (coextendScalars f).obj Y
x : ↑((restrictScalars f).obj X)
⊢ ↑(↑g x) 1 = AddHom.toFun (↑((restrictScalars f).map g) x).toAddHom 1
[PROOFSTEP]
rw [AddHom.toFun_eq_coe, LinearMap.coe_toAddHom, restrictScalars.map_apply]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
x✝¹ x✝ : ↑X
⊢ (fun x => ↑g (1 ⊗ₜ[R] x)) (x✝¹ + x✝) = (fun x => ↑g (1 ⊗ₜ[R] x)) x✝¹ + (fun x => ↑g (1 ⊗ₜ[R] x)) x✝
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
x✝¹ x✝ : ↑X
⊢ ↑g (1 ⊗ₜ[R] (x✝¹ + x✝)) = ↑g (1 ⊗ₜ[R] x✝¹) + ↑g (1 ⊗ₜ[R] x✝)
[PROOFSTEP]
rw [tmul_add, map_add]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
r : R
x : ↑X
⊢ AddHom.toFun
      { toFun := fun x => ↑g (1 ⊗ₜ[R] x),
        map_add' :=
          (_ :
            ∀ (x x_1 : ↑X),
              (fun x => ↑g (1 ⊗ₜ[R] x)) (x + x_1) = (fun x => ↑g (1 ⊗ₜ[R] x)) x + (fun x => ↑g (1 ⊗ₜ[R] x)) x_1) }
      (r • x) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun x => ↑g (1 ⊗ₜ[R] x),
          map_add' :=
            (_ :
              ∀ (x x_1 : ↑X),
                (fun x => ↑g (1 ⊗ₜ[R] x)) (x + x_1) = (fun x => ↑g (1 ⊗ₜ[R] x)) x + (fun x => ↑g (1 ⊗ₜ[R] x)) x_1) }
        x
[PROOFSTEP]
letI : Module R S := Module.compHom S f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
r : R
x : ↑X
this : Module R S := Module.compHom S f
⊢ AddHom.toFun
      { toFun := fun x => ↑g (1 ⊗ₜ[R] x),
        map_add' :=
          (_ :
            ∀ (x x_1 : ↑X),
              (fun x => ↑g (1 ⊗ₜ[R] x)) (x + x_1) = (fun x => ↑g (1 ⊗ₜ[R] x)) x + (fun x => ↑g (1 ⊗ₜ[R] x)) x_1) }
      (r • x) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun x => ↑g (1 ⊗ₜ[R] x),
          map_add' :=
            (_ :
              ∀ (x x_1 : ↑X),
                (fun x => ↑g (1 ⊗ₜ[R] x)) (x + x_1) = (fun x => ↑g (1 ⊗ₜ[R] x)) x + (fun x => ↑g (1 ⊗ₜ[R] x)) x_1) }
        x
[PROOFSTEP]
letI : Module R Y := Module.compHom Y f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
r : R
x : ↑X
this✝ : Module R S := Module.compHom S f
this : Module R ↑Y := Module.compHom (↑Y) f
⊢ AddHom.toFun
      { toFun := fun x => ↑g (1 ⊗ₜ[R] x),
        map_add' :=
          (_ :
            ∀ (x x_1 : ↑X),
              (fun x => ↑g (1 ⊗ₜ[R] x)) (x + x_1) = (fun x => ↑g (1 ⊗ₜ[R] x)) x + (fun x => ↑g (1 ⊗ₜ[R] x)) x_1) }
      (r • x) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun x => ↑g (1 ⊗ₜ[R] x),
          map_add' :=
            (_ :
              ∀ (x x_1 : ↑X),
                (fun x => ↑g (1 ⊗ₜ[R] x)) (x + x_1) = (fun x => ↑g (1 ⊗ₜ[R] x)) x + (fun x => ↑g (1 ⊗ₜ[R] x)) x_1) }
        x
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
r : R
x : ↑X
this✝ : Module R S := Module.compHom S f
this : Module R ↑Y := Module.compHom (↑Y) f
⊢ ↑g (1 ⊗ₜ[R] (r • x)) = ↑f r • ↑g (1 ⊗ₜ[R] x)
[PROOFSTEP]
rw [RestrictScalars.smul_def, ← LinearMap.map_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
r : R
x : ↑X
this✝ : Module R S := Module.compHom S f
this : Module R ↑Y := Module.compHom (↑Y) f
⊢ ↑g
      (1 ⊗ₜ[R]
        ↑(AddEquiv.symm (RestrictScalars.addEquiv R R ↑X))
          (↑(algebraMap R R) r • ↑(RestrictScalars.addEquiv R R ↑X) x)) =
    ↑g (↑f r • 1 ⊗ₜ[R] x)
[PROOFSTEP]
erw [tmul_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
r : R
x : ↑X
this✝ : Module R S := Module.compHom S f
this : Module R ↑Y := Module.compHom (↑Y) f
⊢ ↑g (↑(algebraMap R R) r • 1 ⊗ₜ[R] ↑(RestrictScalars.addEquiv R R ↑X) x) = ↑g (↑f r • 1 ⊗ₜ[R] x)
[PROOFSTEP]
congr
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
⊢ ∀ (x y : ↑X), (fun x => s • ↑g x) (x + y) = (fun x => s • ↑g x) x + (fun x => s • ↑g x) y
[PROOFSTEP]
intros
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
x✝ y✝ : ↑X
⊢ (fun x => s • ↑g x) (x✝ + y✝) = (fun x => s • ↑g x) x✝ + (fun x => s • ↑g x) y✝
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
x✝ y✝ : ↑X
⊢ s • ↑g (x✝ + y✝) = s • ↑g x✝ + s • ↑g y✝
[PROOFSTEP]
rw [map_add, smul_add]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
⊢ ∀ (r : R) (x : ↑X),
    AddHom.toFun
        { toFun := fun x => s • ↑g x,
          map_add' := (_ : ∀ (x y : ↑X), (fun x => s • ↑g x) (x + y) = (fun x => s • ↑g x) x + (fun x => s • ↑g x) y) }
        (r • x) =
      ↑(RingHom.id R) r •
        AddHom.toFun
          { toFun := fun x => s • ↑g x,
            map_add' :=
              (_ : ∀ (x y : ↑X), (fun x => s • ↑g x) (x + y) = (fun x => s • ↑g x) x + (fun x => s • ↑g x) y) }
          x
[PROOFSTEP]
intros r x
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
r : R
x : ↑X
⊢ AddHom.toFun
      { toFun := fun x => s • ↑g x,
        map_add' := (_ : ∀ (x y : ↑X), (fun x => s • ↑g x) (x + y) = (fun x => s • ↑g x) x + (fun x => s • ↑g x) y) }
      (r • x) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun x => s • ↑g x,
          map_add' := (_ : ∀ (x y : ↑X), (fun x => s • ↑g x) (x + y) = (fun x => s • ↑g x) x + (fun x => s • ↑g x) y) }
        x
[PROOFSTEP]
rw [AddHom.toFun_eq_coe, AddHom.coe_mk, RingHom.id_apply, LinearMap.map_smul, smul_comm r s (g x : Y)]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
⊢ (extendScalars f).obj X ⟶ Y
[PROOFSTEP]
letI m1 : Module R S := Module.compHom S f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
⊢ (extendScalars f).obj X ⟶ Y
[PROOFSTEP]
letI m2 : Module R Y := Module.compHom Y f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ (extendScalars f).obj X ⟶ Y
[PROOFSTEP]
refine { toFun := fun z => TensorProduct.lift ?_ z, map_add' := ?_, map_smul' := ?_ }
[GOAL]
case refine_1
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
z : ↑((extendScalars f).obj X)
⊢ ↑((restrictScalars f).obj (ModuleCat.mk S)) →ₗ[R] ↑X →ₗ[R] ↑Y
[PROOFSTEP]
refine
  { toFun := fun s => HomEquiv.evalAt f s g, map_add' := fun (s₁ s₂ : S) => ?_, map_smul' := fun (r : R) (s : S) => ?_ }
[GOAL]
case refine_1.refine_1
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
z : ↑((extendScalars f).obj X)
s₁ s₂ : S
⊢ (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂
[PROOFSTEP]
ext
[GOAL]
case refine_1.refine_1.h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
z : ↑((extendScalars f).obj X)
s₁ s₂ : S
x✝ : ↑X
⊢ ↑((fun s => evalAt f s g) (s₁ + s₂)) x✝ = ↑((fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) x✝
[PROOFSTEP]
dsimp
[GOAL]
case refine_1.refine_1.h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
z : ↑((extendScalars f).obj X)
s₁ s₂ : S
x✝ : ↑X
⊢ (s₁ + s₂) • ↑g x✝ = s₁ • ↑g x✝ + s₂ • ↑g x✝
[PROOFSTEP]
rw [← add_smul]
[GOAL]
case refine_1.refine_2
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
z : ↑((extendScalars f).obj X)
r : R
s : S
⊢ AddHom.toFun
      { toFun := fun s => evalAt f s g,
        map_add' :=
          (_ :
            ∀ (s₁ s₂ : S),
              (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
      (r • s) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun s => evalAt f s g,
          map_add' :=
            (_ :
              ∀ (s₁ s₂ : S),
                (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
        s
[PROOFSTEP]
ext x
[GOAL]
case refine_1.refine_2.h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
z : ↑((extendScalars f).obj X)
r : R
s : S
x : ↑X
⊢ ↑(AddHom.toFun
          { toFun := fun s => evalAt f s g,
            map_add' :=
              (_ :
                ∀ (s₁ s₂ : S),
                  (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
          (r • s))
      x =
    ↑(↑(RingHom.id R) r •
          AddHom.toFun
            { toFun := fun s => evalAt f s g,
              map_add' :=
                (_ :
                  ∀ (s₁ s₂ : S),
                    (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
            s)
      x
[PROOFSTEP]
apply mul_smul (f r) s (g x)
[GOAL]
case refine_2
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ ∀ (x y : ↑((extendScalars f).obj X)),
    (fun z =>
          ↑(lift
                {
                  toAddHom :=
                    { toFun := fun s => evalAt f s g,
                      map_add' :=
                        (_ :
                          ∀ (s₁ s₂ : S),
                            (fun s => evalAt f s g) (s₁ + s₂) =
                              (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                  map_smul' :=
                    (_ :
                      ∀ (r : R) (s : S),
                        AddHom.toFun
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                            (r • s) =
                          ↑(RingHom.id R) r •
                            AddHom.toFun
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                              s) })
            z)
        (x + y) =
      (fun z =>
            ↑(lift
                  {
                    toAddHom :=
                      { toFun := fun s => evalAt f s g,
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s => evalAt f s g) (s₁ + s₂) =
                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                    map_smul' :=
                      (_ :
                        ∀ (r : R) (s : S),
                          AddHom.toFun
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                              (r • s) =
                            ↑(RingHom.id R) r •
                              AddHom.toFun
                                { toFun := fun s => evalAt f s g,
                                  map_add' :=
                                    (_ :
                                      ∀ (s₁ s₂ : S),
                                        (fun s => evalAt f s g) (s₁ + s₂) =
                                          (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                s) })
              z)
          x +
        (fun z =>
            ↑(lift
                  {
                    toAddHom :=
                      { toFun := fun s => evalAt f s g,
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s => evalAt f s g) (s₁ + s₂) =
                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                    map_smul' :=
                      (_ :
                        ∀ (r : R) (s : S),
                          AddHom.toFun
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                              (r • s) =
                            ↑(RingHom.id R) r •
                              AddHom.toFun
                                { toFun := fun s => evalAt f s g,
                                  map_add' :=
                                    (_ :
                                      ∀ (s₁ s₂ : S),
                                        (fun s => evalAt f s g) (s₁ + s₂) =
                                          (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                s) })
              z)
          y
[PROOFSTEP]
intros z₁ z₂
[GOAL]
case refine_2
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
z₁ z₂ : ↑((extendScalars f).obj X)
⊢ (fun z =>
        ↑(lift
              {
                toAddHom :=
                  { toFun := fun s => evalAt f s g,
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          (fun s => evalAt f s g) (s₁ + s₂) =
                            (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                            s) })
          z)
      (z₁ + z₂) =
    (fun z =>
          ↑(lift
                {
                  toAddHom :=
                    { toFun := fun s => evalAt f s g,
                      map_add' :=
                        (_ :
                          ∀ (s₁ s₂ : S),
                            (fun s => evalAt f s g) (s₁ + s₂) =
                              (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                  map_smul' :=
                    (_ :
                      ∀ (r : R) (s : S),
                        AddHom.toFun
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                            (r • s) =
                          ↑(RingHom.id R) r •
                            AddHom.toFun
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                              s) })
            z)
        z₁ +
      (fun z =>
          ↑(lift
                {
                  toAddHom :=
                    { toFun := fun s => evalAt f s g,
                      map_add' :=
                        (_ :
                          ∀ (s₁ s₂ : S),
                            (fun s => evalAt f s g) (s₁ + s₂) =
                              (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                  map_smul' :=
                    (_ :
                      ∀ (r : R) (s : S),
                        AddHom.toFun
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                            (r • s) =
                          ↑(RingHom.id R) r •
                            AddHom.toFun
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                              s) })
            z)
        z₂
[PROOFSTEP]
change lift _ (z₁ + z₂) = lift _ z₁ + lift _ z₂
[GOAL]
case refine_2
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
z₁ z₂ : ↑((extendScalars f).obj X)
⊢ ↑(lift
          {
            toAddHom :=
              { toFun := fun s => evalAt f s g,
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  AddHom.toFun
                      { toFun := fun s => evalAt f s g,
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s => evalAt f s g) (s₁ + s₂) =
                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                      (r • s) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        s) })
      (z₁ + z₂) =
    ↑(lift
            {
              toAddHom :=
                { toFun := fun s => evalAt f s g,
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          s) })
        z₁ +
      ↑(lift
            {
              toAddHom :=
                { toFun := fun s => evalAt f s g,
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          s) })
        z₂
[PROOFSTEP]
rw [map_add]
[GOAL]
case refine_3
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ ∀ (r : S) (x : ↑((extendScalars f).obj X)),
    AddHom.toFun
        {
          toFun := fun z =>
            ↑(lift
                  {
                    toAddHom :=
                      { toFun := fun s => evalAt f s g,
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s => evalAt f s g) (s₁ + s₂) =
                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                    map_smul' :=
                      (_ :
                        ∀ (r : R) (s : S),
                          AddHom.toFun
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                              (r • s) =
                            ↑(RingHom.id R) r •
                              AddHom.toFun
                                { toFun := fun s => evalAt f s g,
                                  map_add' :=
                                    (_ :
                                      ∀ (s₁ s₂ : S),
                                        (fun s => evalAt f s g) (s₁ + s₂) =
                                          (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                s) })
              z,
          map_add' :=
            (_ :
              ∀ (z₁ z₂ : ↑((extendScalars f).obj X)),
                ↑(lift
                        {
                          toAddHom :=
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (s : S),
                                AddHom.toFun
                                    { toFun := fun s => evalAt f s g,
                                      map_add' :=
                                        (_ :
                                          ∀ (s₁ s₂ : S),
                                            (fun s => evalAt f s g) (s₁ + s₂) =
                                              (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                    (r • s) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun s => evalAt f s g,
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s => evalAt f s g) (s₁ + s₂) =
                                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                      s) })
                    (z₁ + z₂) =
                  ↑(lift
                          {
                            toAddHom :=
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      { toFun := fun s => evalAt f s g,
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s => evalAt f s g) (s₁ + s₂) =
                                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun s => evalAt f s g,
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s => evalAt f s g) (s₁ + s₂) =
                                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                        s) })
                      z₁ +
                    ↑(lift
                          {
                            toAddHom :=
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      { toFun := fun s => evalAt f s g,
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s => evalAt f s g) (s₁ + s₂) =
                                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun s => evalAt f s g,
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s => evalAt f s g) (s₁ + s₂) =
                                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                        s) })
                      z₂) }
        (r • x) =
      ↑(RingHom.id S) r •
        AddHom.toFun
          {
            toFun := fun z =>
              ↑(lift
                    {
                      toAddHom :=
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                      map_smul' :=
                        (_ :
                          ∀ (r : R) (s : S),
                            AddHom.toFun
                                { toFun := fun s => evalAt f s g,
                                  map_add' :=
                                    (_ :
                                      ∀ (s₁ s₂ : S),
                                        (fun s => evalAt f s g) (s₁ + s₂) =
                                          (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                (r • s) =
                              ↑(RingHom.id R) r •
                                AddHom.toFun
                                  { toFun := fun s => evalAt f s g,
                                    map_add' :=
                                      (_ :
                                        ∀ (s₁ s₂ : S),
                                          (fun s => evalAt f s g) (s₁ + s₂) =
                                            (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                  s) })
                z,
            map_add' :=
              (_ :
                ∀ (z₁ z₂ : ↑((extendScalars f).obj X)),
                  ↑(lift
                          {
                            toAddHom :=
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      { toFun := fun s => evalAt f s g,
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s => evalAt f s g) (s₁ + s₂) =
                                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun s => evalAt f s g,
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s => evalAt f s g) (s₁ + s₂) =
                                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                        s) })
                      (z₁ + z₂) =
                    ↑(lift
                            {
                              toAddHom :=
                                { toFun := fun s => evalAt f s g,
                                  map_add' :=
                                    (_ :
                                      ∀ (s₁ s₂ : S),
                                        (fun s => evalAt f s g) (s₁ + s₂) =
                                          (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (s : S),
                                    AddHom.toFun
                                        { toFun := fun s => evalAt f s g,
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s => evalAt f s g) (s₁ + s₂) =
                                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                        (r • s) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun s => evalAt f s g,
                                            map_add' :=
                                              (_ :
                                                ∀ (s₁ s₂ : S),
                                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                          s) })
                        z₁ +
                      ↑(lift
                            {
                              toAddHom :=
                                { toFun := fun s => evalAt f s g,
                                  map_add' :=
                                    (_ :
                                      ∀ (s₁ s₂ : S),
                                        (fun s => evalAt f s g) (s₁ + s₂) =
                                          (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (s : S),
                                    AddHom.toFun
                                        { toFun := fun s => evalAt f s g,
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s => evalAt f s g) (s₁ + s₂) =
                                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                        (r • s) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun s => evalAt f s g,
                                            map_add' :=
                                              (_ :
                                                ∀ (s₁ s₂ : S),
                                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                          s) })
                        z₂) }
          x
[PROOFSTEP]
intro s z
[GOAL]
case refine_3
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
z : ↑((extendScalars f).obj X)
⊢ AddHom.toFun
      {
        toFun := fun z =>
          ↑(lift
                {
                  toAddHom :=
                    { toFun := fun s => evalAt f s g,
                      map_add' :=
                        (_ :
                          ∀ (s₁ s₂ : S),
                            (fun s => evalAt f s g) (s₁ + s₂) =
                              (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                  map_smul' :=
                    (_ :
                      ∀ (r : R) (s : S),
                        AddHom.toFun
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                            (r • s) =
                          ↑(RingHom.id R) r •
                            AddHom.toFun
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                              s) })
            z,
        map_add' :=
          (_ :
            ∀ (z₁ z₂ : ↑((extendScalars f).obj X)),
              ↑(lift
                      {
                        toAddHom :=
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                        map_smul' :=
                          (_ :
                            ∀ (r : R) (s : S),
                              AddHom.toFun
                                  { toFun := fun s => evalAt f s g,
                                    map_add' :=
                                      (_ :
                                        ∀ (s₁ s₂ : S),
                                          (fun s => evalAt f s g) (s₁ + s₂) =
                                            (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                  (r • s) =
                                ↑(RingHom.id R) r •
                                  AddHom.toFun
                                    { toFun := fun s => evalAt f s g,
                                      map_add' :=
                                        (_ :
                                          ∀ (s₁ s₂ : S),
                                            (fun s => evalAt f s g) (s₁ + s₂) =
                                              (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                    s) })
                  (z₁ + z₂) =
                ↑(lift
                        {
                          toAddHom :=
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (s : S),
                                AddHom.toFun
                                    { toFun := fun s => evalAt f s g,
                                      map_add' :=
                                        (_ :
                                          ∀ (s₁ s₂ : S),
                                            (fun s => evalAt f s g) (s₁ + s₂) =
                                              (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                    (r • s) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun s => evalAt f s g,
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s => evalAt f s g) (s₁ + s₂) =
                                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                      s) })
                    z₁ +
                  ↑(lift
                        {
                          toAddHom :=
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (s : S),
                                AddHom.toFun
                                    { toFun := fun s => evalAt f s g,
                                      map_add' :=
                                        (_ :
                                          ∀ (s₁ s₂ : S),
                                            (fun s => evalAt f s g) (s₁ + s₂) =
                                              (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                    (r • s) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun s => evalAt f s g,
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s => evalAt f s g) (s₁ + s₂) =
                                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                      s) })
                    z₂) }
      (s • z) =
    ↑(RingHom.id S) s •
      AddHom.toFun
        {
          toFun := fun z =>
            ↑(lift
                  {
                    toAddHom :=
                      { toFun := fun s => evalAt f s g,
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s => evalAt f s g) (s₁ + s₂) =
                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                    map_smul' :=
                      (_ :
                        ∀ (r : R) (s : S),
                          AddHom.toFun
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                              (r • s) =
                            ↑(RingHom.id R) r •
                              AddHom.toFun
                                { toFun := fun s => evalAt f s g,
                                  map_add' :=
                                    (_ :
                                      ∀ (s₁ s₂ : S),
                                        (fun s => evalAt f s g) (s₁ + s₂) =
                                          (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                s) })
              z,
          map_add' :=
            (_ :
              ∀ (z₁ z₂ : ↑((extendScalars f).obj X)),
                ↑(lift
                        {
                          toAddHom :=
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (s : S),
                                AddHom.toFun
                                    { toFun := fun s => evalAt f s g,
                                      map_add' :=
                                        (_ :
                                          ∀ (s₁ s₂ : S),
                                            (fun s => evalAt f s g) (s₁ + s₂) =
                                              (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                    (r • s) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun s => evalAt f s g,
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s => evalAt f s g) (s₁ + s₂) =
                                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                      s) })
                    (z₁ + z₂) =
                  ↑(lift
                          {
                            toAddHom :=
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      { toFun := fun s => evalAt f s g,
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s => evalAt f s g) (s₁ + s₂) =
                                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun s => evalAt f s g,
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s => evalAt f s g) (s₁ + s₂) =
                                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                        s) })
                      z₁ +
                    ↑(lift
                          {
                            toAddHom :=
                              { toFun := fun s => evalAt f s g,
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s => evalAt f s g) (s₁ + s₂) =
                                        (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      { toFun := fun s => evalAt f s g,
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s => evalAt f s g) (s₁ + s₂) =
                                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun s => evalAt f s g,
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s => evalAt f s g) (s₁ + s₂) =
                                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                                        s) })
                      z₂) }
        z
[PROOFSTEP]
change lift _ (s • z) = s • lift _ z
[GOAL]
case refine_3
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
z : ↑((extendScalars f).obj X)
⊢ ↑(lift
          {
            toAddHom :=
              { toFun := fun s => evalAt f s g,
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  AddHom.toFun
                      { toFun := fun s => evalAt f s g,
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s => evalAt f s g) (s₁ + s₂) =
                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                      (r • s) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        s) })
      (s • z) =
    s •
      ↑(lift
            {
              toAddHom :=
                { toFun := fun s => evalAt f s g,
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          s) })
        z
[PROOFSTEP]
induction' z using TensorProduct.induction_on with s' x x y ih1 ih2
[GOAL]
case refine_3.zero
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
⊢ ↑(lift
          {
            toAddHom :=
              { toFun := fun s => evalAt f s g,
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  AddHom.toFun
                      { toFun := fun s => evalAt f s g,
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s => evalAt f s g) (s₁ + s₂) =
                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                      (r • s) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        s) })
      (s • 0) =
    s •
      ↑(lift
            {
              toAddHom :=
                { toFun := fun s => evalAt f s g,
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          s) })
        0
[PROOFSTEP]
rw [smul_zero, map_zero, smul_zero]
[GOAL]
case refine_3.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
s' : ↑((restrictScalars f).obj (ModuleCat.mk S))
x : ↑X
⊢ ↑(lift
          {
            toAddHom :=
              { toFun := fun s => evalAt f s g,
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  AddHom.toFun
                      { toFun := fun s => evalAt f s g,
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s => evalAt f s g) (s₁ + s₂) =
                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                      (r • s) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        s) })
      (s • s' ⊗ₜ[R] x) =
    s •
      ↑(lift
            {
              toAddHom :=
                { toFun := fun s => evalAt f s g,
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          s) })
        (s' ⊗ₜ[R] x)
[PROOFSTEP]
rw [LinearMap.coe_mk, ExtendScalars.smul_tmul]
[GOAL]
case refine_3.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
s' : ↑((restrictScalars f).obj (ModuleCat.mk S))
x : ↑X
⊢ ↑(lift
            {
              toAddHom :=
                { toFun := fun s => evalAt f s g,
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          s) }).toAddHom
      ((s * s') ⊗ₜ[R] x) =
    s •
      ↑(lift
              {
                toAddHom :=
                  { toFun := fun s => evalAt f s g,
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          (fun s => evalAt f s g) (s₁ + s₂) =
                            (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                            s) }).toAddHom
        (s' ⊗ₜ[R] x)
[PROOFSTEP]
erw [lift.tmul, lift.tmul]
[GOAL]
case refine_3.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
s' : ↑((restrictScalars f).obj (ModuleCat.mk S))
x : ↑X
⊢ ↑(↑{
              toAddHom :=
                { toFun := fun s => evalAt f s g,
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          s) }
          (s * s'))
      x =
    s •
      ↑(↑{
                toAddHom :=
                  { toFun := fun s => evalAt f s g,
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          (fun s => evalAt f s g) (s₁ + s₂) =
                            (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                            s) }
            s')
        x
[PROOFSTEP]
set s' : S := s'
[GOAL]
case refine_3.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
s'✝ : ↑((restrictScalars f).obj (ModuleCat.mk S))
x : ↑X
s' : S := s'✝
⊢ ↑(↑{
              toAddHom :=
                { toFun := fun s => evalAt f s g,
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          s) }
          (s * s'))
      x =
    s •
      ↑(↑{
                toAddHom :=
                  { toFun := fun s => evalAt f s g,
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          (fun s => evalAt f s g) (s₁ + s₂) =
                            (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun s => evalAt f s g,
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s => evalAt f s g) (s₁ + s₂) =
                                      (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                            s) }
            s')
        x
[PROOFSTEP]
change (s * s') • (g x) = s • s' • (g x)
[GOAL]
case refine_3.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
s'✝ : ↑((restrictScalars f).obj (ModuleCat.mk S))
x : ↑X
s' : S := s'✝
⊢ (s * s') • ↑g x = s • s' • ↑g x
[PROOFSTEP]
rw [mul_smul]
[GOAL]
case refine_3.add
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
x y : ↑((restrictScalars f).obj (ModuleCat.mk S)) ⊗[R] ↑X
ih1 :
  ↑(lift
          {
            toAddHom :=
              { toFun := fun s => evalAt f s g,
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  AddHom.toFun
                      { toFun := fun s => evalAt f s g,
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s => evalAt f s g) (s₁ + s₂) =
                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                      (r • s) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        s) })
      (s • x) =
    s •
      ↑(lift
            {
              toAddHom :=
                { toFun := fun s => evalAt f s g,
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          s) })
        x
ih2 :
  ↑(lift
          {
            toAddHom :=
              { toFun := fun s => evalAt f s g,
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  AddHom.toFun
                      { toFun := fun s => evalAt f s g,
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s => evalAt f s g) (s₁ + s₂) =
                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                      (r • s) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        s) })
      (s • y) =
    s •
      ↑(lift
            {
              toAddHom :=
                { toFun := fun s => evalAt f s g,
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          s) })
        y
⊢ ↑(lift
          {
            toAddHom :=
              { toFun := fun s => evalAt f s g,
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  AddHom.toFun
                      { toFun := fun s => evalAt f s g,
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s => evalAt f s g) (s₁ + s₂) =
                                (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                      (r • s) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        s) })
      (s • (x + y)) =
    s •
      ↑(lift
            {
              toAddHom :=
                { toFun := fun s => evalAt f s g,
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => evalAt f s g) (s₁ + s₂) = (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => evalAt f s g,
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => evalAt f s g) (s₁ + s₂) =
                                  (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => evalAt f s g,
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => evalAt f s g) (s₁ + s₂) =
                                    (fun s => evalAt f s g) s₁ + (fun s => evalAt f s g) s₂) }
                          s) })
        (x + y)
[PROOFSTEP]
rw [smul_add, map_add, ih1, ih2, map_add, smul_add]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
⊢ HomEquiv.fromExtendScalars f (HomEquiv.toRestrictScalars f g) = g
[PROOFSTEP]
letI m1 : Module R S := Module.compHom S f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
m1 : Module R S := Module.compHom S f
⊢ HomEquiv.fromExtendScalars f (HomEquiv.toRestrictScalars f g) = g
[PROOFSTEP]
letI m2 : Module R Y := Module.compHom Y f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ HomEquiv.fromExtendScalars f (HomEquiv.toRestrictScalars f g) = g
[PROOFSTEP]
apply LinearMap.ext
[GOAL]
case h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ ∀ (x : ↑((extendScalars f).obj X)), ↑(HomEquiv.fromExtendScalars f (HomEquiv.toRestrictScalars f g)) x = ↑g x
[PROOFSTEP]
intro z
[GOAL]
case h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
z : ↑((extendScalars f).obj X)
⊢ ↑(HomEquiv.fromExtendScalars f (HomEquiv.toRestrictScalars f g)) z = ↑g z
[PROOFSTEP]
induction' z using TensorProduct.induction_on with x s z1 z2 ih1 ih2
[GOAL]
case h.zero
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ ↑(HomEquiv.fromExtendScalars f (HomEquiv.toRestrictScalars f g)) 0 = ↑g 0
[PROOFSTEP]
rw [map_zero, map_zero]
[GOAL]
case h.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
x : ↑((restrictScalars f).obj (ModuleCat.mk S))
s : ↑X
⊢ ↑(HomEquiv.fromExtendScalars f (HomEquiv.toRestrictScalars f g)) (x ⊗ₜ[R] s) = ↑g (x ⊗ₜ[R] s)
[PROOFSTEP]
erw [TensorProduct.lift.tmul]
[GOAL]
case h.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
x : ↑((restrictScalars f).obj (ModuleCat.mk S))
s : ↑X
⊢ ↑(↑{
              toAddHom :=
                { toFun := fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g),
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) (s₁ + s₂) =
                          (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) s₁ +
                            (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        { toFun := fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g),
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) (s₁ + s₂) =
                                  (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) s₁ +
                                    (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g),
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) (s₁ + s₂) =
                                    (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) s₁ +
                                      (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) s₂) }
                          s) }
          x)
      s =
    ↑g (x ⊗ₜ[R] s)
[PROOFSTEP]
simp only [LinearMap.coe_mk]
[GOAL]
case h.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
x : ↑((restrictScalars f).obj (ModuleCat.mk S))
s : ↑X
⊢ ↑(↑{ toFun := fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g),
              map_add' :=
                (_ :
                  ∀ (s₁ s₂ : S),
                    (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) (s₁ + s₂) =
                      (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) s₁ +
                        (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) s₂) }
          x)
      s =
    ↑g (x ⊗ₜ[R] s)
[PROOFSTEP]
change S at x
[GOAL]
case h.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : ↑X
x : S
⊢ ↑(↑{ toFun := fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g),
              map_add' :=
                (_ :
                  ∀ (s₁ s₂ : S),
                    (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) (s₁ + s₂) =
                      (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) s₁ +
                        (fun s => HomEquiv.evalAt f s (HomEquiv.toRestrictScalars f g)) s₂) }
          x)
      s =
    ↑g (x ⊗ₜ[R] s)
[PROOFSTEP]
dsimp
[GOAL]
case h.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : ↑X
x : S
⊢ x • ↑(HomEquiv.toRestrictScalars f g) s = ↑g (x ⊗ₜ[R] s)
[PROOFSTEP]
erw [← LinearMap.map_smul, ExtendScalars.smul_tmul, mul_one x]
[GOAL]
case h.add
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
z1 z2 : ↑((restrictScalars f).obj (ModuleCat.mk S)) ⊗[R] ↑X
ih1 : ↑(HomEquiv.fromExtendScalars f (HomEquiv.toRestrictScalars f g)) z1 = ↑g z1
ih2 : ↑(HomEquiv.fromExtendScalars f (HomEquiv.toRestrictScalars f g)) z2 = ↑g z2
⊢ ↑(HomEquiv.fromExtendScalars f (HomEquiv.toRestrictScalars f g)) (z1 + z2) = ↑g (z1 + z2)
[PROOFSTEP]
rw [map_add, map_add, ih1, ih2]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
⊢ HomEquiv.toRestrictScalars f (HomEquiv.fromExtendScalars f g) = g
[PROOFSTEP]
letI m1 : Module R S := Module.compHom S f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
⊢ HomEquiv.toRestrictScalars f (HomEquiv.fromExtendScalars f g) = g
[PROOFSTEP]
letI m2 : Module R Y := Module.compHom Y f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ HomEquiv.toRestrictScalars f (HomEquiv.fromExtendScalars f g) = g
[PROOFSTEP]
apply LinearMap.ext
[GOAL]
case h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ ∀ (x : ↑X), ↑(HomEquiv.toRestrictScalars f (HomEquiv.fromExtendScalars f g)) x = ↑g x
[PROOFSTEP]
intro x
[GOAL]
case h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
x : ↑X
⊢ ↑(HomEquiv.toRestrictScalars f (HomEquiv.fromExtendScalars f g)) x = ↑g x
[PROOFSTEP]
rw [HomEquiv.toRestrictScalars_apply, HomEquiv.fromExtendScalars_apply, lift.tmul, LinearMap.coe_mk, LinearMap.coe_mk]
[GOAL]
case h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
x : ↑X
⊢ ↑(↑{ toFun := fun s => HomEquiv.evalAt f s g,
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s => HomEquiv.evalAt f s g) (s₁ + s₂) =
                        (fun s => HomEquiv.evalAt f s g) s₁ + (fun s => HomEquiv.evalAt f s g) s₂) }
            1).toAddHom
      x =
    ↑g x
[PROOFSTEP]
dsimp
[GOAL]
case h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
x : ↑X
⊢ 1 • ↑g x = ↑g x
[PROOFSTEP]
rw [one_smul]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
x x' : ↑X
⊢ (fun x => 1 ⊗ₜ[R] x) (x + x') = (fun x => 1 ⊗ₜ[R] x) x + (fun x => 1 ⊗ₜ[R] x) x'
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
x x' : ↑X
⊢ 1 ⊗ₜ[R] (x + x') = 1 ⊗ₜ[R] x + 1 ⊗ₜ[R] x'
[PROOFSTEP]
rw [TensorProduct.tmul_add]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
r : R
x : ↑X
⊢ AddHom.toFun
      { toFun := fun x => 1 ⊗ₜ[R] x,
        map_add' :=
          (_ : ∀ (x x' : ↑X), (fun x => 1 ⊗ₜ[R] x) (x + x') = (fun x => 1 ⊗ₜ[R] x) x + (fun x => 1 ⊗ₜ[R] x) x') }
      (r • x) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun x => 1 ⊗ₜ[R] x,
          map_add' :=
            (_ : ∀ (x x' : ↑X), (fun x => 1 ⊗ₜ[R] x) (x + x') = (fun x => 1 ⊗ₜ[R] x) x + (fun x => 1 ⊗ₜ[R] x) x') }
        x
[PROOFSTEP]
letI m1 : Module R S := Module.compHom S f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
r : R
x : ↑X
m1 : Module R S := Module.compHom S f
⊢ AddHom.toFun
      { toFun := fun x => 1 ⊗ₜ[R] x,
        map_add' :=
          (_ : ∀ (x x' : ↑X), (fun x => 1 ⊗ₜ[R] x) (x + x') = (fun x => 1 ⊗ₜ[R] x) x + (fun x => 1 ⊗ₜ[R] x) x') }
      (r • x) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        { toFun := fun x => 1 ⊗ₜ[R] x,
          map_add' :=
            (_ : ∀ (x x' : ↑X), (fun x => 1 ⊗ₜ[R] x) (x + x') = (fun x => 1 ⊗ₜ[R] x) x + (fun x => 1 ⊗ₜ[R] x) x') }
        x
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
r : R
x : ↑X
m1 : Module R S := Module.compHom S f
⊢ 1 ⊗ₜ[R] (r • x) = r • 1 ⊗ₜ[R] x
[PROOFSTEP]
rw [← TensorProduct.smul_tmul, TensorProduct.smul_tmul']
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
⊢ (restrictScalars f ⋙ extendScalars f).obj Y ⟶ Y
[PROOFSTEP]
letI m1 : Module R S := Module.compHom S f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
⊢ (restrictScalars f ⋙ extendScalars f).obj Y ⟶ Y
[PROOFSTEP]
letI m2 : Module R Y := Module.compHom Y f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ (restrictScalars f ⋙ extendScalars f).obj Y ⟶ Y
[PROOFSTEP]
refine'
  {
    toFun :=
      TensorProduct.lift
        { toFun := fun s : S => { toFun := fun y : Y => s • y, map_add' := smul_add _, map_smul' := _ }, map_add' := _,
          map_smul' := _ },
    map_add' := _, map_smul' := _ }
[GOAL]
case refine'_1
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
⊢ ∀ (r : R) (x : ↑Y),
    AddHom.toFun { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
        (r • x) =
      ↑(RingHom.id R) r •
        AddHom.toFun { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) } x
[PROOFSTEP]
intros r y
[GOAL]
case refine'_1
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
r : R
y : ↑Y
⊢ AddHom.toFun { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) } (r • y) =
    ↑(RingHom.id R) r •
      AddHom.toFun { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) } y
[PROOFSTEP]
dsimp
[GOAL]
case refine'_1
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
r : R
y : ↑Y
⊢ s • r • y = r • s • y
[PROOFSTEP]
change s • f r • y = f r • s • y
[GOAL]
case refine'_1
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
r : R
y : ↑Y
⊢ s • ↑f r • y = ↑f r • s • y
[PROOFSTEP]
rw [← mul_smul, mul_comm, mul_smul]
[GOAL]
case refine'_2
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ ∀ (x y : S),
    (fun s =>
          { toAddHom := { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (y : ↑Y),
                  AddHom.toFun
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                      (r • y) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                        y) })
        (x + y) =
      (fun s =>
            {
              toAddHom :=
                { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (y : ↑Y),
                    AddHom.toFun
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                        (r • y) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                          y) })
          x +
        (fun s =>
            {
              toAddHom :=
                { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (y : ↑Y),
                    AddHom.toFun
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                        (r • y) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                          y) })
          y
[PROOFSTEP]
intros s₁ s₂
[GOAL]
case refine'_2
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s₁ s₂ : S
⊢ (fun s =>
        { toAddHom := { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
          map_smul' :=
            (_ :
              ∀ (r : R) (y : ↑Y),
                AddHom.toFun
                    { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                    (r • y) =
                  ↑(RingHom.id R) r •
                    AddHom.toFun
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                      y) })
      (s₁ + s₂) =
    (fun s =>
          { toAddHom := { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (y : ↑Y),
                  AddHom.toFun
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                      (r • y) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                        y) })
        s₁ +
      (fun s =>
          { toAddHom := { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (y : ↑Y),
                  AddHom.toFun
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                      (r • y) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                        y) })
        s₂
[PROOFSTEP]
ext y
[GOAL]
case refine'_2.h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s₁ s₂ : S
y : ↑Y
⊢ ↑((fun s =>
            {
              toAddHom :=
                { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (y : ↑Y),
                    AddHom.toFun
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                        (r • y) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                          y) })
          (s₁ + s₂))
      y =
    ↑((fun s =>
              {
                toAddHom :=
                  { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (y : ↑Y),
                      AddHom.toFun
                          { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                          (r • y) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                            y) })
            s₁ +
          (fun s =>
              {
                toAddHom :=
                  { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (y : ↑Y),
                      AddHom.toFun
                          { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                          (r • y) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                            y) })
            s₂)
      y
[PROOFSTEP]
change (s₁ + s₂) • y = s₁ • y + s₂ • y
[GOAL]
case refine'_2.h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s₁ s₂ : S
y : ↑Y
⊢ (s₁ + s₂) • y = s₁ • y + s₂ • y
[PROOFSTEP]
rw [add_smul]
[GOAL]
case refine'_3
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ ∀ (r : R) (x : S),
    AddHom.toFun
        {
          toFun := fun s =>
            {
              toAddHom :=
                { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (y : ↑Y),
                    AddHom.toFun
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                        (r • y) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                          y) },
          map_add' :=
            (_ :
              ∀ (s₁ s₂ : S),
                (fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' :=
                          (_ :
                            ∀ (r : R) (y : ↑Y),
                              AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  (r • y) =
                                ↑(RingHom.id R) r •
                                  AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    y) })
                    (s₁ + s₂) =
                  (fun s =>
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (y : ↑Y),
                                AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    (r • y) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      y) })
                      s₁ +
                    (fun s =>
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (y : ↑Y),
                                AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    (r • y) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      y) })
                      s₂) }
        (r • x) =
      ↑(RingHom.id R) r •
        AddHom.toFun
          {
            toFun := fun s =>
              {
                toAddHom :=
                  { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (y : ↑Y),
                      AddHom.toFun
                          { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                          (r • y) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                            y) },
            map_add' :=
              (_ :
                ∀ (s₁ s₂ : S),
                  (fun s =>
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (y : ↑Y),
                                AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    (r • y) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      y) })
                      (s₁ + s₂) =
                    (fun s =>
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (y : ↑Y),
                                  AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      (r • y) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        y) })
                        s₁ +
                      (fun s =>
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (y : ↑Y),
                                  AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      (r • y) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        y) })
                        s₂) }
          x
[PROOFSTEP]
intros r s
[GOAL]
case refine'_3
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
r : R
s : S
⊢ AddHom.toFun
      {
        toFun := fun s =>
          { toAddHom := { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (y : ↑Y),
                  AddHom.toFun
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                      (r • y) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                        y) },
        map_add' :=
          (_ :
            ∀ (s₁ s₂ : S),
              (fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' :=
                        (_ :
                          ∀ (r : R) (y : ↑Y),
                            AddHom.toFun
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                (r • y) =
                              ↑(RingHom.id R) r •
                                AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  y) })
                  (s₁ + s₂) =
                (fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' :=
                          (_ :
                            ∀ (r : R) (y : ↑Y),
                              AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  (r • y) =
                                ↑(RingHom.id R) r •
                                  AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    y) })
                    s₁ +
                  (fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' :=
                          (_ :
                            ∀ (r : R) (y : ↑Y),
                              AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  (r • y) =
                                ↑(RingHom.id R) r •
                                  AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    y) })
                    s₂) }
      (r • s) =
    ↑(RingHom.id R) r •
      AddHom.toFun
        {
          toFun := fun s =>
            {
              toAddHom :=
                { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (y : ↑Y),
                    AddHom.toFun
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                        (r • y) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                          y) },
          map_add' :=
            (_ :
              ∀ (s₁ s₂ : S),
                (fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' :=
                          (_ :
                            ∀ (r : R) (y : ↑Y),
                              AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  (r • y) =
                                ↑(RingHom.id R) r •
                                  AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    y) })
                    (s₁ + s₂) =
                  (fun s =>
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (y : ↑Y),
                                AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    (r • y) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      y) })
                      s₁ +
                    (fun s =>
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (y : ↑Y),
                                AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    (r • y) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      y) })
                      s₂) }
        s
[PROOFSTEP]
ext y
[GOAL]
case refine'_3.h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
r : R
s : S
y : ↑Y
⊢ ↑(AddHom.toFun
          {
            toFun := fun s =>
              {
                toAddHom :=
                  { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (y : ↑Y),
                      AddHom.toFun
                          { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                          (r • y) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                            y) },
            map_add' :=
              (_ :
                ∀ (s₁ s₂ : S),
                  (fun s =>
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (y : ↑Y),
                                AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    (r • y) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      y) })
                      (s₁ + s₂) =
                    (fun s =>
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (y : ↑Y),
                                  AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      (r • y) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        y) })
                        s₁ +
                      (fun s =>
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (y : ↑Y),
                                  AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      (r • y) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        y) })
                        s₂) }
          (r • s))
      y =
    ↑(↑(RingHom.id R) r •
          AddHom.toFun
            {
              toFun := fun s =>
                {
                  toAddHom :=
                    { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                  map_smul' :=
                    (_ :
                      ∀ (r : R) (y : ↑Y),
                        AddHom.toFun
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                            (r • y) =
                          ↑(RingHom.id R) r •
                            AddHom.toFun
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                              y) },
              map_add' :=
                (_ :
                  ∀ (s₁ s₂ : S),
                    (fun s =>
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (y : ↑Y),
                                  AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      (r • y) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        y) })
                        (s₁ + s₂) =
                      (fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) })
                          s₁ +
                        (fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) })
                          s₂) }
            s)
      y
[PROOFSTEP]
change (f r • s) • y = (f r) • s • y
[GOAL]
case refine'_3.h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
r : R
s : S
y : ↑Y
⊢ (↑f r • s) • y = ↑f r • s • y
[PROOFSTEP]
rw [smul_eq_mul, mul_smul]
[GOAL]
case refine'_4
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ ∀ (x y : ↑((restrictScalars f ⋙ extendScalars f).obj Y)),
    ↑(lift
            {
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' :=
                        (_ :
                          ∀ (r : R) (y : ↑Y),
                            AddHom.toFun
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                (r • y) =
                              ↑(RingHom.id R) r •
                                AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            (s₁ + s₂) =
                          (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              s₁ +
                            (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        {
                          toFun := fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) },
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    (s₁ + s₂) =
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₁ +
                                    (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          {
                            toFun := fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) },
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      (s₁ + s₂) =
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₁ +
                                      (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₂) }
                          s) })
        (x + y) =
      ↑(lift
              {
                toAddHom :=
                  {
                    toFun := fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' :=
                          (_ :
                            ∀ (r : R) (y : ↑Y),
                              AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  (r • y) =
                                ↑(RingHom.id R) r •
                                  AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    y) },
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              (s₁ + s₂) =
                            (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                s₁ +
                              (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                s₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          {
                            toFun := fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) },
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      (s₁ + s₂) =
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₁ +
                                      (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₂) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            {
                              toFun := fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) },
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        (s₁ + s₂) =
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₁ +
                                        (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₂) }
                            s) })
          x +
        ↑(lift
              {
                toAddHom :=
                  {
                    toFun := fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' :=
                          (_ :
                            ∀ (r : R) (y : ↑Y),
                              AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  (r • y) =
                                ↑(RingHom.id R) r •
                                  AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    y) },
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              (s₁ + s₂) =
                            (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                s₁ +
                              (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                s₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          {
                            toFun := fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) },
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      (s₁ + s₂) =
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₁ +
                                      (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₂) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            {
                              toFun := fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) },
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        (s₁ + s₂) =
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₁ +
                                        (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₂) }
                            s) })
          y
[PROOFSTEP]
intros
[GOAL]
case refine'_4
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
x✝ y✝ : ↑((restrictScalars f ⋙ extendScalars f).obj Y)
⊢ ↑(lift
          {
            toAddHom :=
              {
                toFun := fun s =>
                  {
                    toAddHom :=
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                    map_smul' :=
                      (_ :
                        ∀ (r : R) (y : ↑Y),
                          AddHom.toFun
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                              (r • y) =
                            ↑(RingHom.id R) r •
                              AddHom.toFun
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                y) },
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) })
                          (s₁ + s₂) =
                        (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            s₁ +
                          (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            s₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  AddHom.toFun
                      {
                        toFun := fun s =>
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (y : ↑Y),
                                  AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      (r • y) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        y) },
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s =>
                                    {
                                      toAddHom :=
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                      map_smul' :=
                                        (_ :
                                          ∀ (r : R) (y : ↑Y),
                                            AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                (r • y) =
                                              ↑(RingHom.id R) r •
                                                AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  y) })
                                  (s₁ + s₂) =
                                (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    s₁ +
                                  (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    s₂) }
                      (r • s) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        {
                          toFun := fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) },
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    (s₁ + s₂) =
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₁ +
                                    (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₂) }
                        s) })
      (x✝ + y✝) =
    ↑(lift
            {
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' :=
                        (_ :
                          ∀ (r : R) (y : ↑Y),
                            AddHom.toFun
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                (r • y) =
                              ↑(RingHom.id R) r •
                                AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            (s₁ + s₂) =
                          (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              s₁ +
                            (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        {
                          toFun := fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) },
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    (s₁ + s₂) =
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₁ +
                                    (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          {
                            toFun := fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) },
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      (s₁ + s₂) =
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₁ +
                                      (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₂) }
                          s) })
        x✝ +
      ↑(lift
            {
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' :=
                        (_ :
                          ∀ (r : R) (y : ↑Y),
                            AddHom.toFun
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                (r • y) =
                              ↑(RingHom.id R) r •
                                AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            (s₁ + s₂) =
                          (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              s₁ +
                            (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        {
                          toFun := fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) },
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    (s₁ + s₂) =
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₁ +
                                    (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          {
                            toFun := fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) },
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      (s₁ + s₂) =
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₁ +
                                      (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₂) }
                          s) })
        y✝
[PROOFSTEP]
rw [map_add]
[GOAL]
case refine'_5
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ ∀ (r : S) (x : ↑((restrictScalars f ⋙ extendScalars f).obj Y)),
    AddHom.toFun
        {
          toFun :=
            ↑(lift
                {
                  toAddHom :=
                    {
                      toFun := fun s =>
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (y : ↑Y),
                                AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    (r • y) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      y) },
                      map_add' :=
                        (_ :
                          ∀ (s₁ s₂ : S),
                            (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                (s₁ + s₂) =
                              (fun s =>
                                    {
                                      toAddHom :=
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                      map_smul' :=
                                        (_ :
                                          ∀ (r : R) (y : ↑Y),
                                            AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                (r • y) =
                                              ↑(RingHom.id R) r •
                                                AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  y) })
                                  s₁ +
                                (fun s =>
                                    {
                                      toAddHom :=
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                      map_smul' :=
                                        (_ :
                                          ∀ (r : R) (y : ↑Y),
                                            AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                (r • y) =
                                              ↑(RingHom.id R) r •
                                                AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  y) })
                                  s₂) },
                  map_smul' :=
                    (_ :
                      ∀ (r : R) (s : S),
                        AddHom.toFun
                            {
                              toFun := fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) },
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        (s₁ + s₂) =
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₁ +
                                        (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₂) }
                            (r • s) =
                          ↑(RingHom.id R) r •
                            AddHom.toFun
                              {
                                toFun := fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) },
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          (s₁ + s₂) =
                                        (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₁ +
                                          (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₂) }
                              s) }),
          map_add' :=
            (_ :
              ∀ (x y : ↑((restrictScalars f ⋙ extendScalars f).obj Y)),
                ↑(lift
                        {
                          toAddHom :=
                            {
                              toFun := fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) },
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        (s₁ + s₂) =
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₁ +
                                        (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (s : S),
                                AddHom.toFun
                                    {
                                      toFun := fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) },
                                      map_add' :=
                                        (_ :
                                          ∀ (s₁ s₂ : S),
                                            (fun s =>
                                                  {
                                                    toAddHom :=
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                    map_smul' :=
                                                      (_ :
                                                        ∀ (r : R) (y : ↑Y),
                                                          AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              (r • y) =
                                                            ↑(RingHom.id R) r •
                                                              AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                y) })
                                                (s₁ + s₂) =
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  s₁ +
                                                (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  s₂) }
                                    (r • s) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      {
                                        toFun := fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) },
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  (s₁ + s₂) =
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₁ +
                                                  (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₂) }
                                      s) })
                    (x + y) =
                  ↑(lift
                          {
                            toAddHom :=
                              {
                                toFun := fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) },
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          (s₁ + s₂) =
                                        (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₁ +
                                          (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      {
                                        toFun := fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) },
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  (s₁ + s₂) =
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₁ +
                                                  (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₂) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        {
                                          toFun := fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) },
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    (s₁ + s₂) =
                                                  (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₁ +
                                                    (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₂) }
                                        s) })
                      x +
                    ↑(lift
                          {
                            toAddHom :=
                              {
                                toFun := fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) },
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          (s₁ + s₂) =
                                        (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₁ +
                                          (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      {
                                        toFun := fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) },
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  (s₁ + s₂) =
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₁ +
                                                  (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₂) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        {
                                          toFun := fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) },
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    (s₁ + s₂) =
                                                  (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₁ +
                                                    (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₂) }
                                        s) })
                      y) }
        (r • x) =
      ↑(RingHom.id S) r •
        AddHom.toFun
          {
            toFun :=
              ↑(lift
                  {
                    toAddHom :=
                      {
                        toFun := fun s =>
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (y : ↑Y),
                                  AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      (r • y) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        y) },
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s =>
                                    {
                                      toAddHom :=
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                      map_smul' :=
                                        (_ :
                                          ∀ (r : R) (y : ↑Y),
                                            AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                (r • y) =
                                              ↑(RingHom.id R) r •
                                                AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  y) })
                                  (s₁ + s₂) =
                                (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    s₁ +
                                  (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    s₂) },
                    map_smul' :=
                      (_ :
                        ∀ (r : R) (s : S),
                          AddHom.toFun
                              {
                                toFun := fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) },
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          (s₁ + s₂) =
                                        (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₁ +
                                          (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₂) }
                              (r • s) =
                            ↑(RingHom.id R) r •
                              AddHom.toFun
                                {
                                  toFun := fun s =>
                                    {
                                      toAddHom :=
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                      map_smul' :=
                                        (_ :
                                          ∀ (r : R) (y : ↑Y),
                                            AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                (r • y) =
                                              ↑(RingHom.id R) r •
                                                AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  y) },
                                  map_add' :=
                                    (_ :
                                      ∀ (s₁ s₂ : S),
                                        (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            (s₁ + s₂) =
                                          (fun s =>
                                                {
                                                  toAddHom :=
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                  map_smul' :=
                                                    (_ :
                                                      ∀ (r : R) (y : ↑Y),
                                                        AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            (r • y) =
                                                          ↑(RingHom.id R) r •
                                                            AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              y) })
                                              s₁ +
                                            (fun s =>
                                                {
                                                  toAddHom :=
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                  map_smul' :=
                                                    (_ :
                                                      ∀ (r : R) (y : ↑Y),
                                                        AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            (r • y) =
                                                          ↑(RingHom.id R) r •
                                                            AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              y) })
                                              s₂) }
                                s) }),
            map_add' :=
              (_ :
                ∀ (x y : ↑((restrictScalars f ⋙ extendScalars f).obj Y)),
                  ↑(lift
                          {
                            toAddHom :=
                              {
                                toFun := fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) },
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          (s₁ + s₂) =
                                        (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₁ +
                                          (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      {
                                        toFun := fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) },
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  (s₁ + s₂) =
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₁ +
                                                  (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₂) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        {
                                          toFun := fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) },
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    (s₁ + s₂) =
                                                  (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₁ +
                                                    (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₂) }
                                        s) })
                      (x + y) =
                    ↑(lift
                            {
                              toAddHom :=
                                {
                                  toFun := fun s =>
                                    {
                                      toAddHom :=
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                      map_smul' :=
                                        (_ :
                                          ∀ (r : R) (y : ↑Y),
                                            AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                (r • y) =
                                              ↑(RingHom.id R) r •
                                                AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  y) },
                                  map_add' :=
                                    (_ :
                                      ∀ (s₁ s₂ : S),
                                        (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            (s₁ + s₂) =
                                          (fun s =>
                                                {
                                                  toAddHom :=
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                  map_smul' :=
                                                    (_ :
                                                      ∀ (r : R) (y : ↑Y),
                                                        AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            (r • y) =
                                                          ↑(RingHom.id R) r •
                                                            AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              y) })
                                              s₁ +
                                            (fun s =>
                                                {
                                                  toAddHom :=
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                  map_smul' :=
                                                    (_ :
                                                      ∀ (r : R) (y : ↑Y),
                                                        AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            (r • y) =
                                                          ↑(RingHom.id R) r •
                                                            AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              y) })
                                              s₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (s : S),
                                    AddHom.toFun
                                        {
                                          toFun := fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) },
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    (s₁ + s₂) =
                                                  (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₁ +
                                                    (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₂) }
                                        (r • s) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          {
                                            toFun := fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) },
                                            map_add' :=
                                              (_ :
                                                ∀ (s₁ s₂ : S),
                                                  (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      (s₁ + s₂) =
                                                    (fun s =>
                                                          {
                                                            toAddHom :=
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                            map_smul' :=
                                                              (_ :
                                                                ∀ (r : R) (y : ↑Y),
                                                                  AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      (r • y) =
                                                                    ↑(RingHom.id R) r •
                                                                      AddHom.toFun
                                                                        { toFun := fun y => s • y,
                                                                          map_add' :=
                                                                            (_ :
                                                                              ∀ (b₁ b₂ : ↑Y),
                                                                                s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                        y) })
                                                        s₁ +
                                                      (fun s =>
                                                          {
                                                            toAddHom :=
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                            map_smul' :=
                                                              (_ :
                                                                ∀ (r : R) (y : ↑Y),
                                                                  AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      (r • y) =
                                                                    ↑(RingHom.id R) r •
                                                                      AddHom.toFun
                                                                        { toFun := fun y => s • y,
                                                                          map_add' :=
                                                                            (_ :
                                                                              ∀ (b₁ b₂ : ↑Y),
                                                                                s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                        y) })
                                                        s₂) }
                                          s) })
                        x +
                      ↑(lift
                            {
                              toAddHom :=
                                {
                                  toFun := fun s =>
                                    {
                                      toAddHom :=
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                      map_smul' :=
                                        (_ :
                                          ∀ (r : R) (y : ↑Y),
                                            AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                (r • y) =
                                              ↑(RingHom.id R) r •
                                                AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  y) },
                                  map_add' :=
                                    (_ :
                                      ∀ (s₁ s₂ : S),
                                        (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            (s₁ + s₂) =
                                          (fun s =>
                                                {
                                                  toAddHom :=
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                  map_smul' :=
                                                    (_ :
                                                      ∀ (r : R) (y : ↑Y),
                                                        AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            (r • y) =
                                                          ↑(RingHom.id R) r •
                                                            AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              y) })
                                              s₁ +
                                            (fun s =>
                                                {
                                                  toAddHom :=
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                  map_smul' :=
                                                    (_ :
                                                      ∀ (r : R) (y : ↑Y),
                                                        AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            (r • y) =
                                                          ↑(RingHom.id R) r •
                                                            AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              y) })
                                              s₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (s : S),
                                    AddHom.toFun
                                        {
                                          toFun := fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) },
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    (s₁ + s₂) =
                                                  (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₁ +
                                                    (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₂) }
                                        (r • s) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          {
                                            toFun := fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) },
                                            map_add' :=
                                              (_ :
                                                ∀ (s₁ s₂ : S),
                                                  (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      (s₁ + s₂) =
                                                    (fun s =>
                                                          {
                                                            toAddHom :=
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                            map_smul' :=
                                                              (_ :
                                                                ∀ (r : R) (y : ↑Y),
                                                                  AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      (r • y) =
                                                                    ↑(RingHom.id R) r •
                                                                      AddHom.toFun
                                                                        { toFun := fun y => s • y,
                                                                          map_add' :=
                                                                            (_ :
                                                                              ∀ (b₁ b₂ : ↑Y),
                                                                                s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                        y) })
                                                        s₁ +
                                                      (fun s =>
                                                          {
                                                            toAddHom :=
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                            map_smul' :=
                                                              (_ :
                                                                ∀ (r : R) (y : ↑Y),
                                                                  AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      (r • y) =
                                                                    ↑(RingHom.id R) r •
                                                                      AddHom.toFun
                                                                        { toFun := fun y => s • y,
                                                                          map_add' :=
                                                                            (_ :
                                                                              ∀ (b₁ b₂ : ↑Y),
                                                                                s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                        y) })
                                                        s₂) }
                                          s) })
                        y) }
          x
[PROOFSTEP]
intro s z
[GOAL]
case refine'_5
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
z : ↑((restrictScalars f ⋙ extendScalars f).obj Y)
⊢ AddHom.toFun
      {
        toFun :=
          ↑(lift
              {
                toAddHom :=
                  {
                    toFun := fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' :=
                          (_ :
                            ∀ (r : R) (y : ↑Y),
                              AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  (r • y) =
                                ↑(RingHom.id R) r •
                                  AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    y) },
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              (s₁ + s₂) =
                            (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                s₁ +
                              (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                s₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          {
                            toFun := fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) },
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      (s₁ + s₂) =
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₁ +
                                      (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₂) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            {
                              toFun := fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) },
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        (s₁ + s₂) =
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₁ +
                                        (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₂) }
                            s) }),
        map_add' :=
          (_ :
            ∀ (x y : ↑((restrictScalars f ⋙ extendScalars f).obj Y)),
              ↑(lift
                      {
                        toAddHom :=
                          {
                            toFun := fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) },
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      (s₁ + s₂) =
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₁ +
                                      (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₂) },
                        map_smul' :=
                          (_ :
                            ∀ (r : R) (s : S),
                              AddHom.toFun
                                  {
                                    toFun := fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) },
                                    map_add' :=
                                      (_ :
                                        ∀ (s₁ s₂ : S),
                                          (fun s =>
                                                {
                                                  toAddHom :=
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                  map_smul' :=
                                                    (_ :
                                                      ∀ (r : R) (y : ↑Y),
                                                        AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            (r • y) =
                                                          ↑(RingHom.id R) r •
                                                            AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              y) })
                                              (s₁ + s₂) =
                                            (fun s =>
                                                  {
                                                    toAddHom :=
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                    map_smul' :=
                                                      (_ :
                                                        ∀ (r : R) (y : ↑Y),
                                                          AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              (r • y) =
                                                            ↑(RingHom.id R) r •
                                                              AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                y) })
                                                s₁ +
                                              (fun s =>
                                                  {
                                                    toAddHom :=
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                    map_smul' :=
                                                      (_ :
                                                        ∀ (r : R) (y : ↑Y),
                                                          AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              (r • y) =
                                                            ↑(RingHom.id R) r •
                                                              AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                y) })
                                                s₂) }
                                  (r • s) =
                                ↑(RingHom.id R) r •
                                  AddHom.toFun
                                    {
                                      toFun := fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) },
                                      map_add' :=
                                        (_ :
                                          ∀ (s₁ s₂ : S),
                                            (fun s =>
                                                  {
                                                    toAddHom :=
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                    map_smul' :=
                                                      (_ :
                                                        ∀ (r : R) (y : ↑Y),
                                                          AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              (r • y) =
                                                            ↑(RingHom.id R) r •
                                                              AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                y) })
                                                (s₁ + s₂) =
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  s₁ +
                                                (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  s₂) }
                                    s) })
                  (x + y) =
                ↑(lift
                        {
                          toAddHom :=
                            {
                              toFun := fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) },
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        (s₁ + s₂) =
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₁ +
                                        (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (s : S),
                                AddHom.toFun
                                    {
                                      toFun := fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) },
                                      map_add' :=
                                        (_ :
                                          ∀ (s₁ s₂ : S),
                                            (fun s =>
                                                  {
                                                    toAddHom :=
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                    map_smul' :=
                                                      (_ :
                                                        ∀ (r : R) (y : ↑Y),
                                                          AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              (r • y) =
                                                            ↑(RingHom.id R) r •
                                                              AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                y) })
                                                (s₁ + s₂) =
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  s₁ +
                                                (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  s₂) }
                                    (r • s) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      {
                                        toFun := fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) },
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  (s₁ + s₂) =
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₁ +
                                                  (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₂) }
                                      s) })
                    x +
                  ↑(lift
                        {
                          toAddHom :=
                            {
                              toFun := fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) },
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        (s₁ + s₂) =
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₁ +
                                        (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (s : S),
                                AddHom.toFun
                                    {
                                      toFun := fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) },
                                      map_add' :=
                                        (_ :
                                          ∀ (s₁ s₂ : S),
                                            (fun s =>
                                                  {
                                                    toAddHom :=
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                    map_smul' :=
                                                      (_ :
                                                        ∀ (r : R) (y : ↑Y),
                                                          AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              (r • y) =
                                                            ↑(RingHom.id R) r •
                                                              AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                y) })
                                                (s₁ + s₂) =
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  s₁ +
                                                (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  s₂) }
                                    (r • s) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      {
                                        toFun := fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) },
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  (s₁ + s₂) =
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₁ +
                                                  (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₂) }
                                      s) })
                    y) }
      (s • z) =
    ↑(RingHom.id S) s •
      AddHom.toFun
        {
          toFun :=
            ↑(lift
                {
                  toAddHom :=
                    {
                      toFun := fun s =>
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (y : ↑Y),
                                AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    (r • y) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      y) },
                      map_add' :=
                        (_ :
                          ∀ (s₁ s₂ : S),
                            (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                (s₁ + s₂) =
                              (fun s =>
                                    {
                                      toAddHom :=
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                      map_smul' :=
                                        (_ :
                                          ∀ (r : R) (y : ↑Y),
                                            AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                (r • y) =
                                              ↑(RingHom.id R) r •
                                                AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  y) })
                                  s₁ +
                                (fun s =>
                                    {
                                      toAddHom :=
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                      map_smul' :=
                                        (_ :
                                          ∀ (r : R) (y : ↑Y),
                                            AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                (r • y) =
                                              ↑(RingHom.id R) r •
                                                AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  y) })
                                  s₂) },
                  map_smul' :=
                    (_ :
                      ∀ (r : R) (s : S),
                        AddHom.toFun
                            {
                              toFun := fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) },
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        (s₁ + s₂) =
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₁ +
                                        (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₂) }
                            (r • s) =
                          ↑(RingHom.id R) r •
                            AddHom.toFun
                              {
                                toFun := fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) },
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          (s₁ + s₂) =
                                        (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₁ +
                                          (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₂) }
                              s) }),
          map_add' :=
            (_ :
              ∀ (x y : ↑((restrictScalars f ⋙ extendScalars f).obj Y)),
                ↑(lift
                        {
                          toAddHom :=
                            {
                              toFun := fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) },
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        (s₁ + s₂) =
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₁ +
                                        (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₂) },
                          map_smul' :=
                            (_ :
                              ∀ (r : R) (s : S),
                                AddHom.toFun
                                    {
                                      toFun := fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) },
                                      map_add' :=
                                        (_ :
                                          ∀ (s₁ s₂ : S),
                                            (fun s =>
                                                  {
                                                    toAddHom :=
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                    map_smul' :=
                                                      (_ :
                                                        ∀ (r : R) (y : ↑Y),
                                                          AddHom.toFun
                                                              { toFun := fun y => s • y,
                                                                map_add' :=
                                                                  (_ :
                                                                    ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                              (r • y) =
                                                            ↑(RingHom.id R) r •
                                                              AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                y) })
                                                (s₁ + s₂) =
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  s₁ +
                                                (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  s₂) }
                                    (r • s) =
                                  ↑(RingHom.id R) r •
                                    AddHom.toFun
                                      {
                                        toFun := fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) },
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  (s₁ + s₂) =
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₁ +
                                                  (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₂) }
                                      s) })
                    (x + y) =
                  ↑(lift
                          {
                            toAddHom :=
                              {
                                toFun := fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) },
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          (s₁ + s₂) =
                                        (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₁ +
                                          (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      {
                                        toFun := fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) },
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  (s₁ + s₂) =
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₁ +
                                                  (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₂) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        {
                                          toFun := fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) },
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    (s₁ + s₂) =
                                                  (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₁ +
                                                    (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₂) }
                                        s) })
                      x +
                    ↑(lift
                          {
                            toAddHom :=
                              {
                                toFun := fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) },
                                map_add' :=
                                  (_ :
                                    ∀ (s₁ s₂ : S),
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          (s₁ + s₂) =
                                        (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₁ +
                                          (fun s =>
                                              {
                                                toAddHom :=
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                map_smul' :=
                                                  (_ :
                                                    ∀ (r : R) (y : ↑Y),
                                                      AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          (r • y) =
                                                        ↑(RingHom.id R) r •
                                                          AddHom.toFun
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                            y) })
                                            s₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (s : S),
                                  AddHom.toFun
                                      {
                                        toFun := fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) },
                                        map_add' :=
                                          (_ :
                                            ∀ (s₁ s₂ : S),
                                              (fun s =>
                                                    {
                                                      toAddHom :=
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                      map_smul' :=
                                                        (_ :
                                                          ∀ (r : R) (y : ↑Y),
                                                            AddHom.toFun
                                                                { toFun := fun y => s • y,
                                                                  map_add' :=
                                                                    (_ :
                                                                      ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                (r • y) =
                                                              ↑(RingHom.id R) r •
                                                                AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  y) })
                                                  (s₁ + s₂) =
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₁ +
                                                  (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    s₂) }
                                      (r • s) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        {
                                          toFun := fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) },
                                          map_add' :=
                                            (_ :
                                              ∀ (s₁ s₂ : S),
                                                (fun s =>
                                                      {
                                                        toAddHom :=
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                        map_smul' :=
                                                          (_ :
                                                            ∀ (r : R) (y : ↑Y),
                                                              AddHom.toFun
                                                                  { toFun := fun y => s • y,
                                                                    map_add' :=
                                                                      (_ :
                                                                        ∀ (b₁ b₂ : ↑Y),
                                                                          s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                  (r • y) =
                                                                ↑(RingHom.id R) r •
                                                                  AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    y) })
                                                    (s₁ + s₂) =
                                                  (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₁ +
                                                    (fun s =>
                                                        {
                                                          toAddHom :=
                                                            { toFun := fun y => s • y,
                                                              map_add' :=
                                                                (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                                          map_smul' :=
                                                            (_ :
                                                              ∀ (r : R) (y : ↑Y),
                                                                AddHom.toFun
                                                                    { toFun := fun y => s • y,
                                                                      map_add' :=
                                                                        (_ :
                                                                          ∀ (b₁ b₂ : ↑Y),
                                                                            s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                    (r • y) =
                                                                  ↑(RingHom.id R) r •
                                                                    AddHom.toFun
                                                                      { toFun := fun y => s • y,
                                                                        map_add' :=
                                                                          (_ :
                                                                            ∀ (b₁ b₂ : ↑Y),
                                                                              s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                                      y) })
                                                      s₂) }
                                        s) })
                      y) }
        z
[PROOFSTEP]
dsimp
[GOAL]
case refine'_5
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
z : ↑((restrictScalars f ⋙ extendScalars f).obj Y)
⊢ ↑(lift
          {
            toAddHom :=
              {
                toFun := fun s =>
                  {
                    toAddHom :=
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                    map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      {
                          toAddHom :=
                            { toFun := fun y => (s₁ + s₂) • y,
                              map_add' :=
                                (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                        {
                            toAddHom :=
                              { toFun := fun y => s₁ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                          {
                            toAddHom :=
                              { toFun := fun y => s₂ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  {
                      toAddHom :=
                        { toFun := fun y => (r • s) • y,
                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                      map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                    r •
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
      (s • z) =
    s •
      ↑(lift
            {
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        {
                            toAddHom :=
                              { toFun := fun y => (s₁ + s₂) • y,
                                map_add' :=
                                  (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                          {
                              toAddHom :=
                                { toFun := fun y => s₁ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                            {
                              toAddHom :=
                                { toFun := fun y => s₂ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    {
                        toAddHom :=
                          { toFun := fun y => (r • s) • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                        map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                      r •
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
        z
[PROOFSTEP]
induction' z using TensorProduct.induction_on with s' y z1 z2 ih1 ih2
[GOAL]
case refine'_5.zero
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
⊢ ↑(lift
          {
            toAddHom :=
              {
                toFun := fun s =>
                  {
                    toAddHom :=
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                    map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      {
                          toAddHom :=
                            { toFun := fun y => (s₁ + s₂) • y,
                              map_add' :=
                                (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                        {
                            toAddHom :=
                              { toFun := fun y => s₁ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                          {
                            toAddHom :=
                              { toFun := fun y => s₂ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  {
                      toAddHom :=
                        { toFun := fun y => (r • s) • y,
                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                      map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                    r •
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
      (s • 0) =
    s •
      ↑(lift
            {
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        {
                            toAddHom :=
                              { toFun := fun y => (s₁ + s₂) • y,
                                map_add' :=
                                  (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                          {
                              toAddHom :=
                                { toFun := fun y => s₁ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                            {
                              toAddHom :=
                                { toFun := fun y => s₂ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    {
                        toAddHom :=
                          { toFun := fun y => (r • s) • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                        map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                      r •
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
        0
[PROOFSTEP]
rw [smul_zero, map_zero, smul_zero]
[GOAL]
case refine'_5.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
s' : ↑((restrictScalars f).obj (ModuleCat.mk S))
y : ↑((restrictScalars f).obj Y)
⊢ ↑(lift
          {
            toAddHom :=
              {
                toFun := fun s =>
                  {
                    toAddHom :=
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                    map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      {
                          toAddHom :=
                            { toFun := fun y => (s₁ + s₂) • y,
                              map_add' :=
                                (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                        {
                            toAddHom :=
                              { toFun := fun y => s₁ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                          {
                            toAddHom :=
                              { toFun := fun y => s₂ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  {
                      toAddHom :=
                        { toFun := fun y => (r • s) • y,
                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                      map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                    r •
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
      (s • s' ⊗ₜ[R] y) =
    s •
      ↑(lift
            {
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        {
                            toAddHom :=
                              { toFun := fun y => (s₁ + s₂) • y,
                                map_add' :=
                                  (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                          {
                              toAddHom :=
                                { toFun := fun y => s₁ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                            {
                              toAddHom :=
                                { toFun := fun y => s₂ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    {
                        toAddHom :=
                          { toFun := fun y => (r • s) • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                        map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                      r •
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
        (s' ⊗ₜ[R] y)
[PROOFSTEP]
rw [ExtendScalars.smul_tmul, LinearMap.coe_mk]
[GOAL]
case refine'_5.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
s' : ↑((restrictScalars f).obj (ModuleCat.mk S))
y : ↑((restrictScalars f).obj Y)
⊢ ↑(lift
            {
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        {
                            toAddHom :=
                              { toFun := fun y => (s₁ + s₂) • y,
                                map_add' :=
                                  (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                          {
                              toAddHom :=
                                { toFun := fun y => s₁ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                            {
                              toAddHom :=
                                { toFun := fun y => s₂ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    {
                        toAddHom :=
                          { toFun := fun y => (r • s) • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                        map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                      r •
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) }).toAddHom
      ((s * s') ⊗ₜ[R] y) =
    s •
      ↑(lift
              {
                toAddHom :=
                  {
                    toFun := fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          {
                              toAddHom :=
                                { toFun := fun y => (s₁ + s₂) • y,
                                  map_add' :=
                                    (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                            {
                                toAddHom :=
                                  { toFun := fun y => s₁ • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                                map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                              {
                                toAddHom :=
                                  { toFun := fun y => s₂ • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                                map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      {
                          toAddHom :=
                            { toFun := fun y => (r • s) • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                          map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                        r •
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) }).toAddHom
        (s' ⊗ₜ[R] y)
[PROOFSTEP]
erw [TensorProduct.lift.tmul, TensorProduct.lift.tmul]
[GOAL]
case refine'_5.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
s' : ↑((restrictScalars f).obj (ModuleCat.mk S))
y : ↑((restrictScalars f).obj Y)
⊢ ↑(↑{
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        {
                            toAddHom :=
                              { toFun := fun y => (s₁ + s₂) • y,
                                map_add' :=
                                  (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                          {
                              toAddHom :=
                                { toFun := fun y => s₁ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                            {
                              toAddHom :=
                                { toFun := fun y => s₂ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    {
                        toAddHom :=
                          { toFun := fun y => (r • s) • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                        map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                      r •
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) }
          (s * s'))
      y =
    s •
      ↑(↑{
                toAddHom :=
                  {
                    toFun := fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          {
                              toAddHom :=
                                { toFun := fun y => (s₁ + s₂) • y,
                                  map_add' :=
                                    (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                            {
                                toAddHom :=
                                  { toFun := fun y => s₁ • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                                map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                              {
                                toAddHom :=
                                  { toFun := fun y => s₂ • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                                map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      {
                          toAddHom :=
                            { toFun := fun y => (r • s) • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                          map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                        r •
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) }
            s')
        y
[PROOFSTEP]
set s' : S := s'
[GOAL]
case refine'_5.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
s'✝ : ↑((restrictScalars f).obj (ModuleCat.mk S))
y : ↑((restrictScalars f).obj Y)
s' : S := s'✝
⊢ ↑(↑{
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        {
                            toAddHom :=
                              { toFun := fun y => (s₁ + s₂) • y,
                                map_add' :=
                                  (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                          {
                              toAddHom :=
                                { toFun := fun y => s₁ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                            {
                              toAddHom :=
                                { toFun := fun y => s₂ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    {
                        toAddHom :=
                          { toFun := fun y => (r • s) • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                        map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                      r •
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) }
          (s * s'))
      y =
    s •
      ↑(↑{
                toAddHom :=
                  {
                    toFun := fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          {
                              toAddHom :=
                                { toFun := fun y => (s₁ + s₂) • y,
                                  map_add' :=
                                    (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                            {
                                toAddHom :=
                                  { toFun := fun y => s₁ • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                                map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                              {
                                toAddHom :=
                                  { toFun := fun y => s₂ • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                                map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      {
                          toAddHom :=
                            { toFun := fun y => (r • s) • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                          map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                        r •
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) }
            s')
        y
[PROOFSTEP]
change (s * s') • y = s • s' • y
[GOAL]
case refine'_5.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
s'✝ : ↑((restrictScalars f).obj (ModuleCat.mk S))
y : ↑((restrictScalars f).obj Y)
s' : S := s'✝
⊢ (s * s') • y = s • s' • y
[PROOFSTEP]
rw [mul_smul]
[GOAL]
case refine'_5.add
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y : ModuleCat S
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : S
z1 z2 : ↑((restrictScalars f).obj (ModuleCat.mk S)) ⊗[R] ↑((restrictScalars f).obj Y)
ih1 :
  ↑(lift
          {
            toAddHom :=
              {
                toFun := fun s =>
                  {
                    toAddHom :=
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                    map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      {
                          toAddHom :=
                            { toFun := fun y => (s₁ + s₂) • y,
                              map_add' :=
                                (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                        {
                            toAddHom :=
                              { toFun := fun y => s₁ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                          {
                            toAddHom :=
                              { toFun := fun y => s₂ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  {
                      toAddHom :=
                        { toFun := fun y => (r • s) • y,
                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                      map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                    r •
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
      (s • z1) =
    s •
      ↑(lift
            {
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        {
                            toAddHom :=
                              { toFun := fun y => (s₁ + s₂) • y,
                                map_add' :=
                                  (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                          {
                              toAddHom :=
                                { toFun := fun y => s₁ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                            {
                              toAddHom :=
                                { toFun := fun y => s₂ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    {
                        toAddHom :=
                          { toFun := fun y => (r • s) • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                        map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                      r •
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
        z1
ih2 :
  ↑(lift
          {
            toAddHom :=
              {
                toFun := fun s =>
                  {
                    toAddHom :=
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                    map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      {
                          toAddHom :=
                            { toFun := fun y => (s₁ + s₂) • y,
                              map_add' :=
                                (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                        {
                            toAddHom :=
                              { toFun := fun y => s₁ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                          {
                            toAddHom :=
                              { toFun := fun y => s₂ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  {
                      toAddHom :=
                        { toFun := fun y => (r • s) • y,
                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                      map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                    r •
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
      (s • z2) =
    s •
      ↑(lift
            {
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        {
                            toAddHom :=
                              { toFun := fun y => (s₁ + s₂) • y,
                                map_add' :=
                                  (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                          {
                              toAddHom :=
                                { toFun := fun y => s₁ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                            {
                              toAddHom :=
                                { toFun := fun y => s₂ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    {
                        toAddHom :=
                          { toFun := fun y => (r • s) • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                        map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                      r •
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
        z2
⊢ ↑(lift
          {
            toAddHom :=
              {
                toFun := fun s =>
                  {
                    toAddHom :=
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                    map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      {
                          toAddHom :=
                            { toFun := fun y => (s₁ + s₂) • y,
                              map_add' :=
                                (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                        {
                            toAddHom :=
                              { toFun := fun y => s₁ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                          {
                            toAddHom :=
                              { toFun := fun y => s₂ • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  {
                      toAddHom :=
                        { toFun := fun y => (r • s) • y,
                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                      map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                    r •
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
      (s • (z1 + z2)) =
    s •
      ↑(lift
            {
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        {
                            toAddHom :=
                              { toFun := fun y => (s₁ + s₂) • y,
                                map_add' :=
                                  (_ : ∀ (b₁ b₂ : ↑Y), (s₁ + s₂) • (b₁ + b₂) = (s₁ + s₂) • b₁ + (s₁ + s₂) • b₂) },
                            map_smul' := (_ : ∀ (r : R) (y : ↑Y), (s₁ + s₂) • ↑f r • y = ↑f r • (s₁ + s₂) • y) } =
                          {
                              toAddHom :=
                                { toFun := fun y => s₁ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₁ • (b₁ + b₂) = s₁ • b₁ + s₁ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₁ • ↑f r • y = ↑f r • s₁ • y) } +
                            {
                              toAddHom :=
                                { toFun := fun y => s₂ • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s₂ • (b₁ + b₂) = s₂ • b₁ + s₂ • b₂) },
                              map_smul' := (_ : ∀ (r : R) (y : ↑Y), s₂ • ↑f r • y = ↑f r • s₂ • y) }) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    {
                        toAddHom :=
                          { toFun := fun y => (r • s) • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), (r • s) • (b₁ + b₂) = (r • s) • b₁ + (r • s) • b₂) },
                        map_smul' := (_ : ∀ (r_1 : R) (y : ↑Y), (r • s) • ↑f r_1 • y = ↑f r_1 • (r • s) • y) } =
                      r •
                        {
                          toAddHom :=
                            { toFun := fun y => s • y,
                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                          map_smul' := (_ : ∀ (r : R) (y : ↑Y), s • ↑f r • y = ↑f r • s • y) }) })
        (z1 + z2)
[PROOFSTEP]
rw [smul_add, map_add, map_add, ih1, ih2, smul_add]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
⊢ (restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y' =
    (fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g
[PROOFSTEP]
letI m1 : Module R S := Module.compHom S f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
⊢ (restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y' =
    (fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g
[PROOFSTEP]
letI m2 : Module R Y := Module.compHom Y f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ (restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y' =
    (fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g
[PROOFSTEP]
letI m2 : Module R Y' := Module.compHom Y' f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2✝ : Module R ↑Y := Module.compHom (↑Y) f
m2 : Module R ↑Y' := Module.compHom (↑Y') f
⊢ (restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y' =
    (fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g
[PROOFSTEP]
apply LinearMap.ext
[GOAL]
case h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2✝ : Module R ↑Y := Module.compHom (↑Y) f
m2 : Module R ↑Y' := Module.compHom (↑Y') f
⊢ ∀ (x : ↑((restrictScalars f ⋙ extendScalars f).obj Y)),
    ↑((restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y') x =
      ↑((fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g) x
[PROOFSTEP]
intro z
[GOAL]
case h
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2✝ : Module R ↑Y := Module.compHom (↑Y) f
m2 : Module R ↑Y' := Module.compHom (↑Y') f
z : ↑((restrictScalars f ⋙ extendScalars f).obj Y)
⊢ ↑((restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y') z =
    ↑((fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g) z
[PROOFSTEP]
induction' z using TensorProduct.induction_on with s' y z₁ z₂ ih₁ ih₂
[GOAL]
case h.zero
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2✝ : Module R ↑Y := Module.compHom (↑Y) f
m2 : Module R ↑Y' := Module.compHom (↑Y') f
⊢ ↑((restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y') 0 =
    ↑((fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g) 0
[PROOFSTEP]
rw [map_zero, map_zero]
[GOAL]
case h.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2✝ : Module R ↑Y := Module.compHom (↑Y) f
m2 : Module R ↑Y' := Module.compHom (↑Y') f
s' : ↑((restrictScalars f).obj (ModuleCat.mk S))
y : ↑((restrictScalars f).obj Y)
⊢ ↑((restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y') (s' ⊗ₜ[R] y) =
    ↑((fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g) (s' ⊗ₜ[R] y)
[PROOFSTEP]
dsimp
[GOAL]
case h.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2✝ : Module R ↑Y := Module.compHom (↑Y) f
m2 : Module R ↑Y' := Module.compHom (↑Y') f
s' : ↑((restrictScalars f).obj (ModuleCat.mk S))
y : ↑((restrictScalars f).obj Y)
⊢ ↑((extendScalars f).map ((restrictScalars f).map g) ≫ Counit.map f) (s' ⊗ₜ[R] y) = ↑(Counit.map f ≫ g) (s' ⊗ₜ[R] y)
[PROOFSTEP]
rw [ModuleCat.coe_comp, ModuleCat.coe_comp, Function.comp, Function.comp, ExtendScalars.map_tmul,
  restrictScalars.map_apply, Counit.map_apply, Counit.map_apply, lift.tmul, lift.tmul, LinearMap.coe_mk,
  LinearMap.coe_mk]
[GOAL]
case h.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2✝ : Module R ↑Y := Module.compHom (↑Y) f
m2 : Module R ↑Y' := Module.compHom (↑Y') f
s' : ↑((restrictScalars f).obj (ModuleCat.mk S))
y : ↑((restrictScalars f).obj Y)
⊢ ↑(↑{
                toFun := fun s =>
                  {
                    toAddHom :=
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                    map_smul' :=
                      (_ :
                        ∀ (r : R) (y : ↑Y'),
                          AddHom.toFun
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                              (r • y) =
                            ↑(RingHom.id R) r •
                              AddHom.toFun
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                y) },
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y'),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) })
                          (s₁ + s₂) =
                        (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y'),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            s₁ +
                          (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y'),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            s₂) }
            s').toAddHom
      (↑g y) =
    ↑g
      (↑(↑{
                toAddHom :=
                  {
                    toFun := fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' :=
                          (_ :
                            ∀ (r : R) (y : ↑Y),
                              AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  (r • y) =
                                ↑(RingHom.id R) r •
                                  AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    y) },
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              (s₁ + s₂) =
                            (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                s₁ +
                              (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                s₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          {
                            toFun := fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) },
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      (s₁ + s₂) =
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₁ +
                                      (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₂) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            {
                              toFun := fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) },
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        (s₁ + s₂) =
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₁ +
                                        (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₂) }
                            s) }
            s')
        y)
[PROOFSTEP]
set s' : S := s'
[GOAL]
case h.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2✝ : Module R ↑Y := Module.compHom (↑Y) f
m2 : Module R ↑Y' := Module.compHom (↑Y') f
s'✝ : ↑((restrictScalars f).obj (ModuleCat.mk S))
y : ↑((restrictScalars f).obj Y)
s' : S := s'✝
⊢ ↑(↑{
                toFun := fun s =>
                  {
                    toAddHom :=
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                    map_smul' :=
                      (_ :
                        ∀ (r : R) (y : ↑Y'),
                          AddHom.toFun
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                              (r • y) =
                            ↑(RingHom.id R) r •
                              AddHom.toFun
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                y) },
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y'),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) })
                          (s₁ + s₂) =
                        (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y'),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            s₁ +
                          (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y'),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y'), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            s₂) }
            s').toAddHom
      (↑g y) =
    ↑g
      (↑(↑{
                toAddHom :=
                  {
                    toFun := fun s =>
                      {
                        toAddHom :=
                          { toFun := fun y => s • y,
                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                        map_smul' :=
                          (_ :
                            ∀ (r : R) (y : ↑Y),
                              AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  (r • y) =
                                ↑(RingHom.id R) r •
                                  AddHom.toFun
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                    y) },
                    map_add' :=
                      (_ :
                        ∀ (s₁ s₂ : S),
                          (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              (s₁ + s₂) =
                            (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                s₁ +
                              (fun s =>
                                  {
                                    toAddHom :=
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                    map_smul' :=
                                      (_ :
                                        ∀ (r : R) (y : ↑Y),
                                          AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              (r • y) =
                                            ↑(RingHom.id R) r •
                                              AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                y) })
                                s₂) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (s : S),
                      AddHom.toFun
                          {
                            toFun := fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) },
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      (s₁ + s₂) =
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₁ +
                                      (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₂) }
                          (r • s) =
                        ↑(RingHom.id R) r •
                          AddHom.toFun
                            {
                              toFun := fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) },
                              map_add' :=
                                (_ :
                                  ∀ (s₁ s₂ : S),
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        (s₁ + s₂) =
                                      (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₁ +
                                        (fun s =>
                                            {
                                              toAddHom :=
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                              map_smul' :=
                                                (_ :
                                                  ∀ (r : R) (y : ↑Y),
                                                    AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        (r • y) =
                                                      ↑(RingHom.id R) r •
                                                        AddHom.toFun
                                                          { toFun := fun y => s • y,
                                                            map_add' :=
                                                              (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                          y) })
                                          s₂) }
                            s) }
            s')
        y)
[PROOFSTEP]
change s' • g y = g (s' • y)
[GOAL]
case h.tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2✝ : Module R ↑Y := Module.compHom (↑Y) f
m2 : Module R ↑Y' := Module.compHom (↑Y') f
s'✝ : ↑((restrictScalars f).obj (ModuleCat.mk S))
y : ↑((restrictScalars f).obj Y)
s' : S := s'✝
⊢ s' • ↑g y = ↑g (s' • y)
[PROOFSTEP]
rw [map_smul]
[GOAL]
case h.add
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2✝ : Module R ↑Y := Module.compHom (↑Y) f
m2 : Module R ↑Y' := Module.compHom (↑Y') f
z₁ z₂ : ↑((restrictScalars f).obj (ModuleCat.mk S)) ⊗[R] ↑((restrictScalars f).obj Y)
ih₁ :
  ↑((restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y') z₁ =
    ↑((fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g) z₁
ih₂ :
  ↑((restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y') z₂ =
    ↑((fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g) z₂
⊢ ↑((restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y') (z₁ + z₂) =
    ↑((fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g) (z₁ + z₂)
[PROOFSTEP]
rw [map_add, map_add]
[GOAL]
case h.add
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
Y Y' : ModuleCat S
g : Y ⟶ Y'
m1 : Module R S := Module.compHom S f
m2✝ : Module R ↑Y := Module.compHom (↑Y) f
m2 : Module R ↑Y' := Module.compHom (↑Y') f
z₁ z₂ : ↑((restrictScalars f).obj (ModuleCat.mk S)) ⊗[R] ↑((restrictScalars f).obj Y)
ih₁ :
  ↑((restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y') z₁ =
    ↑((fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g) z₁
ih₂ :
  ↑((restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y') z₂ =
    ↑((fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g) z₂
⊢ ↑((restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y') z₁ +
      ↑((restrictScalars f ⋙ extendScalars f).map g ≫ (fun x => Counit.map f) Y') z₂ =
    ↑((fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g) z₁ +
      ↑((fun x => Counit.map f) Y ≫ (𝟭 (ModuleCat S)).map g) z₂
[PROOFSTEP]
congr 1
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
x : ↑X
⊢ ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y) g) x =
    ↑(NatTrans.app (ExtendRestrictScalarsAdj.unit f) X ≫ (restrictScalars f).map g) x
[PROOFSTEP]
dsimp
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
x : ↑X
⊢ ↑(↑(ExtendRestrictScalarsAdj.homEquiv f) g) x = ↑(ExtendRestrictScalarsAdj.Unit.map f ≫ (restrictScalars f).map g) x
[PROOFSTEP]
rw [ModuleCat.coe_comp, Function.comp, restrictScalars.map_apply]
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : (extendScalars f).obj X ⟶ Y
x : ↑X
⊢ ↑(↑(ExtendRestrictScalarsAdj.homEquiv f) g) x = ↑g (↑(ExtendRestrictScalarsAdj.Unit.map f) x)
[PROOFSTEP]
rfl
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
x : ↑((extendScalars f).obj X)
⊢ ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) x =
    ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) x
[PROOFSTEP]
letI m1 : Module R S := Module.compHom S f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
x : ↑((extendScalars f).obj X)
m1 : Module R S := Module.compHom S f
⊢ ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) x =
    ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) x
[PROOFSTEP]
letI m2 : Module R Y := Module.compHom Y f
[GOAL]
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
x : ↑((extendScalars f).obj X)
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) x =
    ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) x
[PROOFSTEP]
induction' x using TensorProduct.induction_on with s x _ _ _ _
[GOAL]
case zero
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
⊢ ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) 0 =
    ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) 0
[PROOFSTEP]
rw [map_zero, map_zero]
[GOAL]
case tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : ↑((restrictScalars f).obj (ModuleCat.mk S))
x : ↑X
⊢ ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) (s ⊗ₜ[R] x) =
    ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) (s ⊗ₜ[R] x)
[PROOFSTEP]
rw [ExtendRestrictScalarsAdj.homEquiv_symm_apply, ModuleCat.coe_comp, Function.comp_apply,
  ExtendRestrictScalarsAdj.counit_app, ExtendRestrictScalarsAdj.Counit.map_apply]
[GOAL]
case tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : ↑((restrictScalars f).obj (ModuleCat.mk S))
x : ↑X
⊢ ↑(ExtendRestrictScalarsAdj.HomEquiv.fromExtendScalars f g) (s ⊗ₜ[R] x) =
    ↑(lift
          {
            toAddHom :=
              {
                toFun := fun s =>
                  {
                    toAddHom :=
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                    map_smul' :=
                      (_ :
                        ∀ (r : R) (y : ↑Y),
                          AddHom.toFun
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                              (r • y) =
                            ↑(RingHom.id R) r •
                              AddHom.toFun
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                y) },
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) })
                          (s₁ + s₂) =
                        (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            s₁ +
                          (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            s₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  AddHom.toFun
                      {
                        toFun := fun s =>
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (y : ↑Y),
                                  AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      (r • y) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        y) },
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s =>
                                    {
                                      toAddHom :=
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                      map_smul' :=
                                        (_ :
                                          ∀ (r : R) (y : ↑Y),
                                            AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                (r • y) =
                                              ↑(RingHom.id R) r •
                                                AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  y) })
                                  (s₁ + s₂) =
                                (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    s₁ +
                                  (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    s₂) }
                      (r • s) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        {
                          toFun := fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) },
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    (s₁ + s₂) =
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₁ +
                                    (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₂) }
                        s) })
      (↑((extendScalars f).map g) (s ⊗ₜ[R] x))
[PROOFSTEP]
dsimp
[GOAL]
case tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : ↑((restrictScalars f).obj (ModuleCat.mk S))
x : ↑X
⊢ s • ↑g x =
    ↑(lift
          {
            toAddHom :=
              {
                toFun := fun s =>
                  {
                    toAddHom :=
                      { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                    map_smul' :=
                      (_ :
                        ∀ (r : R) (y : ↑Y),
                          AddHom.toFun
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                              (r • y) =
                            ↑(RingHom.id R) r •
                              AddHom.toFun
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                y) },
                map_add' :=
                  (_ :
                    ∀ (s₁ s₂ : S),
                      (fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) })
                          (s₁ + s₂) =
                        (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            s₁ +
                          (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            s₂) },
            map_smul' :=
              (_ :
                ∀ (r : R) (s : S),
                  AddHom.toFun
                      {
                        toFun := fun s =>
                          {
                            toAddHom :=
                              { toFun := fun y => s • y,
                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                            map_smul' :=
                              (_ :
                                ∀ (r : R) (y : ↑Y),
                                  AddHom.toFun
                                      { toFun := fun y => s • y,
                                        map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                      (r • y) =
                                    ↑(RingHom.id R) r •
                                      AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        y) },
                        map_add' :=
                          (_ :
                            ∀ (s₁ s₂ : S),
                              (fun s =>
                                    {
                                      toAddHom :=
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                      map_smul' :=
                                        (_ :
                                          ∀ (r : R) (y : ↑Y),
                                            AddHom.toFun
                                                { toFun := fun y => s • y,
                                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                (r • y) =
                                              ↑(RingHom.id R) r •
                                                AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  y) })
                                  (s₁ + s₂) =
                                (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    s₁ +
                                  (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    s₂) }
                      (r • s) =
                    ↑(RingHom.id R) r •
                      AddHom.toFun
                        {
                          toFun := fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) },
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    (s₁ + s₂) =
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₁ +
                                    (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₂) }
                        s) })
      (s ⊗ₜ[R] ↑g x)
[PROOFSTEP]
rw [TensorProduct.lift.tmul]
[GOAL]
case tmul
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
s : ↑((restrictScalars f).obj (ModuleCat.mk S))
x : ↑X
⊢ s • ↑g x =
    ↑(↑{
              toAddHom :=
                {
                  toFun := fun s =>
                    {
                      toAddHom :=
                        { toFun := fun y => s • y, map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                      map_smul' :=
                        (_ :
                          ∀ (r : R) (y : ↑Y),
                            AddHom.toFun
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                (r • y) =
                              ↑(RingHom.id R) r •
                                AddHom.toFun
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                  y) },
                  map_add' :=
                    (_ :
                      ∀ (s₁ s₂ : S),
                        (fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) })
                            (s₁ + s₂) =
                          (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              s₁ +
                            (fun s =>
                                {
                                  toAddHom :=
                                    { toFun := fun y => s • y,
                                      map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                  map_smul' :=
                                    (_ :
                                      ∀ (r : R) (y : ↑Y),
                                        AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            (r • y) =
                                          ↑(RingHom.id R) r •
                                            AddHom.toFun
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                              y) })
                              s₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (s : S),
                    AddHom.toFun
                        {
                          toFun := fun s =>
                            {
                              toAddHom :=
                                { toFun := fun y => s • y,
                                  map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                              map_smul' :=
                                (_ :
                                  ∀ (r : R) (y : ↑Y),
                                    AddHom.toFun
                                        { toFun := fun y => s • y,
                                          map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                        (r • y) =
                                      ↑(RingHom.id R) r •
                                        AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          y) },
                          map_add' :=
                            (_ :
                              ∀ (s₁ s₂ : S),
                                (fun s =>
                                      {
                                        toAddHom :=
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (y : ↑Y),
                                              AddHom.toFun
                                                  { toFun := fun y => s • y,
                                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                  (r • y) =
                                                ↑(RingHom.id R) r •
                                                  AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    y) })
                                    (s₁ + s₂) =
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₁ +
                                    (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      s₂) }
                        (r • s) =
                      ↑(RingHom.id R) r •
                        AddHom.toFun
                          {
                            toFun := fun s =>
                              {
                                toAddHom :=
                                  { toFun := fun y => s • y,
                                    map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                map_smul' :=
                                  (_ :
                                    ∀ (r : R) (y : ↑Y),
                                      AddHom.toFun
                                          { toFun := fun y => s • y,
                                            map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                          (r • y) =
                                        ↑(RingHom.id R) r •
                                          AddHom.toFun
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                            y) },
                            map_add' :=
                              (_ :
                                ∀ (s₁ s₂ : S),
                                  (fun s =>
                                        {
                                          toAddHom :=
                                            { toFun := fun y => s • y,
                                              map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (y : ↑Y),
                                                AddHom.toFun
                                                    { toFun := fun y => s • y,
                                                      map_add' :=
                                                        (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                    (r • y) =
                                                  ↑(RingHom.id R) r •
                                                    AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      y) })
                                      (s₁ + s₂) =
                                    (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₁ +
                                      (fun s =>
                                          {
                                            toAddHom :=
                                              { toFun := fun y => s • y,
                                                map_add' := (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (y : ↑Y),
                                                  AddHom.toFun
                                                      { toFun := fun y => s • y,
                                                        map_add' :=
                                                          (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                      (r • y) =
                                                    ↑(RingHom.id R) r •
                                                      AddHom.toFun
                                                        { toFun := fun y => s • y,
                                                          map_add' :=
                                                            (_ : ∀ (b₁ b₂ : ↑Y), s • (b₁ + b₂) = s • b₁ + s • b₂) }
                                                        y) })
                                        s₂) }
                          s) }
          s)
      (↑g x)
[PROOFSTEP]
rfl
[GOAL]
case add
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
x✝ y✝ : ↑((restrictScalars f).obj (ModuleCat.mk S)) ⊗[R] ↑X
a✝¹ :
  ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) x✝ =
    ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) x✝
a✝ :
  ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) y✝ =
    ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) y✝
⊢ ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) (x✝ + y✝) =
    ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) (x✝ + y✝)
[PROOFSTEP]
rw [map_add, map_add]
[GOAL]
case add
R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
g : X ⟶ (restrictScalars f).obj Y
m1 : Module R S := Module.compHom S f
m2 : Module R ↑Y := Module.compHom (↑Y) f
x✝ y✝ : ↑((restrictScalars f).obj (ModuleCat.mk S)) ⊗[R] ↑X
a✝¹ :
  ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) x✝ =
    ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) x✝
a✝ :
  ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) y✝ =
    ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) y✝
⊢ ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) x✝ +
      ↑(↑((fun x x_1 => ExtendRestrictScalarsAdj.homEquiv f) X Y).symm g) y✝ =
    ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) x✝ +
      ↑((extendScalars f).map g ≫ NatTrans.app (ExtendRestrictScalarsAdj.counit f) Y) y✝
[PROOFSTEP]
congr 1