/-- The ring morphism `A →+* A ⊗[R] B` sending `a` to `a ⊗ₜ 1`. -/
@[simps]
def includeLeftRingHom : A →+* 𝒜 ᵍ⊗[R] ℬ where
  toFun a := a ᵍ⊗ₜ 1
  map_zero' := by simp
  map_add' := by 

Proof state:
R : Type u_1
ι : Type u_2
A : Type u_3
B : Type u_4
inst✝⁹ : CommSemiring ι
inst✝⁸ : Module ι (Additive ℤˣ)
inst✝⁷ : DecidableEq ι
inst✝⁶ : CommRing R
inst✝⁵ : Ring A
inst✝⁴ : Ring B
inst✝³ : Algebra R A
inst✝² : Algebra R B
𝒜 : ι → Submodule R A
ℬ : ι → Submodule R B
inst✝¹ : GradedAlgebra 𝒜
inst✝ : GradedAlgebra ℬ
⊢ ∀ (x y : A),
    OneHom.toFun
        (↑{
            toOneHom :=
              { toFun := fun a => a ᵍ⊗ₜ[R] 1, map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) },
            map_mul' :=
              (_ :
                ∀ (a₁ a₂ : A),
                  OneHom.toFun
                      { toFun := fun a => a ᵍ⊗ₜ[R] 1,
                        map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) }
                      (a₁ * a₂) =
                    OneHom.toFun
                        { toFun := fun a => a ᵍ⊗ₜ[R] 1,
                          map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) }
                        a₁ *
                      OneHom.toFun
                        { toFun := fun a => a ᵍ⊗ₜ[R] 1,
                          map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) }
                        a₂) })
        (x + y) =
      OneHom.toFun
          (↑{
              toOneHom :=
                { toFun := fun a => a ᵍ⊗ₜ[R] 1, map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) },
              map_mul' :=
                (_ :
                  ∀ (a₁ a₂ : A),
                    OneHom.toFun
                        { toFun := fun a => a ᵍ⊗ₜ[R] 1,
                          map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) }
                        (a₁ * a₂) =
                      OneHom.toFun
                          { toFun := fun a => a ᵍ⊗ₜ[R] 1,
                            map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) }
                          a₁ *
                        OneHom.toFun
                          { toFun := fun a => a ᵍ⊗ₜ[R] 1,
                            map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) }
                          a₂) })
          x +
        OneHom.toFun
          (↑{
              toOneHom :=
                { toFun := fun a => a ᵍ⊗ₜ[R] 1, map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) },
              map_mul' :=
                (_ :
                  ∀ (a₁ a₂ : A),
                    OneHom.toFun
                        { toFun := fun a => a ᵍ⊗ₜ[R] 1,
                          map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) }
                        (a₁ * a₂) =
                      OneHom.toFun
                          { toFun := fun a => a ᵍ⊗ₜ[R] 1,
                            map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) }
                          a₁ *
                        OneHom.toFun
                          { toFun := fun a => a ᵍ⊗ₜ[R] 1,
                            map_one' := (_ : (fun a => a ᵍ⊗ₜ[R] 1) 1 = (fun a => a ᵍ⊗ₜ[R] 1) 1) }
                          a₂) })
          y

Next tactic:
simp [tmul, TensorProduct.add_tmul]