l3lab/ntp-mathlib huggingface dataset:
theorem IsBaseChange.comp {f : M →ₗ[R] N} (hf : IsBaseChange S f) {g : N →ₗ[S] O}
    (hg : IsBaseChange T g) : IsBaseChange T ((g.restrictScalars R).comp f) := by
  apply IsBaseChange.of_lift_unique
  intro Q _ _ _ _ i
  letI := Module.compHom Q (algebraMap S T)
  haveI : IsScalarTower S T Q :=
    ⟨fun x y z => by
      rw [Algebra.smul_def, mul_smul]
      rfl⟩
  have : IsScalarTower R S Q := by
    refine' ⟨fun x y z => _⟩
    change (IsScalarTower.toAlgHom R S T) (x • y) • z = x • algebraMap S T y • z
    rw [AlgHom.map_smul, smul_assoc]
    rfl
  refine'
    ⟨hg.lift (hf.lift i), by
      ext
      simp [IsBaseChange.lift_eq], _⟩
  rintro g' (e : _ = _)
  refine' hg.algHom_ext' _ _ (hf.algHom_ext' _ _ _)
  rw [IsBaseChange.lift_comp, IsBaseChange.lift_comp, ← e]
  ext
  

Proof state:
case h.h
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
f : M →ₗ[R] N
hf : IsBaseChange S f
g : N →ₗ[S] O
hg : IsBaseChange T g
Q : Type (max v₁ u_5 u_4)
inst✝³ : AddCommMonoid Q
inst✝² : Module R Q
inst✝¹ : Module T Q
inst✝ : IsScalarTower R T Q
i : M →ₗ[R] Q
this✝¹ : Module S Q := Module.compHom Q (algebraMap S T)
this✝ : IsScalarTower S T Q
this : IsScalarTower R S Q
g' : O →ₗ[T] Q
e : ↑R g' ∘ₗ ↑R g ∘ₗ f = i
x✝ : M
⊢ (↑R (↑S g' ∘ₗ g) ∘ₗ f) x✝ = (↑R g' ∘ₗ ↑R g ∘ₗ f) x✝

Next tactic:
rfl
@[symm]
theorem Algebra.IsPushout.symm (h : Algebra.IsPushout R S R' S') : Algebra.IsPushout R R' S S' := by
  

Proof state:
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'
⊢ IsPushout R R' S S'

Next tactic:
let _ := (Algebra.TensorProduct.includeRight : R' →ₐ[R] S ⊗ R').toRingHom.toAlgebra
@[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
  

Proof state:
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
⊢ IsPushout R R' S S'

Next tactic:
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]
@[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
    

Proof state:
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
⊢ R' ⊗[R] S ≃ₗ[R'] S'

Next tactic:
refine' { (_root_.TensorProduct.comm R R' S).trans <|
      h.1.equiv.restrictScalars R with map_smul' := _ }
@[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' := _ }
    

Proof state:
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
src✝ : R' ⊗[R] S ≃ₗ[R] S' :=
  _root_.TensorProduct.comm R R' S ≪≫ₗ
    LinearEquiv.restrictScalars R (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
⊢ ∀ (r : R') (x : R' ⊗[R] S), AddHom.toFun src✝.toAddHom (r • x) = (RingHom.id R') r • AddHom.toFun src✝.toAddHom x

Next tactic:
intro r x
@[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
    

Proof state:
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
src✝ : R' ⊗[R] S ≃ₗ[R] S' :=
  _root_.TensorProduct.comm R R' S ≪≫ₗ
    LinearEquiv.restrictScalars R (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
r : R'
x : R' ⊗[R] S
⊢ AddHom.toFun src✝.toAddHom (r • x) = (RingHom.id R') r • AddHom.toFun src✝.toAddHom x

Next tactic:
change
      h.1.equiv (TensorProduct.comm R R' S (r • x)) = r • h.1.equiv (TensorProduct.comm R R' S x)
@[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)
    

Proof state:
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
src✝ : R' ⊗[R] S ≃ₗ[R] S' :=
  _root_.TensorProduct.comm R R' S ≪≫ₗ
    LinearEquiv.restrictScalars R (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
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)

Next tactic:
refine TensorProduct.induction_on x ?_ ?_ ?_
@[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 ?_ ?_ ?_
    · 

Proof state:
case refine_1
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
src✝ : R' ⊗[R] S ≃ₗ[R] S' :=
  _root_.TensorProduct.comm R R' S ≪≫ₗ
    LinearEquiv.restrictScalars R (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
r : R'
x : R' ⊗[R] S
⊢ (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
      ((TensorProduct.comm R R' S) (r • 0)) =
    r •
      (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S')))) ((TensorProduct.comm R R' S) 0)

Next tactic:
simp only [smul_zero, map_zero]
@[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]
    · 

Proof state:
case refine_2
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
src✝ : R' ⊗[R] S ≃ₗ[R] S' :=
  _root_.TensorProduct.comm R R' S ≪≫ₗ
    LinearEquiv.restrictScalars R (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
r : R'
x : R' ⊗[R] S
⊢ ∀ (x : R') (y : S),
    (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
        ((TensorProduct.comm R R' S) (r • x ⊗ₜ[R] y)) =
      r •
        (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
          ((TensorProduct.comm R R' S) (x ⊗ₜ[R] y))

Next tactic:
intro x y
@[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
      

Proof state:
case refine_2
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
src✝ : R' ⊗[R] S ≃ₗ[R] S' :=
  _root_.TensorProduct.comm R R' S ≪≫ₗ
    LinearEquiv.restrictScalars R (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
r : R'
x✝ : R' ⊗[R] S
x : R'
y : S
⊢ (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
      ((TensorProduct.comm R R' S) (r • x ⊗ₜ[R] y)) =
    r •
      (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
        ((TensorProduct.comm R R' S) (x ⊗ₜ[R] y))

Next tactic:
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']
@[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']
      

Proof state:
case refine_2
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
src✝ : R' ⊗[R] S ≃ₗ[R] S' :=
  _root_.TensorProduct.comm R R' S ≪≫ₗ
    LinearEquiv.restrictScalars R (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
r : R'
x✝ : R' ⊗[R] S
x : R'
y : S
⊢ (algebraMap S S') y * ((algebraMap R' S') r * (algebraMap R' S') x) =
    (algebraMap R' S') r * ((algebraMap S S') y * (algebraMap R' S') x)

Next tactic:
ring
@[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
    · 

Proof state:
case refine_3
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
src✝ : R' ⊗[R] S ≃ₗ[R] S' :=
  _root_.TensorProduct.comm R R' S ≪≫ₗ
    LinearEquiv.restrictScalars R (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
r : R'
x : R' ⊗[R] S
⊢ ∀ (x y : 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) →
      (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
            ((TensorProduct.comm R R' S) (r • y)) =
          r •
            (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
              ((TensorProduct.comm R R' S) y) →
        (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
            ((TensorProduct.comm R R' S) (r • (x + y))) =
          r •
            (IsBaseChange.equiv (_ : IsBaseChange S (AlgHom.toLinearMap (toAlgHom R R' S'))))
              ((TensorProduct.comm R R' S) (x + y))

Next tactic:
intro x y hx hy