@[symm]
theorem Algebra.IsPushout.symm (h : Algebra.IsPushout R S R' S') : Algebra.IsPushout R R' S S' := by
  let _ := (Algebra.TensorProduct.includeRight : R' →ₐ[R] S ⊗ R').toRingHom.toAlgebra
  let e : R' ⊗[R] S ≃ₗ[R'] S' := by
    refine' { (_root_.TensorProduct.comm R R' S).trans <|
      h.1.equiv.restrictScalars R with map_smul' := _ }
    intro r x
    change
      h.1.equiv (TensorProduct.comm R R' S (r • x)) = r • h.1.equiv (TensorProduct.comm R R' S x)
    refine TensorProduct.induction_on x ?_ ?_ ?_
    · simp only [smul_zero, map_zero]
    · intro x y
      simp only [smul_tmul', smul_eq_mul, TensorProduct.comm_tmul, smul_def,
        TensorProduct.algebraMap_apply, id.map_eq_id, RingHom.id_apply, TensorProduct.tmul_mul_tmul,
        one_mul, h.1.equiv_tmul, AlgHom.toLinearMap_apply, _root_.map_mul,
        IsScalarTower.coe_toAlgHom']
      ring
    · intro x y hx hy
      rw [map_add, map_add, smul_add, map_add, map_add, hx, hy, smul_add]
  have :
    (toAlgHom R S S').toLinearMap =
      (e.toLinearMap.restrictScalars R).comp (TensorProduct.mk R R' S 1) := by
    ext
    simp [h.1.equiv_tmul, Algebra.smul_def]
  constructor
  rw [this]
  

Proof state:
case out
R : Type u_1
M : Type v₁
N : Type v₂
S : Type v₃
inst✝³¹ : AddCommMonoid M
inst✝³⁰ : AddCommMonoid N
inst✝²⁹ : CommRing R
inst✝²⁸ : CommRing S
inst✝²⁷ : Algebra R S
inst✝²⁶ : Module R M
inst✝²⁵ : Module R N
inst✝²⁴ : Module S N
inst✝²³ : IsScalarTower R S N
f : M →ₗ[R] N
h✝ : IsBaseChange S f
P : Type u_2
Q : Type u_3
inst✝²² : AddCommMonoid P
inst✝²¹ : Module R P
inst✝²⁰ : AddCommMonoid Q
inst✝¹⁹ : Module S Q
T : Type u_4
O : Type u_5
inst✝¹⁸ : CommRing T
inst✝¹⁷ : Algebra R T
inst✝¹⁶ : Algebra S T
inst✝¹⁵ : IsScalarTower R S T
inst✝¹⁴ : AddCommMonoid O
inst✝¹³ : Module R O
inst✝¹² : Module S O
inst✝¹¹ : Module T O
inst✝¹⁰ : IsScalarTower S T O
inst✝⁹ : IsScalarTower R S O
inst✝⁸ : IsScalarTower R T O
R' : Type u_6
S' : Type u_7
inst✝⁷ : CommRing R'
inst✝⁶ : CommRing S'
inst✝⁵ : Algebra R R'
inst✝⁴ : Algebra S S'
inst✝³ : Algebra R' S'
inst✝² : Algebra R S'
inst✝¹ : IsScalarTower R R' S'
inst✝ : IsScalarTower R S S'
h : IsPushout R S R' S'
x✝ : Algebra R' (S ⊗[R] R') := RingHom.toAlgebra ↑TensorProduct.includeRight
e : R' ⊗[R] S ≃ₗ[R'] S' :=
  let src :=
    _root_.TensorProduct.comm R R' S ≪≫ₗ
      LinearEquiv.restrictScalars R (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))));
  {
    toLinearMap :=
      { toAddHom := src.toAddHom,
        map_smul' :=
          (_ :
            ∀ (r : R') (x : R' ⊗[R] S),
              (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
                  ((TensorProduct.comm R R' S) (r • x)) =
                r •
                  (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
                    ((TensorProduct.comm R R' S) x)) },
    invFun := src.invFun, left_inv := (_ : Function.LeftInverse src.invFun src.toFun),
    right_inv := (_ : Function.RightInverse src.invFun src.toFun) }
this : AlgHom.toLinearMap (toAlgHom R S S') = ↑R ↑e ∘ₗ (TensorProduct.mk R R' S) 1
⊢ IsBaseChange R' (↑R ↑e ∘ₗ (TensorProduct.mk R R' S) 1)

Next tactic:
exact (TensorProduct.isBaseChange R S R').comp (IsBaseChange.ofEquiv e)