UnluckyOrangutan/tactic-haveDraft8 · Datasets at Hugging Face

tactic stringlengths 1 5.59k	name stringlengths 1 85	haveDraft stringlengths 1 44.5k	goal stringlengths 8 62.2k
rw [inter_comm, card_sdiff_comm]	rw	#r = #s	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ r ∩ s, x + #(r \ s) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))
inter_comm,	this	∑ x ∈ s ∩ r, x + #(r \ s) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ r ∩ s, x + #(r \ s) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))
card_sdiff_comm	card_sdiff_comm	∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ s ∩ r, x + #(r \ s) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))
card_sdiff_comm	card_sdiff_comm	#r = #s	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) card_sdiff_comm : ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ s ∩ r, x + #(r \ s) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))
Int.card_Ico,	this	(c + (↑(#s) : ℤ) - c).toNat = #s	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ #r = #s
add_sub_cancel_left,	this	(↑(#s) : ℤ).toNat = #s	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ (c + (↑(#s) : ℤ) - c).toNat = #s
Int.toNat_natCast	this	#s = #s	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ (↑(#s) : ℤ).toNat = #s
rw [← sum_inter_add_sum_diff s r _]	rw	∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ≤ ∑ x ∈ s ∩ r, x + ∑ x ∈ s \ r, x	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ≤ ∑ x ∈ s, x
← sum_inter_add_sum_diff s r _	sum_inter_add_sum_diff	∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ≤ ∑ x ∈ s ∩ r, x + ∑ x ∈ s \ r, x	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ≤ ∑ x ∈ s, x
refine add_le_add_left (card_nsmul_le_sum _ _ _ fun x mx ↦ ?_) _	refine	x ∈ s \ r → c + (↑(#s) : ℤ) ≤ x	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ≤ ∑ x ∈ s ∩ r, x + ∑ x ∈ s \ r, x
rw [mem_sdiff, mem_Ico, not_and] at mx	rw	x ∈ s ∧ (c ≤ x → ¬x < c + (↑(#s) : ℤ))	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) x : ℤ mx : x ∈ s \ r ⊢ c + (↑(#s) : ℤ) ≤ x
mem_sdiff,	this	x ∈ s ∧ x ∉ r	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) x : ℤ mx : x ∈ s \ r ⊢ c + (↑(#s) : ℤ) ≤ x
mem_Ico,	this	x ∈ s ∧ ¬(c ≤ x ∧ x < c + (↑(#s) : ℤ))	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) x : ℤ mx : x ∈ s ∧ x ∉ r ⊢ c + (↑(#s) : ℤ) ≤ x
not_and	not_and	x ∈ s ∧ (c ≤ x → ¬x < c + (↑(#s) : ℤ))	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) x : ℤ mx : x ∈ s ∧ ¬(c ≤ x ∧ x < c + (↑(#s) : ℤ)) ⊢ c + (↑(#s) : ℤ) ≤ x
have := mx.2 (hs _ mx.1)	have	¬x < c + (↑(#s) : ℤ)	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) x : ℤ mx : x ∈ s ∧ (c ≤ x → ¬x < c + (↑(#s) : ℤ)) ⊢ c + (↑(#s) : ℤ) ≤ x
convert sum_Ico_le_sum hs	h	∑ n ∈ range #s, (c + (↑n : ℤ)) = ∑ x ∈ Ico c (c + (↑(#s) : ℤ)), x	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x ⊢ ∑ n ∈ range #s, (c + (↑n : ℤ)) ≤ ∑ x ∈ s, x
refine sum_nbij (c + ·) ?_ ?_ ?_ (fun _ _ ↦ rfl)	h	∀ a ∈ range #s, (fun x ↦ c + (↑x : ℤ)) a ∈ Ico c (c + (↑(#s) : ℤ))	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x ⊢ ∑ n ∈ range #s, (c + (↑n : ℤ)) = ∑ x ∈ Ico c (c + (↑(#s) : ℤ)), x
refine sum_nbij (c + ·) ?_ ?_ ?_ (fun _ _ ↦ rfl)	h	Set.InjOn (fun x ↦ c + (↑x : ℤ)) (↑(range #s) : Set ℕ)	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x h : ∀ a ∈ range #s, (fun x ↦ c + (↑x : ℤ)) a ∈ Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ n ∈ range #s, (c + (↑n : ℤ)) = ∑ x ∈ Ico c (c + (↑(#s) : ℤ)), x
refine sum_nbij (c + ·) ?_ ?_ ?_ (fun _ _ ↦ rfl)	h	Set.SurjOn (fun x ↦ c + (↑x : ℤ)) (↑(range #s) : Set ℕ) (↑(Ico c (c + (↑(#s) : ℤ))) : Set ℤ)	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x h : ∀ a ∈ range #s, (fun x ↦ c + (↑x : ℤ)) a ∈ Ico c (c + (↑(#s) : ℤ)) h₁ : Set.InjOn (fun x ↦ c + (↑x : ℤ)) (↑(range #s) : Set ℕ) ⊢ ∑ n ∈ range #s, (c + (↑n : ℤ)) = ∑ x ∈ Ico c (c + (↑(#s) : ℤ)), x
rw [mem_Ico]	h	c ≤ (fun x ↦ c + (↑x : ℤ)) x ∧ (fun x ↦ c + (↑x : ℤ)) x < c + (↑(#s) : ℤ)	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℕ mx : x ∈ range #s ⊢ (fun x ↦ c + (↑x : ℤ)) x ∈ Ico c (c + (↑(#s) : ℤ))
mem_Ico	h	c ≤ (fun x ↦ c + (↑x : ℤ)) x ∧ (fun x ↦ c + (↑x : ℤ)) x < c + (↑(#s) : ℤ)	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℕ mx : x ∈ range #s ⊢ (fun x ↦ c + (↑x : ℤ)) x ∈ Ico c (c + (↑(#s) : ℤ))
rw [mem_range] at mx	h	x < #s	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℕ mx : x ∈ range #s ⊢ c ≤ c + (↑x : ℤ) ∧ c + (↑x : ℤ) < c + (↑(#s) : ℤ)
mem_range	h	x < #s	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℕ mx : x ∈ range #s ⊢ c ≤ c + (↑x : ℤ) ∧ c + (↑x : ℤ) < c + (↑(#s) : ℤ)
simp_rw [coe_range, Set.mem_image, Set.mem_Iio]	h	∃ x_1 < #s, c + (↑x_1 : ℤ) = x	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℤ mx : x ∈ (↑(Ico c (c + (↑(#s) : ℤ))) : Set ℤ) ⊢ x ∈ (fun x ↦ c + (↑x : ℤ)) '' (↑(range #s) : Set ℕ)
rw [mem_coe, mem_Ico] at mx	h	c ≤ x ∧ x < c + (↑(#s) : ℤ)	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℤ mx : x ∈ (↑(Ico c (c + (↑(#s) : ℤ))) : Set ℤ) ⊢ ∃ x_1 < #s, c + (↑x_1 : ℤ) = x
mem_coe,	h	x ∈ Ico c (c + (↑(#s) : ℤ))	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℤ mx : x ∈ (↑(Ico c (c + (↑(#s) : ℤ))) : Set ℤ) ⊢ ∃ x_1 < #s, c + (↑x_1 : ℤ) = x
mem_Ico	h	c ≤ x ∧ x < c + (↑(#s) : ℤ)	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℤ mx : x ∈ Ico c (c + (↑(#s) : ℤ)) ⊢ ∃ x_1 < #s, c + (↑x_1 : ℤ) = x
use (x - c).toNat	h	(x - c).toNat < #s ∧ c + (↑(x - c).toNat : ℤ) = x	s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℤ mx : c ≤ x ∧ x < c + (↑(#s) : ℤ) ⊢ ∃ x_1 < #s, c + (↑x_1 : ℤ) = x
fapply Limits.PushoutCocone.mk	W	CommRingCat	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B ⊢ PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B))
fapply Limits.PushoutCocone.mk	inl	of A ⟶ of (A ⊗[R] B)	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B W : CommRingCat ⊢ PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B))
fapply Limits.PushoutCocone.mk	inr	of B ⟶ of (A ⊗[R] B)	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B W : CommRingCat inl : of A ⟶ of (A ⊗[R] B) ⊢ PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B))
fapply Limits.PushoutCocone.mk	eq	ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom = ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B W : CommRingCat inl : of A ⟶ of (A ⊗[R] B) inr : of B ⟶ of (A ⊗[R] B) ⊢ PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B))
ext r	eq	(Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r = (Hom.hom (ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B ⊢ ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom = ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom
trans algebraMap R (A ⊗[R] B) r	trans	(Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r = (algebraMap R (A ⊗[R] B) : R → A ⊗[R] B) r	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B r : (↑(of R) : Type u) ⊢ (Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r = (Hom.hom (ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r
trans algebraMap R (A ⊗[R] B) r	trans	(algebraMap R (A ⊗[R] B) : R → A ⊗[R] B) r = (Hom.hom (ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B r : (↑(of R) : Type u) trans : (Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r = (algebraMap R (A ⊗[R] B) : R → A ⊗[R] B) r ⊢ (Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r = (Hom.hom (ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r
use ofHom (AlgHom.toRingHom (Algebra.TensorProduct.productMap f' g'))	property	(pushoutCocone R A B).inl ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl ∧ (pushoutCocone R A B).inr ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, (pushoutCocone R A B).inl ≫ m = s.inl → (pushoutCocone R A B).inr ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this ⊢ { l // (pushoutCocone R A B).inl ≫ l = s.inl ∧ (pushoutCocone R A B).inr ≫ l = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, (pushoutCocone R A B).inl ≫ m = s.inl → (pushoutCocone R A B).inr ≫ m = s.inr → m = l }
constructor	property	ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this ⊢ ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl ∧ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom
constructor	property	ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this property : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl ⊢ ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl ∧ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom
ext x	property	(Hom.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom) : (↑(of A) : Type u) → (↑s.pt : Type u)) x = (Hom.hom s.inl : (↑(of A) : Type u) → (↑s.pt : Type u)) x	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this ⊢ ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl
constructor	property	ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this ⊢ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom
constructor	property	∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this property : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ⊢ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom
ext x	property	(Hom.hom (ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom) : (↑(of B) : Type u) → (↑s.pt : Type u)) x = (Hom.hom s.inr : (↑(of B) : Type u) → (↑s.pt : Type u)) x	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this ⊢ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr
change h (algebraMap R A r ⊗ₜ[R] 1) = s.inl (algebraMap R A r)	change	(ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom s.inl : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr r : R ⊢ (↑(↑(Hom.hom h) : (↑(pushoutCocone R A B).pt : Type u) →* (↑s.pt : Type u)) : OneHom (↑(pushoutCocone R A B).pt : Type u) (↑s.pt : Type u)).toFun ((algebraMap R (A ⊗[R] B) : R → A ⊗[R] B) r) = (algebraMap R (↑s.pt : Type u) : R → (↑s.pt : Type u)) r
rw [← eq1]	rw	(ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr r : R ⊢ (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom s.inl : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)
← eq1	eq1	(ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr r : R ⊢ (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom s.inl : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)
simp only [pushoutCocone_pt, coe_of, AlgHom.toRingHom_eq_coe]	simp	(ConcreteCategory.hom h : A ⊗[R] B → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : A → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr r : R ⊢ (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)
suffices h' = Algebra.TensorProduct.productMap f' g' by ext x change h' x = Algebra.TensorProduct.productMap f' g' x rw [this]	property	h' = Algebra.TensorProduct.productMap f' g'	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } ⊢ h = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom
ext x	hf	(Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) x = (Hom.hom (ofHom (Algebra.TensorProduct.productMap f' g').toRingHom) : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) x	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝¹ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this✝ : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } this : h' = Algebra.TensorProduct.productMap f' g' ⊢ h = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom
change h' x = Algebra.TensorProduct.productMap f' g' x	hf	(h' : A ⊗[R] B → (↑s.pt : Type u)) x = (Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) x	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝¹ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this✝ : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } this : h' = Algebra.TensorProduct.productMap f' g' x : (↑(pushoutCocone R A B).pt : Type u) ⊢ (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) x = (Hom.hom (ofHom (Algebra.TensorProduct.productMap f' g').toRingHom) : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) x
this	hf	(Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) x = (Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) x	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝¹ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this✝ : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } this : h' = Algebra.TensorProduct.productMap f' g' x : (↑(pushoutCocone R A B).pt : Type u) ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) x = (Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) x
apply Algebra.TensorProduct.ext'	property	∀ (a : A) (b : B), (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b)	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } ⊢ h' = Algebra.TensorProduct.productMap f' g'
simp only [f', g', ← eq1, pushoutCocone_pt, ← eq2, AlgHom.toRingHom_eq_coe, Algebra.TensorProduct.productMap_apply_tmul, AlgHom.coe_mk]	property	(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : A → (↑s.pt : Type u)) a * (Hom.hom (ofHom (↑Algebra.TensorProduct.includeRight : B →+* A ⊗[R] B) ≫ h) : B → (↑s.pt : Type u)) b	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b)
change _ = h (a ⊗ₜ 1) * h (1 ⊗ₜ b)	property	(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] 1) * (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (1 ⊗ₜ[R] b)	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : A → (↑s.pt : Type u)) a * (Hom.hom (ofHom (↑Algebra.TensorProduct.includeRight : B →+* A ⊗[R] B) ≫ h) : B → (↑s.pt : Type u)) b
rw [← h.hom.map_mul, Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul]	property	(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] b)	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] 1) * (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (1 ⊗ₜ[R] b)
← h.hom.map_mul,	property	(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] 1 * 1 ⊗ₜ[R] b)	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] 1) * (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (1 ⊗ₜ[R] b)
Algebra.TensorProduct.tmul_mul_tmul,	property	(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((a * 1) ⊗ₜ[R] (1 * b))	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] 1 * 1 ⊗ₜ[R] b)
mul_one,	property	(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] (1 * b))	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((a * 1) ⊗ₜ[R] (1 * b))
one_mul	property	(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] b)	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] (1 * b))
ext	hf	(Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) x✝ = (Hom.hom (ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) x✝	R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B ⊢ ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom = ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom
ext	hf	(Hom.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ (Algebra.IsPushout.equiv R S A B).toRingEquiv.toCommRingCatIso.hom) : (↑(of S) : Type u) → (↑(of B) : Type u)) x✝ = (Hom.hom ((Iso.refl (of S)).hom ≫ ofHom (algebraMap S B)) : (↑(of S) : Type u) → (↑(of B) : Type u)) x✝	R S A B : Type u inst✝¹¹ : CommRing R inst✝¹⁰ : CommRing S inst✝⁹ : CommRing A inst✝⁸ : CommRing B inst✝⁷ : Algebra R S inst✝⁶ : Algebra S B inst✝⁵ : Algebra R A inst✝⁴ : Algebra A B inst✝³ : Algebra R B inst✝² : IsScalarTower R A B inst✝¹ : IsScalarTower R S B inst✝ : Algebra.IsPushout R S A B ⊢ ofHom Algebra.TensorProduct.includeLeftRingHom ≫ (Algebra.IsPushout.equiv R S A B).toRingEquiv.toCommRingCatIso.hom = (Iso.refl (of S)).hom ≫ ofHom (algebraMap S B)
ext	hf	(Hom.hom (ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ (Algebra.IsPushout.equiv R S A B).toRingEquiv.toCommRingCatIso.hom) : (↑(of A) : Type u) → (↑(of B) : Type u)) x✝ = (Hom.hom ((Iso.refl (of A)).hom ≫ ofHom (algebraMap A B)) : (↑(of A) : Type u) → (↑(of B) : Type u)) x✝	R S A B : Type u inst✝¹¹ : CommRing R inst✝¹⁰ : CommRing S inst✝⁹ : CommRing A inst✝⁸ : CommRing B inst✝⁷ : Algebra R S inst✝⁶ : Algebra S B inst✝⁵ : Algebra R A inst✝⁴ : Algebra A B inst✝³ : Algebra R B inst✝² : IsScalarTower R A B inst✝¹ : IsScalarTower R S B inst✝ : Algebra.IsPushout R S A B ⊢ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ (Algebra.IsPushout.equiv R S A B).toRingEquiv.toCommRingCatIso.hom = (Iso.refl (of A)).hom ≫ ofHom (algebraMap A B)
cases j <;> ext a	left	(Hom.hom ((A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) a = (Hom.hom (s.ι.app { as := WalkingPair.left }) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) a	A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair j : WalkingPair ⊢ (A.coproductCocone B).ι.app { as := j } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := j }
cases j <;> ext a	right	(Hom.hom ((A.coproductCocone B).ι.app { as := WalkingPair.right } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom) : (↑((pair A B).obj { as := WalkingPair.right }) : Type u) → (↑s.pt : Type u)) a = (Hom.hom (s.ι.app { as := WalkingPair.right }) : (↑((pair A B).obj { as := WalkingPair.right }) : Type u) → (↑s.pt : Type u)) a	A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair j : WalkingPair left : (Hom.hom ((A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) _fvar.97312 = (Hom.hom (s.ι.app { as := WalkingPair.left }) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) _fvar.97312 ⊢ (A.coproductCocone B).ι.app { as := j } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := j }
cases j	left	(A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom = s.ι.app { as := WalkingPair.left }	A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair j : WalkingPair ⊢ (A.coproductCocone B).ι.app { as := j } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := j }
cases j	right	(A.coproductCocone B).ι.app { as := WalkingPair.right } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom = s.ι.app { as := WalkingPair.right }	A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair j : WalkingPair left : (A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := WalkingPair.left } ⊢ (A.coproductCocone B).ι.app { as := j } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := j }
ext a	left	(Hom.hom ((A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) a = (Hom.hom (s.ι.app { as := WalkingPair.left }) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) a	A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair ⊢ (A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := WalkingPair.left }
ext a	right	(Hom.hom ((A.coproductCocone B).ι.app { as := WalkingPair.right } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom) : (↑((pair A B).obj { as := WalkingPair.right }) : Type u) → (↑s.pt : Type u)) a = (Hom.hom (s.ι.app { as := WalkingPair.right }) : (↑((pair A B).obj { as := WalkingPair.right }) : Type u) → (↑s.pt : Type u)) a	A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair ⊢ (A.coproductCocone B).ι.app { as := WalkingPair.right } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := WalkingPair.right }
apply CommRingCat.hom_ext	_private	{ hom' := m }.hom = Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)	A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ { hom' := m } = ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom
apply RingHom.toIntAlgHom_injective	_private	{ hom' := m }.hom.toIntAlgHom = (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom	A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ { hom' := m }.hom = Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)
apply Algebra.TensorProduct.liftEquiv.symm.injective	_private	(Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) { hom' := m }.hom.toIntAlgHom = (Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom	A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ { hom' := m }.hom.toIntAlgHom = (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom
apply Subtype.ext	_private	(↑((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) { hom' := m }.hom.toIntAlgHom) : ((↑A : Type u) →ₐ[ℤ] (↑s.pt : Type u)) × ((↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u))) = (↑((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom) : ((↑A : Type u) →ₐ[ℤ] (↑s.pt : Type u)) × ((↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)))	A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ (Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) { hom' := m }.hom.toIntAlgHom = (Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom
rw [Algebra.TensorProduct.liftEquiv_symm_apply_coe, Prod.mk.injEq]	_private	{ hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.1 ∧ (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.2	A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ (↑((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) { hom' := m }.hom.toIntAlgHom) : ((↑A : Type u) →ₐ[ℤ] (↑s.pt : Type u)) × ((↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u))) = (↑((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom) : ((↑A : Type u) →ₐ[ℤ] (↑s.pt : Type u)) × ((↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)))
Prod.mk.injEq	_private	{ hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.1 ∧ (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.2	A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ ({ hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft, (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight) = (↑((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom) : ((↑A : Type u) →ₐ[ℤ] (↑s.pt : Type u)) × ((↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)))
constructor	_private	{ hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.1	A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ { hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.1 ∧ (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.2
constructor	_private	(AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.2	A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j _private : { hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.1 ⊢ { hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.1 ∧ (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.2
ext a	_private	({ hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft : (↑A : Type u) → (↑s.pt : Type u)) a = (((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.1 : (↑A : Type u) → (↑s.pt : Type u)) a	A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ { hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.1
ext b	_private	((AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight : (↑B : Type u) → (↑s.pt : Type u)) b = (((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.2 : (↑B : Type u) → (↑s.pt : Type u)) b	A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.2
apply hasStrictTerminalObjects_of_terminal_is_strict (CommRingCat.of PUnit)	apply	∀ (A : CommRingCat) (f : of PUnit.{u + 1} ⟶ A), IsIso f	⊢ HasStrictTerminalObjects CommRingCat
refine ⟨ofHom ⟨1, rfl, by simp⟩, ?_, ?_⟩	refine_1	f ≫ ofHom { toMonoidHom := 1, map_zero' := sorry, map_add' := sorry } = 𝟙 (of PUnit.{u + 1})	X : CommRingCat f : of PUnit.{u + 1} ⟶ X ⊢ IsIso f
refine ⟨ofHom ⟨1, rfl, by simp⟩, ?_, ?_⟩	refine_2	ofHom { toMonoidHom := 1, map_zero' := sorry, map_add' := sorry } ≫ f = 𝟙 X	X : CommRingCat f : of PUnit.{u + 1} ⟶ X refine_1 : f ≫ ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } = 𝟙 (of PUnit.{u + 1}) ⊢ IsIso f
ext x	refine_2	(Hom.hom (ofHom { toMonoidHom := 1, map_zero' := sorry, map_add' := sorry } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x	X : CommRingCat f : of PUnit.{u + 1} ⟶ X ⊢ ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f = 𝟙 X
have e : (0 : X) = 1 := by rw [← f.hom.map_one, ← f.hom.map_zero]	refine_2	0 = 1	X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x
← f.hom.map_one,	this	0 = (Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 1	X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) ⊢ 0 = 1
← f.hom.map_zero	this	(Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 0 = (Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 1	X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) ⊢ 0 = (Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 1
replace e : 0 * x = 1 * x := congr_arg (· * x) e	refine_2	0 * x = 1 * x	X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) e : 0 = 1 ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x
rw [one_mul, zero_mul, ← f.hom.map_zero] at e	refine_2	(Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 0 = x	X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) e : 0 * x = 1 * x ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x
one_mul,	refine_2	0 * x = x	X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) e : 0 * x = 1 * x ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x
zero_mul,	refine_2	0 = x	X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) e : 0 * x = x ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x
← f.hom.map_zero	refine_2	(Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 0 = x	X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) e : 0 = x ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x
ext : 1	hf	Hom.hom x✝ = Hom.hom default	R : CommRingCat x✝ : of (ULift.{u, 0} ℤ) ⟶ R ⊢ x✝ = default
rw [← RingHom.cancel_right (f := (ULift.ringEquiv.{0, u} (R := ℤ)).symm.toRingHom) (hf := ULift.ringEquiv.symm.surjective)]	hf	(Hom.hom x✝).comp ULift.ringEquiv.symm.toRingHom = (Hom.hom default).comp ULift.ringEquiv.symm.toRingHom	R : CommRingCat x✝ : of (ULift.{u, 0} ℤ) ⟶ R ⊢ Hom.hom x✝ = Hom.hom default
← RingHom.cancel_right (f := (ULift.ringEquiv.{0, u} (R := ℤ)).symm.toRingHom) (hf := ULift.ringEquiv.symm.surjective)	hf	(Hom.hom x✝).comp ULift.ringEquiv.symm.toRingHom = (Hom.hom default).comp ULift.ringEquiv.symm.toRingHom	R : CommRingCat x✝ : of (ULift.{u, 0} ℤ) ⟶ R ⊢ Hom.hom x✝ = Hom.hom default
ext	hf	(Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝ = (Hom.hom (c.π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝	A B : CommRingCat c : Cone (pair A B) j : Discrete WalkingPair ⊢ ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j = c.π.app j
rcases j with ⟨⟨⟩⟩ <;> simp only [pair_obj_left, prodFan_pt, BinaryFan.π_app_left, BinaryFan.π_app_right, FunctorToTypes.map_comp_apply, forget_map, coe_of, RingHom.prod_apply]	hf	(Hom.hom (ofHom ((Hom.hom (BinaryFan.fst c)).prod (Hom.hom (BinaryFan.snd c))) ≫ (A.prodFan B).fst) : (↑c.pt : Type u) → (↑A : Type u)) x✝ = (Hom.hom (BinaryFan.fst c) : (↑c.pt : Type u) → (↑A : Type u)) x✝	A B : CommRingCat c : Cone (pair A B) j : Discrete WalkingPair x✝ : (↑c.pt : Type u) ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝ = (Hom.hom (c.π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝
rcases j with ⟨⟨⟩⟩ <;> simp only [pair_obj_left, prodFan_pt, BinaryFan.π_app_left, BinaryFan.π_app_right, FunctorToTypes.map_comp_apply, forget_map, coe_of, RingHom.prod_apply]	hf	(Hom.hom (ofHom ((Hom.hom (BinaryFan.fst c)).prod (Hom.hom (BinaryFan.snd c))) ≫ (A.prodFan B).snd) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝ = (Hom.hom (BinaryFan.snd c) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝	A B : CommRingCat c : Cone (pair A B) j : Discrete WalkingPair x✝ : (↑c.pt : Type u) hf : (Hom.hom (ofHom ((Hom.hom (BinaryFan.fst c)).prod (Hom.hom (BinaryFan.snd c))) ≫ (A.prodFan B).fst) : (↑c.pt : Type u) → (↑A : Type u)) x✝ = (Hom.hom (BinaryFan.fst c) : (↑c.pt : Type u) → (↑A : Type u)) x✝ ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝ = (Hom.hom (c.π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝
rcases j with ⟨⟨⟩⟩	hf	(Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝ = (Hom.hom (c.π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝	A B : CommRingCat c : Cone (pair A B) j : Discrete WalkingPair x✝ : (↑c.pt : Type u) ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝ = (Hom.hom (c.π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝
rcases j with ⟨⟨⟩⟩	hf	(Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app { as := WalkingPair.right }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝ = (Hom.hom (c.π.app { as := WalkingPair.right }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝	A B : CommRingCat c : Cone (pair A B) j : Discrete WalkingPair x✝ : (↑c.pt : Type u) hf : (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝ = (Hom.hom (c.π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝ ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝ = (Hom.hom (c.π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝
simp only [pair_obj_left, prodFan_pt, BinaryFan.π_app_left, BinaryFan.π_app_right, FunctorToTypes.map_comp_apply, forget_map, coe_of, RingHom.prod_apply]	hf	(Hom.hom (ofHom ((Hom.hom (BinaryFan.fst c)).prod (Hom.hom (BinaryFan.snd c))) ≫ (A.prodFan B).fst) : (↑c.pt : Type u) → (↑A : Type u)) x✝ = (Hom.hom (BinaryFan.fst c) : (↑c.pt : Type u) → (↑A : Type u)) x✝	A B : CommRingCat c : Cone (pair A B) x✝ : (↑c.pt : Type u) ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝ = (Hom.hom (c.π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝
simp only [pair_obj_left, prodFan_pt, BinaryFan.π_app_left, BinaryFan.π_app_right, FunctorToTypes.map_comp_apply, forget_map, coe_of, RingHom.prod_apply]	hf	(Hom.hom (ofHom ((Hom.hom (BinaryFan.fst c)).prod (Hom.hom (BinaryFan.snd c))) ≫ (A.prodFan B).snd) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝ = (Hom.hom (BinaryFan.snd c) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝	A B : CommRingCat c : Cone (pair A B) x✝ : (↑c.pt : Type u) ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app { as := WalkingPair.right }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝ = (Hom.hom (c.π.app { as := WalkingPair.right }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝
ext x	hf	(Hom.hom m : (↑s.pt : Type u) → (↑(A.prodFan B).pt : Type u)) x = (Hom.hom (ofHom ((Hom.hom (s.π.app { as := WalkingPair.left })).prod (Hom.hom (s.π.app { as := WalkingPair.right })))) : (↑s.pt : Type u) → (↑(A.prodFan B).pt : Type u)) x	A B : CommRingCat s : Cone (pair A B) m : s.pt ⟶ (A.prodFan B).pt h : ∀ (j : Discrete WalkingPair), m ≫ (A.prodFan B).π.app j = s.π.app j ⊢ m = ofHom ((Hom.hom (s.π.app { as := WalkingPair.left })).prod (Hom.hom (s.π.app { as := WalkingPair.right })))

rw [inter_comm, card_sdiff_comm]

rw

#r = #s

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ r ∩ s, x + #(r \ s) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))

inter_comm,

this

∑ x ∈ s ∩ r, x + #(r \ s) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ r ∩ s, x + #(r \ s) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))

card_sdiff_comm

∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ s ∩ r, x + #(r \ s) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))

card_sdiff_comm

#r = #s

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) card_sdiff_comm : ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ s ∩ r, x + #(r \ s) • (c + (↑(#s) : ℤ)) = ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ))

Int.card_Ico,

this

(c + (↑(#s) : ℤ) - c).toNat = #s

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ #r = #s

add_sub_cancel_left,

this

(↑(#s) : ℤ).toNat = #s

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ (c + (↑(#s) : ℤ) - c).toNat = #s

Int.toNat_natCast

this

#s = #s

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ (↑(#s) : ℤ).toNat = #s

rw [← sum_inter_add_sum_diff s r _]

rw

∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ≤ ∑ x ∈ s ∩ r, x + ∑ x ∈ s \ r, x

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ≤ ∑ x ∈ s, x

← sum_inter_add_sum_diff s r _

sum_inter_add_sum_diff

∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ≤ ∑ x ∈ s ∩ r, x + ∑ x ∈ s \ r, x

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ≤ ∑ x ∈ s, x

refine add_le_add_left (card_nsmul_le_sum _ _ _ fun x mx ↦ ?_) _

refine

x ∈ s \ r → c + (↑(#s) : ℤ) ≤ x

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ x ∈ s ∩ r, x + #(s \ r) • (c + (↑(#s) : ℤ)) ≤ ∑ x ∈ s ∩ r, x + ∑ x ∈ s \ r, x

rw [mem_sdiff, mem_Ico, not_and] at mx

rw

x ∈ s ∧ (c ≤ x → ¬x < c + (↑(#s) : ℤ))

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) x : ℤ mx : x ∈ s \ r ⊢ c + (↑(#s) : ℤ) ≤ x

mem_sdiff,

this

x ∈ s ∧ x ∉ r

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) x : ℤ mx : x ∈ s \ r ⊢ c + (↑(#s) : ℤ) ≤ x

mem_Ico,

this

x ∈ s ∧ ¬(c ≤ x ∧ x < c + (↑(#s) : ℤ))

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) x : ℤ mx : x ∈ s ∧ x ∉ r ⊢ c + (↑(#s) : ℤ) ≤ x

not_and

x ∈ s ∧ (c ≤ x → ¬x < c + (↑(#s) : ℤ))

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) x : ℤ mx : x ∈ s ∧ ¬(c ≤ x ∧ x < c + (↑(#s) : ℤ)) ⊢ c + (↑(#s) : ℤ) ≤ x

have := mx.2 (hs _ mx.1)

have

¬x < c + (↑(#s) : ℤ)

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x r : Finset ℤ := Ico c (c + (↑(#s) : ℤ)) x : ℤ mx : x ∈ s ∧ (c ≤ x → ¬x < c + (↑(#s) : ℤ)) ⊢ c + (↑(#s) : ℤ) ≤ x

convert sum_Ico_le_sum hs

h

∑ n ∈ range #s, (c + (↑n : ℤ)) = ∑ x ∈ Ico c (c + (↑(#s) : ℤ)), x

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x ⊢ ∑ n ∈ range #s, (c + (↑n : ℤ)) ≤ ∑ x ∈ s, x

refine sum_nbij (c + ·) ?_ ?_ ?_ (fun _ _ ↦ rfl)

h

∀ a ∈ range #s, (fun x ↦ c + (↑x : ℤ)) a ∈ Ico c (c + (↑(#s) : ℤ))

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x ⊢ ∑ n ∈ range #s, (c + (↑n : ℤ)) = ∑ x ∈ Ico c (c + (↑(#s) : ℤ)), x

refine sum_nbij (c + ·) ?_ ?_ ?_ (fun _ _ ↦ rfl)

h

Set.InjOn (fun x ↦ c + (↑x : ℤ)) (↑(range #s) : Set ℕ)

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x h : ∀ a ∈ range #s, (fun x ↦ c + (↑x : ℤ)) a ∈ Ico c (c + (↑(#s) : ℤ)) ⊢ ∑ n ∈ range #s, (c + (↑n : ℤ)) = ∑ x ∈ Ico c (c + (↑(#s) : ℤ)), x

refine sum_nbij (c + ·) ?_ ?_ ?_ (fun _ _ ↦ rfl)

h

Set.SurjOn (fun x ↦ c + (↑x : ℤ)) (↑(range #s) : Set ℕ) (↑(Ico c (c + (↑(#s) : ℤ))) : Set ℤ)

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x h : ∀ a ∈ range #s, (fun x ↦ c + (↑x : ℤ)) a ∈ Ico c (c + (↑(#s) : ℤ)) h₁ : Set.InjOn (fun x ↦ c + (↑x : ℤ)) (↑(range #s) : Set ℕ) ⊢ ∑ n ∈ range #s, (c + (↑n : ℤ)) = ∑ x ∈ Ico c (c + (↑(#s) : ℤ)), x

rw [mem_Ico]

h

c ≤ (fun x ↦ c + (↑x : ℤ)) x ∧ (fun x ↦ c + (↑x : ℤ)) x < c + (↑(#s) : ℤ)

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℕ mx : x ∈ range #s ⊢ (fun x ↦ c + (↑x : ℤ)) x ∈ Ico c (c + (↑(#s) : ℤ))

mem_Ico

h

c ≤ (fun x ↦ c + (↑x : ℤ)) x ∧ (fun x ↦ c + (↑x : ℤ)) x < c + (↑(#s) : ℤ)

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℕ mx : x ∈ range #s ⊢ (fun x ↦ c + (↑x : ℤ)) x ∈ Ico c (c + (↑(#s) : ℤ))

rw [mem_range] at mx

h

x < #s

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℕ mx : x ∈ range #s ⊢ c ≤ c + (↑x : ℤ) ∧ c + (↑x : ℤ) < c + (↑(#s) : ℤ)

mem_range

h

x < #s

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℕ mx : x ∈ range #s ⊢ c ≤ c + (↑x : ℤ) ∧ c + (↑x : ℤ) < c + (↑(#s) : ℤ)

simp_rw [coe_range, Set.mem_image, Set.mem_Iio]

h

∃ x_1 < #s, c + (↑x_1 : ℤ) = x

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℤ mx : x ∈ (↑(Ico c (c + (↑(#s) : ℤ))) : Set ℤ) ⊢ x ∈ (fun x ↦ c + (↑x : ℤ)) '' (↑(range #s) : Set ℕ)

rw [mem_coe, mem_Ico] at mx

h

c ≤ x ∧ x < c + (↑(#s) : ℤ)

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℤ mx : x ∈ (↑(Ico c (c + (↑(#s) : ℤ))) : Set ℤ) ⊢ ∃ x_1 < #s, c + (↑x_1 : ℤ) = x

mem_coe,

h

x ∈ Ico c (c + (↑(#s) : ℤ))

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℤ mx : x ∈ (↑(Ico c (c + (↑(#s) : ℤ))) : Set ℤ) ⊢ ∃ x_1 < #s, c + (↑x_1 : ℤ) = x

mem_Ico

h

c ≤ x ∧ x < c + (↑(#s) : ℤ)

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℤ mx : x ∈ Ico c (c + (↑(#s) : ℤ)) ⊢ ∃ x_1 < #s, c + (↑x_1 : ℤ) = x

use (x - c).toNat

h

(x - c).toNat < #s ∧ c + (↑(x - c).toNat : ℤ) = x

s : Finset ℤ c : ℤ hs : ∀ x ∈ s, c ≤ x x : ℤ mx : c ≤ x ∧ x < c + (↑(#s) : ℤ) ⊢ ∃ x_1 < #s, c + (↑x_1 : ℤ) = x

fapply Limits.PushoutCocone.mk

W

CommRingCat

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B ⊢ PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B))

fapply Limits.PushoutCocone.mk

inl

of A ⟶ of (A ⊗[R] B)

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B W : CommRingCat ⊢ PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B))

fapply Limits.PushoutCocone.mk

inr

of B ⟶ of (A ⊗[R] B)

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B W : CommRingCat inl : of A ⟶ of (A ⊗[R] B) ⊢ PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B))

fapply Limits.PushoutCocone.mk

eq

ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom = ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B W : CommRingCat inl : of A ⟶ of (A ⊗[R] B) inr : of B ⟶ of (A ⊗[R] B) ⊢ PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B))

ext r

eq

(Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r = (Hom.hom (ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B ⊢ ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom = ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom

trans algebraMap R (A ⊗[R] B) r

trans

(Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r = (algebraMap R (A ⊗[R] B) : R → A ⊗[R] B) r

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B r : (↑(of R) : Type u) ⊢ (Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r = (Hom.hom (ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r

trans algebraMap R (A ⊗[R] B) r

trans

(algebraMap R (A ⊗[R] B) : R → A ⊗[R] B) r = (Hom.hom (ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B r : (↑(of R) : Type u) trans : (Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r = (algebraMap R (A ⊗[R] B) : R → A ⊗[R] B) r ⊢ (Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r = (Hom.hom (ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) r

use ofHom (AlgHom.toRingHom (Algebra.TensorProduct.productMap f' g'))

property

(pushoutCocone R A B).inl ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl ∧ (pushoutCocone R A B).inr ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, (pushoutCocone R A B).inl ≫ m = s.inl → (pushoutCocone R A B).inr ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this ⊢ { l // (pushoutCocone R A B).inl ≫ l = s.inl ∧ (pushoutCocone R A B).inr ≫ l = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, (pushoutCocone R A B).inl ≫ m = s.inl → (pushoutCocone R A B).inr ≫ m = s.inr → m = l }

constructor

property

ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this ⊢ ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl ∧ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom

constructor

property

ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this property : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl ⊢ ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl ∧ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom

ext x

property

(Hom.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom) : (↑(of A) : Type u) → (↑s.pt : Type u)) x = (Hom.hom s.inl : (↑(of A) : Type u) → (↑s.pt : Type u)) x

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this ⊢ ofHom Algebra.TensorProduct.includeLeftRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inl

constructor

property

ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this ⊢ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom

constructor

property

∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this property : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ⊢ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr ∧ ∀ {m : (pushoutCocone R A B).pt ⟶ s.pt}, ofHom Algebra.TensorProduct.includeLeftRingHom ≫ m = s.inl → ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ m = s.inr → m = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom

ext x

property

(Hom.hom (ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom) : (↑(of B) : Type u) → (↑s.pt : Type u)) x = (Hom.hom s.inr : (↑(of B) : Type u) → (↑s.pt : Type u)) x

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this ⊢ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ ofHom (Algebra.TensorProduct.productMap f' g').toRingHom = s.inr

change h (algebraMap R A r ⊗ₜ[R] 1) = s.inl (algebraMap R A r)

change

(ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom s.inl : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr r : R ⊢ (↑(↑(Hom.hom h) : (↑(pushoutCocone R A B).pt : Type u) →* (↑s.pt : Type u)) : OneHom (↑(pushoutCocone R A B).pt : Type u) (↑s.pt : Type u)).toFun ((algebraMap R (A ⊗[R] B) : R → A ⊗[R] B) r) = (algebraMap R (↑s.pt : Type u) : R → (↑s.pt : Type u)) r

rw [← eq1]

rw

(ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr r : R ⊢ (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom s.inl : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)

← eq1

eq1

(ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr r : R ⊢ (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom s.inl : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)

simp only [pushoutCocone_pt, coe_of, AlgHom.toRingHom_eq_coe]

simp

(ConcreteCategory.hom h : A ⊗[R] B → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : A → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr r : R ⊢ (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r ⊗ₜ[R] 1) = (ConcreteCategory.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : (↑(of A) : Type u) → (↑s.pt : Type u)) ((algebraMap R A : R → A) r)

suffices h' = Algebra.TensorProduct.productMap f' g' by ext x change h' x = Algebra.TensorProduct.productMap f' g' x rw [this]

property

h' = Algebra.TensorProduct.productMap f' g'

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } ⊢ h = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom

ext x

hf

(Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) x = (Hom.hom (ofHom (Algebra.TensorProduct.productMap f' g').toRingHom) : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) x

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝¹ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this✝ : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } this : h' = Algebra.TensorProduct.productMap f' g' ⊢ h = ofHom (Algebra.TensorProduct.productMap f' g').toRingHom

change h' x = Algebra.TensorProduct.productMap f' g' x

hf

(h' : A ⊗[R] B → (↑s.pt : Type u)) x = (Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) x

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝¹ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this✝ : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } this : h' = Algebra.TensorProduct.productMap f' g' x : (↑(pushoutCocone R A B).pt : Type u) ⊢ (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) x = (Hom.hom (ofHom (Algebra.TensorProduct.productMap f' g').toRingHom) : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) x

this

hf

(Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) x = (Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) x

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝¹ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this✝ : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } this : h' = Algebra.TensorProduct.productMap f' g' x : (↑(pushoutCocone R A B).pt : Type u) ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) x = (Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) x

apply Algebra.TensorProduct.ext'

property

∀ (a : A) (b : B), (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b)

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } ⊢ h' = Algebra.TensorProduct.productMap f' g'

simp only [f', g', ← eq1, pushoutCocone_pt, ← eq2, AlgHom.toRingHom_eq_coe, Algebra.TensorProduct.productMap_apply_tmul, AlgHom.coe_mk]

property

(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : A → (↑s.pt : Type u)) a * (Hom.hom (ofHom (↑Algebra.TensorProduct.includeRight : B →+* A ⊗[R] B) ≫ h) : B → (↑s.pt : Type u)) b

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Algebra.TensorProduct.productMap f' g' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b)

change _ = h (a ⊗ₜ 1) * h (1 ⊗ₜ b)

property

(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] 1) * (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (1 ⊗ₜ[R] b)

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h) : A → (↑s.pt : Type u)) a * (Hom.hom (ofHom (↑Algebra.TensorProduct.includeRight : B →+* A ⊗[R] B) ≫ h) : B → (↑s.pt : Type u)) b

rw [← h.hom.map_mul, Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul]

property

(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] b)

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] 1) * (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (1 ⊗ₜ[R] b)

← h.hom.map_mul,

property

(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] 1 * 1 ⊗ₜ[R] b)

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] 1) * (ConcreteCategory.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (1 ⊗ₜ[R] b)

Algebra.TensorProduct.tmul_mul_tmul,

property

(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((a * 1) ⊗ₜ[R] (1 * b))

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] 1 * 1 ⊗ₜ[R] b)

mul_one,

property

(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] (1 * b))

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) ((a * 1) ⊗ₜ[R] (1 * b))

one_mul

property

(h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] b)

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B s : PushoutCocone (ofHom (algebraMap R A)) (ofHom (algebraMap R B)) this✝ : Algebra R (↑s.pt : Type u) := ((Hom.hom s.inl).comp (algebraMap R A)).toAlgebra f' : A →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inl; { toRingHom := __src, commutes' := ⋯ } g' : B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom s.inr; { toRingHom := __src, commutes' := ⋯ } this : Algebra R (↑(pushoutCocone R A B).pt : Type u) := let_fun this := inferInstance; this h : (pushoutCocone R A B).pt ⟶ s.pt eq1 : ofHom Algebra.TensorProduct.includeLeftRingHom ≫ h = s.inl eq2 : ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ h = s.inr h' : A ⊗[R] B →ₐ[R] (↑s.pt : Type u) := let __src := Hom.hom h; { toRingHom := __src, commutes' := ⋯ } a : A b : B ⊢ (h' : A ⊗[R] B → (↑s.pt : Type u)) (a ⊗ₜ[R] b) = (Hom.hom h : (↑(pushoutCocone R A B).pt : Type u) → (↑s.pt : Type u)) (a ⊗ₜ[R] (1 * b))

ext

hf

(Hom.hom (ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) x✝ = (Hom.hom (ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom) : (↑(of R) : Type u) → (↑(of (A ⊗[R] B)) : Type u)) x✝

R A B : Type u inst✝⁴ : CommRing R inst✝³ : CommRing A inst✝² : CommRing B inst✝¹ : Algebra R A inst✝ : Algebra R B ⊢ ofHom (algebraMap R A) ≫ ofHom Algebra.TensorProduct.includeLeftRingHom = ofHom (algebraMap R B) ≫ ofHom Algebra.TensorProduct.includeRight.toRingHom

ext

hf

(Hom.hom (ofHom Algebra.TensorProduct.includeLeftRingHom ≫ (Algebra.IsPushout.equiv R S A B).toRingEquiv.toCommRingCatIso.hom) : (↑(of S) : Type u) → (↑(of B) : Type u)) x✝ = (Hom.hom ((Iso.refl (of S)).hom ≫ ofHom (algebraMap S B)) : (↑(of S) : Type u) → (↑(of B) : Type u)) x✝

R S A B : Type u inst✝¹¹ : CommRing R inst✝¹⁰ : CommRing S inst✝⁹ : CommRing A inst✝⁸ : CommRing B inst✝⁷ : Algebra R S inst✝⁶ : Algebra S B inst✝⁵ : Algebra R A inst✝⁴ : Algebra A B inst✝³ : Algebra R B inst✝² : IsScalarTower R A B inst✝¹ : IsScalarTower R S B inst✝ : Algebra.IsPushout R S A B ⊢ ofHom Algebra.TensorProduct.includeLeftRingHom ≫ (Algebra.IsPushout.equiv R S A B).toRingEquiv.toCommRingCatIso.hom = (Iso.refl (of S)).hom ≫ ofHom (algebraMap S B)

ext

hf

(Hom.hom (ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ (Algebra.IsPushout.equiv R S A B).toRingEquiv.toCommRingCatIso.hom) : (↑(of A) : Type u) → (↑(of B) : Type u)) x✝ = (Hom.hom ((Iso.refl (of A)).hom ≫ ofHom (algebraMap A B)) : (↑(of A) : Type u) → (↑(of B) : Type u)) x✝

R S A B : Type u inst✝¹¹ : CommRing R inst✝¹⁰ : CommRing S inst✝⁹ : CommRing A inst✝⁸ : CommRing B inst✝⁷ : Algebra R S inst✝⁶ : Algebra S B inst✝⁵ : Algebra R A inst✝⁴ : Algebra A B inst✝³ : Algebra R B inst✝² : IsScalarTower R A B inst✝¹ : IsScalarTower R S B inst✝ : Algebra.IsPushout R S A B ⊢ ofHom Algebra.TensorProduct.includeRight.toRingHom ≫ (Algebra.IsPushout.equiv R S A B).toRingEquiv.toCommRingCatIso.hom = (Iso.refl (of A)).hom ≫ ofHom (algebraMap A B)

cases j <;> ext a

left

(Hom.hom ((A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) a = (Hom.hom (s.ι.app { as := WalkingPair.left }) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) a

A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair j : WalkingPair ⊢ (A.coproductCocone B).ι.app { as := j } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := j }

cases j <;> ext a

right

(Hom.hom ((A.coproductCocone B).ι.app { as := WalkingPair.right } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom) : (↑((pair A B).obj { as := WalkingPair.right }) : Type u) → (↑s.pt : Type u)) a = (Hom.hom (s.ι.app { as := WalkingPair.right }) : (↑((pair A B).obj { as := WalkingPair.right }) : Type u) → (↑s.pt : Type u)) a

A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair j : WalkingPair left : (Hom.hom ((A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) _fvar.97312 = (Hom.hom (s.ι.app { as := WalkingPair.left }) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) _fvar.97312 ⊢ (A.coproductCocone B).ι.app { as := j } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := j }

cases j

left

(A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom = s.ι.app { as := WalkingPair.left }

A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair j : WalkingPair ⊢ (A.coproductCocone B).ι.app { as := j } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := j }

cases j

right

(A.coproductCocone B).ι.app { as := WalkingPair.right } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom = s.ι.app { as := WalkingPair.right }

A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair j : WalkingPair left : (A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := WalkingPair.left } ⊢ (A.coproductCocone B).ι.app { as := j } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := j }

ext a

left

(Hom.hom ((A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) a = (Hom.hom (s.ι.app { as := WalkingPair.left }) : (↑((pair A B).obj { as := WalkingPair.left }) : Type u) → (↑s.pt : Type u)) a

A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair ⊢ (A.coproductCocone B).ι.app { as := WalkingPair.left } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := WalkingPair.left }

ext a

right

(Hom.hom ((A.coproductCocone B).ι.app { as := WalkingPair.right } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom) : (↑((pair A B).obj { as := WalkingPair.right }) : Type u) → (↑s.pt : Type u)) a = (Hom.hom (s.ι.app { as := WalkingPair.right }) : (↑((pair A B).obj { as := WalkingPair.right }) : Type u) → (↑s.pt : Type u)) a

A B : CommRingCat s : BinaryCofan A B x✝ : Discrete WalkingPair ⊢ (A.coproductCocone B).ι.app { as := WalkingPair.right } ≫ ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom = s.ι.app { as := WalkingPair.right }

apply CommRingCat.hom_ext

_private

{ hom' := m }.hom = Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)

A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ { hom' := m } = ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom

apply RingHom.toIntAlgHom_injective

_private

{ hom' := m }.hom.toIntAlgHom = (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom

A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ { hom' := m }.hom = Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)

apply Algebra.TensorProduct.liftEquiv.symm.injective

_private

(Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) { hom' := m }.hom.toIntAlgHom = (Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom

A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ { hom' := m }.hom.toIntAlgHom = (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom

apply Subtype.ext

_private

(↑((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) { hom' := m }.hom.toIntAlgHom) : ((↑A : Type u) →ₐ[ℤ] (↑s.pt : Type u)) × ((↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u))) = (↑((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom) : ((↑A : Type u) →ₐ[ℤ] (↑s.pt : Type u)) × ((↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)))

A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ (Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) { hom' := m }.hom.toIntAlgHom = (Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom

rw [Algebra.TensorProduct.liftEquiv_symm_apply_coe, Prod.mk.injEq]

_private

{ hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.1 ∧ (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.2

A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ (↑((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) { hom' := m }.hom.toIntAlgHom) : ((↑A : Type u) →ₐ[ℤ] (↑s.pt : Type u)) × ((↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u))) = (↑((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom) : ((↑A : Type u) →ₐ[ℤ] (↑s.pt : Type u)) × ((↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)))

Prod.mk.injEq

_private

{ hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.1 ∧ (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.2

A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ ({ hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft, (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight) = (↑((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom) : ((↑A : Type u) →ₐ[ℤ] (↑s.pt : Type u)) × ((↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)))

constructor

_private

{ hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.1

A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ { hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.1 ∧ (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.2

constructor

_private

(AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.2

A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j _private : { hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.1 ⊢ { hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.1 ∧ (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.2

ext a

_private

({ hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft : (↑A : Type u) → (↑s.pt : Type u)) a = (((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.1 : (↑A : Type u) → (↑s.pt : Type u)) a

A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ { hom' := m }.hom.toIntAlgHom.comp Algebra.TensorProduct.includeLeft = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.1

ext b

_private

((AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight : (↑B : Type u) → (↑s.pt : Type u)) b = (((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom sorry).toRingHom)).toIntAlgHom).1.2 : (↑B : Type u) → (↑s.pt : Type u)) b

A B : CommRingCat s : BinaryCofan A B m : (↑A : Type u) ⊗[ℤ] (↑B : Type u) →+* (↑s.pt : Type u) hm : ∀ (j : Discrete WalkingPair), (A.coproductCocone B).ι.app j ≫ { hom' := m } = s.ι.app j ⊢ (AlgHom.restrictScalars ℤ { hom' := m }.hom.toIntAlgHom).comp Algebra.TensorProduct.includeRight = ((Algebra.TensorProduct.liftEquiv.symm : ((↑A : Type u) ⊗[ℤ] (↑B : Type u) →ₐ[ℤ] (↑s.pt : Type u)) → { fg // ∀ (x : (↑A : Type u)) (y : (↑B : Type u)), Commute ((fg.1 : (↑A : Type u) → (↑s.pt : Type u)) x) ((fg.2 : (↑B : Type u) → (↑s.pt : Type u)) y) }) (Hom.hom (ofHom (Algebra.TensorProduct.lift (Hom.hom s.inl).toIntAlgHom (Hom.hom s.inr).toIntAlgHom ⋯).toRingHom)).toIntAlgHom).1.2

apply hasStrictTerminalObjects_of_terminal_is_strict (CommRingCat.of PUnit)

apply

∀ (A : CommRingCat) (f : of PUnit.{u + 1} ⟶ A), IsIso f

⊢ HasStrictTerminalObjects CommRingCat

refine ⟨ofHom ⟨1, rfl, by simp⟩, ?_, ?_⟩

refine_1

f ≫ ofHom { toMonoidHom := 1, map_zero' := sorry, map_add' := sorry } = 𝟙 (of PUnit.{u + 1})

X : CommRingCat f : of PUnit.{u + 1} ⟶ X ⊢ IsIso f

refine ⟨ofHom ⟨1, rfl, by simp⟩, ?_, ?_⟩

refine_2

ofHom { toMonoidHom := 1, map_zero' := sorry, map_add' := sorry } ≫ f = 𝟙 X

X : CommRingCat f : of PUnit.{u + 1} ⟶ X refine_1 : f ≫ ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } = 𝟙 (of PUnit.{u + 1}) ⊢ IsIso f

ext x

refine_2

(Hom.hom (ofHom { toMonoidHom := 1, map_zero' := sorry, map_add' := sorry } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x

X : CommRingCat f : of PUnit.{u + 1} ⟶ X ⊢ ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f = 𝟙 X

have e : (0 : X) = 1 := by rw [← f.hom.map_one, ← f.hom.map_zero]

refine_2

0 = 1

X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x

← f.hom.map_one,

this

0 = (Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 1

X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) ⊢ 0 = 1

← f.hom.map_zero

this

(Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 0 = (Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 1

X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) ⊢ 0 = (Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 1

replace e : 0 * x = 1 * x := congr_arg (· * x) e

refine_2

0 * x = 1 * x

X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) e : 0 = 1 ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x

rw [one_mul, zero_mul, ← f.hom.map_zero] at e

refine_2

(Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 0 = x

X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) e : 0 * x = 1 * x ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x

one_mul,

refine_2

0 * x = x

X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) e : 0 * x = 1 * x ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x

zero_mul,

refine_2

0 = x

X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) e : 0 * x = x ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x

← f.hom.map_zero

refine_2

(Hom.hom f : (↑(of PUnit.{u + 1}) : Type u) → (↑X : Type u)) 0 = x

X : CommRingCat f : of PUnit.{u + 1} ⟶ X x : (↑X : Type u) e : 0 = x ⊢ (Hom.hom (ofHom { toMonoidHom := 1, map_zero' := ⋯, map_add' := ⋯ } ≫ f) : (↑X : Type u) → (↑X : Type u)) x = (Hom.hom (𝟙 X) : (↑X : Type u) → (↑X : Type u)) x

ext : 1

hf

Hom.hom x✝ = Hom.hom default

R : CommRingCat x✝ : of (ULift.{u, 0} ℤ) ⟶ R ⊢ x✝ = default

rw [← RingHom.cancel_right (f := (ULift.ringEquiv.{0, u} (R := ℤ)).symm.toRingHom) (hf := ULift.ringEquiv.symm.surjective)]

hf

(Hom.hom x✝).comp ULift.ringEquiv.symm.toRingHom = (Hom.hom default).comp ULift.ringEquiv.symm.toRingHom

R : CommRingCat x✝ : of (ULift.{u, 0} ℤ) ⟶ R ⊢ Hom.hom x✝ = Hom.hom default

← RingHom.cancel_right (f := (ULift.ringEquiv.{0, u} (R := ℤ)).symm.toRingHom) (hf := ULift.ringEquiv.symm.surjective)

hf

(Hom.hom x✝).comp ULift.ringEquiv.symm.toRingHom = (Hom.hom default).comp ULift.ringEquiv.symm.toRingHom

R : CommRingCat x✝ : of (ULift.{u, 0} ℤ) ⟶ R ⊢ Hom.hom x✝ = Hom.hom default

ext

hf

(Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝ = (Hom.hom (c.π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝

A B : CommRingCat c : Cone (pair A B) j : Discrete WalkingPair ⊢ ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j = c.π.app j

rcases j with ⟨⟨⟩⟩ <;> simp only [pair_obj_left, prodFan_pt, BinaryFan.π_app_left, BinaryFan.π_app_right, FunctorToTypes.map_comp_apply, forget_map, coe_of, RingHom.prod_apply]

hf

(Hom.hom (ofHom ((Hom.hom (BinaryFan.fst c)).prod (Hom.hom (BinaryFan.snd c))) ≫ (A.prodFan B).fst) : (↑c.pt : Type u) → (↑A : Type u)) x✝ = (Hom.hom (BinaryFan.fst c) : (↑c.pt : Type u) → (↑A : Type u)) x✝

A B : CommRingCat c : Cone (pair A B) j : Discrete WalkingPair x✝ : (↑c.pt : Type u) ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝ = (Hom.hom (c.π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝

rcases j with ⟨⟨⟩⟩ <;> simp only [pair_obj_left, prodFan_pt, BinaryFan.π_app_left, BinaryFan.π_app_right, FunctorToTypes.map_comp_apply, forget_map, coe_of, RingHom.prod_apply]

hf

(Hom.hom (ofHom ((Hom.hom (BinaryFan.fst c)).prod (Hom.hom (BinaryFan.snd c))) ≫ (A.prodFan B).snd) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝ = (Hom.hom (BinaryFan.snd c) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝

A B : CommRingCat c : Cone (pair A B) j : Discrete WalkingPair x✝ : (↑c.pt : Type u) hf : (Hom.hom (ofHom ((Hom.hom (BinaryFan.fst c)).prod (Hom.hom (BinaryFan.snd c))) ≫ (A.prodFan B).fst) : (↑c.pt : Type u) → (↑A : Type u)) x✝ = (Hom.hom (BinaryFan.fst c) : (↑c.pt : Type u) → (↑A : Type u)) x✝ ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝ = (Hom.hom (c.π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝

rcases j with ⟨⟨⟩⟩

hf

(Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝ = (Hom.hom (c.π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝

A B : CommRingCat c : Cone (pair A B) j : Discrete WalkingPair x✝ : (↑c.pt : Type u) ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝ = (Hom.hom (c.π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝

rcases j with ⟨⟨⟩⟩

hf

(Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app { as := WalkingPair.right }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝ = (Hom.hom (c.π.app { as := WalkingPair.right }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝

A B : CommRingCat c : Cone (pair A B) j : Discrete WalkingPair x✝ : (↑c.pt : Type u) hf : (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝ = (Hom.hom (c.π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝ ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝ = (Hom.hom (c.π.app j) : (↑c.pt : Type u) → (↑((pair A B).obj j) : Type u)) x✝

simp only [pair_obj_left, prodFan_pt, BinaryFan.π_app_left, BinaryFan.π_app_right, FunctorToTypes.map_comp_apply, forget_map, coe_of, RingHom.prod_apply]

hf

(Hom.hom (ofHom ((Hom.hom (BinaryFan.fst c)).prod (Hom.hom (BinaryFan.snd c))) ≫ (A.prodFan B).fst) : (↑c.pt : Type u) → (↑A : Type u)) x✝ = (Hom.hom (BinaryFan.fst c) : (↑c.pt : Type u) → (↑A : Type u)) x✝

A B : CommRingCat c : Cone (pair A B) x✝ : (↑c.pt : Type u) ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝ = (Hom.hom (c.π.app { as := WalkingPair.left }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.left }) : Type u)) x✝

simp only [pair_obj_left, prodFan_pt, BinaryFan.π_app_left, BinaryFan.π_app_right, FunctorToTypes.map_comp_apply, forget_map, coe_of, RingHom.prod_apply]

hf

(Hom.hom (ofHom ((Hom.hom (BinaryFan.fst c)).prod (Hom.hom (BinaryFan.snd c))) ≫ (A.prodFan B).snd) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝ = (Hom.hom (BinaryFan.snd c) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝

A B : CommRingCat c : Cone (pair A B) x✝ : (↑c.pt : Type u) ⊢ (Hom.hom (ofHom ((Hom.hom (c.π.app { as := WalkingPair.left })).prod (Hom.hom (c.π.app { as := WalkingPair.right }))) ≫ (A.prodFan B).π.app { as := WalkingPair.right }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝ = (Hom.hom (c.π.app { as := WalkingPair.right }) : (↑c.pt : Type u) → (↑((pair A B).obj { as := WalkingPair.right }) : Type u)) x✝

ext x

hf

(Hom.hom m : (↑s.pt : Type u) → (↑(A.prodFan B).pt : Type u)) x = (Hom.hom (ofHom ((Hom.hom (s.π.app { as := WalkingPair.left })).prod (Hom.hom (s.π.app { as := WalkingPair.right })))) : (↑s.pt : Type u) → (↑(A.prodFan B).pt : Type u)) x

A B : CommRingCat s : Cone (pair A B) m : s.pt ⟶ (A.prodFan B).pt h : ∀ (j : Discrete WalkingPair), m ≫ (A.prodFan B).π.app j = s.π.app j ⊢ m = ofHom ((Hom.hom (s.π.app { as := WalkingPair.left })).prod (Hom.hom (s.π.app { as := WalkingPair.right })))