[GOAL]
x y : ℝ
⊢ MonotoneOn (fun x => log x * x) {x | 1 ≤ x}
[PROOFSTEP]
simp only [MonotoneOn, mem_setOf_eq]
[GOAL]
x y : ℝ
⊢ ∀ ⦃a : ℝ⦄, 1 ≤ a → ∀ ⦃b : ℝ⦄, 1 ≤ b → a ≤ b → log a * a ≤ log b * b
[PROOFSTEP]
intro x hex y hey hxy
[GOAL]
x✝ y✝ x : ℝ
hex : 1 ≤ x
y : ℝ
hey : 1 ≤ y
hxy : x ≤ y
⊢ log x * x ≤ log y * y
[PROOFSTEP]
have x_pos : 0 < x := lt_of_lt_of_le zero_lt_one hex
[GOAL]
x✝ y✝ x : ℝ
hex : 1 ≤ x
y : ℝ
hey : 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
⊢ log x * x ≤ log y * y
[PROOFSTEP]
have y_pos : 0 < y := lt_of_lt_of_le zero_lt_one hey
[GOAL]
x✝ y✝ x : ℝ
hex : 1 ≤ x
y : ℝ
hey : 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
⊢ log x * x ≤ log y * y
[PROOFSTEP]
refine' mul_le_mul ((log_le_log x_pos y_pos).mpr hxy) hxy (le_of_lt x_pos) _
[GOAL]
x✝ y✝ x : ℝ
hex : 1 ≤ x
y : ℝ
hey : 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
⊢ 0 ≤ log y
[PROOFSTEP]
rwa [le_log_iff_exp_le y_pos, Real.exp_zero]
[GOAL]
x y : ℝ
⊢ AntitoneOn (fun x => log x / x) {x | exp 1 ≤ x}
[PROOFSTEP]
simp only [AntitoneOn, mem_setOf_eq]
[GOAL]
x y : ℝ
⊢ ∀ ⦃a : ℝ⦄, exp 1 ≤ a → ∀ ⦃b : ℝ⦄, exp 1 ≤ b → a ≤ b → log b / b ≤ log a / a
[PROOFSTEP]
intro x hex y hey hxy
[GOAL]
x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
⊢ log y / y ≤ log x / x
[PROOFSTEP]
have x_pos : 0 < x := (exp_pos 1).trans_le hex
[GOAL]
x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
⊢ log y / y ≤ log x / x
[PROOFSTEP]
have y_pos : 0 < y := (exp_pos 1).trans_le hey
[GOAL]
x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
⊢ log y / y ≤ log x / x
[PROOFSTEP]
have hlogx : 1 ≤ log x := by rwa [le_log_iff_exp_le x_pos]
[GOAL]
x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
⊢ 1 ≤ log x
[PROOFSTEP]
rwa [le_log_iff_exp_le x_pos]
[GOAL]
x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
⊢ log y / y ≤ log x / x
[PROOFSTEP]
have hyx : 0 ≤ y / x - 1 := by rwa [le_sub_iff_add_le, le_div_iff x_pos, zero_add, one_mul]
[GOAL]
x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
⊢ 0 ≤ y / x - 1
[PROOFSTEP]
rwa [le_sub_iff_add_le, le_div_iff x_pos, zero_add, one_mul]
[GOAL]
x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y / y ≤ log x / x
[PROOFSTEP]
rw [div_le_iff y_pos, ← sub_le_sub_iff_right (log x)]
[GOAL]
x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y - log x ≤ log x / x * y - log x
[PROOFSTEP]
calc
  log y - log x = log (y / x) := by rw [log_div y_pos.ne' x_pos.ne']
  _ ≤ y / x - 1 := (log_le_sub_one_of_pos (div_pos y_pos x_pos))
  _ ≤ log x * (y / x - 1) := (le_mul_of_one_le_left hyx hlogx)
  _ = log x / x * y - log x := by ring
[GOAL]
x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y - log x = log (y / x)
[PROOFSTEP]
rw [log_div y_pos.ne' x_pos.ne']
[GOAL]
x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log x * (y / x - 1) = log x / x * y - log x
[PROOFSTEP]
ring
[GOAL]
x y a : ℝ
ha : 0 < a
⊢ AntitoneOn (fun x => log x / x ^ a) {x | exp (1 / a) ≤ x}
[PROOFSTEP]
simp only [AntitoneOn, mem_setOf_eq]
[GOAL]
x y a : ℝ
ha : 0 < a
⊢ ∀ ⦃a_1 : ℝ⦄, exp (1 / a) ≤ a_1 → ∀ ⦃b : ℝ⦄, exp (1 / a) ≤ b → a_1 ≤ b → log b / b ^ a ≤ log a_1 / a_1 ^ a
[PROOFSTEP]
intro x hex y _ hxy
[GOAL]
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
⊢ log y / y ^ a ≤ log x / x ^ a
[PROOFSTEP]
have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
[GOAL]
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
⊢ log y / y ^ a ≤ log x / x ^ a
[PROOFSTEP]
have y_pos : 0 < y := by linarith
[GOAL]
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
⊢ 0 < y
[PROOFSTEP]
linarith
[GOAL]
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
⊢ log y / y ^ a ≤ log x / x ^ a
[PROOFSTEP]
have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
[GOAL]
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
⊢ log y / y ^ a ≤ log x / x ^ a
[PROOFSTEP]
have y_nonneg : 0 ≤ y := by linarith
[GOAL]
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
⊢ 0 ≤ y
[PROOFSTEP]
linarith
[GOAL]
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ log y / y ^ a ≤ log x / x ^ a
[PROOFSTEP]
nth_rw 1 [← rpow_one y]
[GOAL]
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ log (y ^ 1) / y ^ a ≤ log x / x ^ a
[PROOFSTEP]
nth_rw 1 [← rpow_one x]
[GOAL]
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ log (y ^ 1) / y ^ a ≤ log (x ^ 1) / x ^ a
[PROOFSTEP]
rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
  log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc, mul_div_assoc,
  mul_le_mul_left (one_div_pos.mpr ha)]
[GOAL]
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ log (y ^ a) / y ^ a ≤ log (x ^ a) / x ^ a
[PROOFSTEP]
refine' log_div_self_antitoneOn _ _ _
[GOAL]
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ x ^ a ∈ {x | exp 1 ≤ x}
[PROOFSTEP]
simp only [Set.mem_setOf_eq]
[GOAL]
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ exp 1 ≤ x ^ a
[PROOFSTEP]
convert rpow_le_rpow _ hex (le_of_lt ha) using 1
[GOAL]
case h.e'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ exp 1 = exp (1 / a) ^ a
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ exp (1 / a)
[PROOFSTEP]
rw [← exp_mul]
[GOAL]
case h.e'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ exp 1 = exp (1 / a * a)
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ exp (1 / a)
[PROOFSTEP]
simp only [Real.exp_eq_exp]
[GOAL]
case h.e'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 1 = 1 / a * a
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ exp (1 / a)
[PROOFSTEP]
field_simp [(ne_of_lt ha).symm]
[GOAL]
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ exp (1 / a)
[PROOFSTEP]
exact le_of_lt (exp_pos (1 / a))
[GOAL]
case refine'_2
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ y ^ a ∈ {x | exp 1 ≤ x}
[PROOFSTEP]
simp only [Set.mem_setOf_eq]
[GOAL]
case refine'_2
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ exp 1 ≤ y ^ a
[PROOFSTEP]
convert rpow_le_rpow _ (_root_.trans hex hxy) (le_of_lt ha) using 1
[GOAL]
case h.e'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ exp 1 = exp (1 / a) ^ a
case refine'_2
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ exp (1 / a)
[PROOFSTEP]
rw [← exp_mul]
[GOAL]
case h.e'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ exp 1 = exp (1 / a * a)
case refine'_2
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ exp (1 / a)
[PROOFSTEP]
simp only [Real.exp_eq_exp]
[GOAL]
case h.e'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 1 = 1 / a * a
case refine'_2
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ exp (1 / a)
[PROOFSTEP]
field_simp [(ne_of_lt ha).symm]
[GOAL]
case refine'_2
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ exp (1 / a)
[PROOFSTEP]
exact le_of_lt (exp_pos (1 / a))
[GOAL]
case refine'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : exp (1 / a) ≤ x
y : ℝ
x✝ : exp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ x ^ a ≤ y ^ a
[PROOFSTEP]
exact rpow_le_rpow x_nonneg hxy (le_of_lt ha)
[GOAL]
x y : ℝ
⊢ AntitoneOn (fun x => log x / sqrt x) {x | exp 2 ≤ x}
[PROOFSTEP]
simp_rw [sqrt_eq_rpow]
[GOAL]
x y : ℝ
⊢ AntitoneOn (fun x => log x / x ^ (1 / 2)) {x | exp 2 ≤ x}
[PROOFSTEP]
convert @log_div_self_rpow_antitoneOn (1 / 2) (by norm_num)
[GOAL]
x y : ℝ
⊢ 0 < 1 / 2
[PROOFSTEP]
norm_num
[GOAL]
case h.e'_6.h.e'_2.h.h.e'_3.h.e'_1
x y x✝ : ℝ
⊢ 2 = 1 / (1 / 2)
[PROOFSTEP]
norm_num


[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ T R (n + 2) = 2 * X * T R (n + 1) - T R n
[PROOFSTEP]
rw [T]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ T R 2 = 2 * X ^ 2 - 1
[PROOFSTEP]
simp only [T, sub_left_inj, sq, mul_assoc]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
h : 2 ≤ n
⊢ T R n = 2 * X * T R (n - 1) - T R (n - 2)
[PROOFSTEP]
obtain ⟨n, rfl⟩ := Nat.exists_eq_add_of_le h
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
h : 2 ≤ 2 + n
⊢ T R (2 + n) = 2 * X * T R (2 + n - 1) - T R (2 + n - 2)
[PROOFSTEP]
rw [add_comm]
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
h : 2 ≤ 2 + n
⊢ T R (n + 2) = 2 * X * T R (n + 2 - 1) - T R (n + 2 - 2)
[PROOFSTEP]
exact T_add_two R n
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ U R (n + 2) = 2 * X * U R (n + 1) - U R n
[PROOFSTEP]
rw [U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ U R 2 = 4 * X ^ 2 - 1
[PROOFSTEP]
simp only [U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ 2 * X * (2 * X) - 1 = 4 * X ^ 2 - 1
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
h : 2 ≤ n
⊢ U R n = 2 * X * U R (n - 1) - U R (n - 2)
[PROOFSTEP]
obtain ⟨n, rfl⟩ := Nat.exists_eq_add_of_le h
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
h : 2 ≤ 2 + n
⊢ U R (2 + n) = 2 * X * U R (2 + n - 1) - U R (2 + n - 2)
[PROOFSTEP]
rw [add_comm]
[GOAL]
case intro
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
h : 2 ≤ 2 + n
⊢ U R (n + 2) = 2 * X * U R (n + 2 - 1) - U R (n + 2 - 2)
[PROOFSTEP]
exact U_add_two R n
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ U R (0 + 1) = X * U R 0 + T R (0 + 1)
[PROOFSTEP]
simp only [T, U, two_mul, mul_one]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ U R (1 + 1) = X * U R 1 + T R (1 + 1)
[PROOFSTEP]
simp only [T, U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ 2 * X * (2 * X) - 1 = X * (2 * X) + (2 * X * X - 1)
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ U R (n + 2 + 1) = 2 * X * (X * U R (n + 1) + T R (n + 2)) - (X * U R n + T R (n + 1))
[PROOFSTEP]
rw [U_add_two, U_eq_X_mul_U_add_T n, U_eq_X_mul_U_add_T (n + 1), U_eq_X_mul_U_add_T n]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ 2 * X * (X * U R (n + 1) + T R (n + 2)) - (X * U R n + T R (n + 1)) =
    X * (2 * X * U R (n + 1) - U R n) + (2 * X * T R (n + 2) - T R (n + 1))
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ X * (2 * X * U R (n + 1) - U R n) + (2 * X * T R (n + 2) - T R (n + 1)) = X * U R (n + 2) + T R (n + 2 + 1)
[PROOFSTEP]
simp only [U_add_two, T_add_two]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ T R (n + 1) = U R (n + 1) - X * U R n
[PROOFSTEP]
rw [U_eq_X_mul_U_add_T, add_comm (X * U R n), add_sub_cancel]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ T R (0 + 2) = X * T R (0 + 1) - (1 - X ^ 2) * U R 0
[PROOFSTEP]
simp only [T, U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ 2 * X * X - 1 = X * X - (1 - X ^ 2) * 1
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ T R (1 + 2) = X * T R (1 + 1) - (1 - X ^ 2) * U R 1
[PROOFSTEP]
simp only [T, U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ 2 * X * (2 * X * X - 1) - X = X * (2 * X * X - 1) - (1 - X ^ 2) * (2 * X)
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ 2 * X * T R (n + 2 + 1) - T R (n + 2) =
    2 * X * (X * T R (n + 2) - (1 - X ^ 2) * U R (n + 1)) - (X * T R (n + 1) - (1 - X ^ 2) * U R n)
[PROOFSTEP]
simp only [T_eq_X_mul_T_sub_pol_U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ 2 * X * (X * T R (n + 2) - (1 - X ^ 2) * U R (n + 1)) - (X * T R (n + 1) - (1 - X ^ 2) * U R n) =
    X * (2 * X * T R (n + 2) - T R (n + 1)) - (1 - X ^ 2) * (2 * X * U R (n + 1) - U R n)
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ X * (2 * X * T R (n + 2) - T R (n + 1)) - (1 - X ^ 2) * (2 * X * U R (n + 1) - U R n) =
    X * T R (n + 2 + 1) - (1 - X ^ 2) * U R (n + 2)
[PROOFSTEP]
rw [T_add_two _ (n + 1), U_add_two]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (1 - X ^ 2) * U R n = X * T R (n + 1) - T R (n + 2)
[PROOFSTEP]
rw [T_eq_X_mul_T_sub_pol_U, ← sub_add, sub_self, zero_add]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
⊢ map f (T R 0) = T S 0
[PROOFSTEP]
simp only [T_zero, Polynomial.map_one]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
⊢ map f (T R 1) = T S 1
[PROOFSTEP]
simp only [T_one, map_X]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
n : ℕ
⊢ map f (T R (n + 2)) = T S (n + 2)
[PROOFSTEP]
simp only [T_add_two, Polynomial.map_mul, Polynomial.map_sub, map_X, Polynomial.map_add, Polynomial.map_one,
  Polynomial.map_ofNat, map_T f (n + 1), map_T f n]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
⊢ map f (U R 0) = U S 0
[PROOFSTEP]
simp only [U_zero, Polynomial.map_one]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
⊢ map f (U R 1) = U S 1
[PROOFSTEP]
simp [U_one, map_X, Polynomial.map_mul, Polynomial.map_add, Polynomial.map_one]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
n : ℕ
⊢ map f (U R (n + 2)) = U S (n + 2)
[PROOFSTEP]
simp only [U_add_two, Polynomial.map_mul, Polynomial.map_sub, map_X, Polynomial.map_add, Polynomial.map_one,
  map_U f (n + 1), map_U f n]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
n : ℕ
⊢ map f 2 * X * U S (n + 1) - U S n = 2 * X * U S (n + 1) - U S n
[PROOFSTEP]
norm_num
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ ↑derivative (T R (0 + 1)) = (↑0 + 1) * U R 0
[PROOFSTEP]
simp only [T_one, U_zero, derivative_X, Nat.cast_zero, zero_add, mul_one]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ ↑derivative (T R (1 + 1)) = (↑1 + 1) * U R 1
[PROOFSTEP]
simp [T_two, U_one, derivative_sub, derivative_one, derivative_mul, derivative_X_pow, add_mul]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ ↑derivative (T R (n + 2 + 1)) = 2 * T R (n + 2) + 2 * X * ↑derivative (T R (n + 1 + 1)) - ↑derivative (T R (n + 1))
[PROOFSTEP]
rw [T_add_two _ (n + 1), derivative_sub, derivative_mul, derivative_mul, derivative_X, derivative_ofNat]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (0 * X + 2 * 1) * T R (n + 1 + 1) + 2 * X * ↑derivative (T R (n + 1 + 1)) - ↑derivative (T R (n + 1)) =
    2 * T R (n + 2) + 2 * X * ↑derivative (T R (n + 1 + 1)) - ↑derivative (T R (n + 1))
[PROOFSTEP]
ring_nf
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ 2 * T R (n + 2) + 2 * X * ↑derivative (T R (n + 1 + 1)) - ↑derivative (T R (n + 1)) =
    2 * (U R (n + 1 + 1) - X * U R (n + 1)) + 2 * X * ((↑n + 1 + 1) * U R (n + 1)) - (↑n + 1) * U R n
[PROOFSTEP]
rw_mod_cast [T_derivative_eq_U (n + 1), T_derivative_eq_U n, T_eq_U_sub_X_mul_U _ (n + 1)]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ 2 * (U R (n + 1 + 1) - X * U R (n + 1)) + 2 * X * ((↑n + 1 + 1) * U R (n + 1)) - (↑n + 1) * U R n =
    (↑n + 1) * (2 * X * U R (n + 1) - U R n) + 2 * U R (n + 2)
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (↑n + 1) * (2 * X * U R (n + 1) - U R n) + 2 * U R (n + 2) = (↑n + 1) * U R (n + 2) + 2 * U R (n + 2)
[PROOFSTEP]
rw [U_add_two]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (↑n + 1) * U R (n + 2) + 2 * U R (n + 2) = (↑n + 2 + 1) * U R (n + 2)
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (↑n + 2 + 1) * U R (n + 2) = (↑(n + 2) + 1) * U R (n + 2)
[PROOFSTEP]
norm_cast
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (1 - X ^ 2) * ↑derivative (T R (n + 1)) = (1 - X ^ 2) * ((↑n + 1) * U R n)
[PROOFSTEP]
rw [T_derivative_eq_U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (1 - X ^ 2) * ((↑n + 1) * U R n) = (↑n + 1) * ((1 - X ^ 2) * U R n)
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (↑n + 1) * ((1 - X ^ 2) * U R n) = (↑n + 1) * (X * T R (n + 1) - (2 * X * T R (n + 1) - T R n))
[PROOFSTEP]
rw [one_sub_X_sq_mul_U_eq_pol_in_T, T_add_two]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (↑n + 1) * (X * T R (n + 1) - (2 * X * T R (n + 1) - T R n)) = (↑n + 1) * (T R n - X * T R (n + 1))
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (↑n + 1) * T R (n + 1) = X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
[PROOFSTEP]
have h :
  derivative (T R (n + 2)) =
    U R (n + 1) - X * U R n + X * derivative (T R (n + 1)) + 2 * X * U R n - (1 - X ^ 2) * derivative (U R n) :=
  by
  conv_lhs => rw [T_eq_X_mul_T_sub_pol_U]
  simp only [derivative_sub, derivative_mul, derivative_X, derivative_one, derivative_X_pow, one_mul, T_derivative_eq_U]
  rw [T_eq_U_sub_X_mul_U, C_eq_nat_cast]
  ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ ↑derivative (T R (n + 2)) =
    U R (n + 1) - X * U R n + X * ↑derivative (T R (n + 1)) + 2 * X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
[PROOFSTEP]
conv_lhs => rw [T_eq_X_mul_T_sub_pol_U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
| ↑derivative (T R (n + 2))
[PROOFSTEP]
rw [T_eq_X_mul_T_sub_pol_U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
| ↑derivative (T R (n + 2))
[PROOFSTEP]
rw [T_eq_X_mul_T_sub_pol_U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
| ↑derivative (T R (n + 2))
[PROOFSTEP]
rw [T_eq_X_mul_T_sub_pol_U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ ↑derivative (X * T R (n + 1) - (1 - X ^ 2) * U R n) =
    U R (n + 1) - X * U R n + X * ↑derivative (T R (n + 1)) + 2 * X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
[PROOFSTEP]
simp only [derivative_sub, derivative_mul, derivative_X, derivative_one, derivative_X_pow, one_mul, T_derivative_eq_U]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ T R (n + 1) + X * ((↑n + 1) * U R n) - ((0 - ↑C ↑2 * X ^ (2 - 1)) * U R n + (1 - X ^ 2) * ↑derivative (U R n)) =
    U R (n + 1) - X * U R n + X * ((↑n + 1) * U R n) + 2 * X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
[PROOFSTEP]
rw [T_eq_U_sub_X_mul_U, C_eq_nat_cast]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ U R (n + 1) - X * U R n + X * ((↑n + 1) * U R n) -
      ((0 - ↑2 * X ^ (2 - 1)) * U R n + (1 - X ^ 2) * ↑derivative (U R n)) =
    U R (n + 1) - X * U R n + X * ((↑n + 1) * U R n) + 2 * X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
h :
  ↑derivative (T R (n + 2)) =
    U R (n + 1) - X * U R n + X * ↑derivative (T R (n + 1)) + 2 * X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
⊢ (↑n + 1) * T R (n + 1) = X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
[PROOFSTEP]
calc
  ((n : R[X]) + 1) * T R (n + 1) =
      ((n : R[X]) + 1 + 1) * (X * U R n + T R (n + 1)) - X * ((n + 1 : R[X]) * U R n) - (X * U R n + T R (n + 1)) :=
    by ring
  _ = derivative (T R (n + 2)) - X * derivative (T R (n + 1)) - U R (n + 1) := by
    rw [← U_eq_X_mul_U_add_T, ← T_derivative_eq_U, ← Nat.cast_one, ← Nat.cast_add, Nat.cast_one, ←
      T_derivative_eq_U (n + 1)]
  _ =
      U R (n + 1) - X * U R n + X * derivative (T R (n + 1)) + 2 * X * U R n - (1 - X ^ 2) * derivative (U R n) -
          X * derivative (T R (n + 1)) -
        U R (n + 1) :=
    by rw [h]
  _ = X * U R n - (1 - X ^ 2) * derivative (U R n) := by ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
h :
  ↑derivative (T R (n + 2)) =
    U R (n + 1) - X * U R n + X * ↑derivative (T R (n + 1)) + 2 * X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
⊢ (↑n + 1) * T R (n + 1) = (↑n + 1 + 1) * (X * U R n + T R (n + 1)) - X * ((↑n + 1) * U R n) - (X * U R n + T R (n + 1))
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
h :
  ↑derivative (T R (n + 2)) =
    U R (n + 1) - X * U R n + X * ↑derivative (T R (n + 1)) + 2 * X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
⊢ (↑n + 1 + 1) * (X * U R n + T R (n + 1)) - X * ((↑n + 1) * U R n) - (X * U R n + T R (n + 1)) =
    ↑derivative (T R (n + 2)) - X * ↑derivative (T R (n + 1)) - U R (n + 1)
[PROOFSTEP]
rw [← U_eq_X_mul_U_add_T, ← T_derivative_eq_U, ← Nat.cast_one, ← Nat.cast_add, Nat.cast_one, ←
  T_derivative_eq_U (n + 1)]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
h :
  ↑derivative (T R (n + 2)) =
    U R (n + 1) - X * U R n + X * ↑derivative (T R (n + 1)) + 2 * X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
⊢ ↑derivative (T R (n + 2)) - X * ↑derivative (T R (n + 1)) - U R (n + 1) =
    U R (n + 1) - X * U R n + X * ↑derivative (T R (n + 1)) + 2 * X * U R n - (1 - X ^ 2) * ↑derivative (U R n) -
        X * ↑derivative (T R (n + 1)) -
      U R (n + 1)
[PROOFSTEP]
rw [h]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
h :
  ↑derivative (T R (n + 2)) =
    U R (n + 1) - X * U R n + X * ↑derivative (T R (n + 1)) + 2 * X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
⊢ U R (n + 1) - X * U R n + X * ↑derivative (T R (n + 1)) + 2 * X * U R n - (1 - X ^ 2) * ↑derivative (U R n) -
        X * ↑derivative (T R (n + 1)) -
      U R (n + 1) =
    X * U R n - (1 - X ^ 2) * ↑derivative (U R n)
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ ∀ (k : ℕ), 2 * T R 0 * T R (0 + k) = T R (2 * 0 + k) + T R k
[PROOFSTEP]
simp [two_mul, add_mul]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ ∀ (k : ℕ), 2 * T R 1 * T R (1 + k) = T R (2 * 1 + k) + T R k
[PROOFSTEP]
simp [add_comm]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m : ℕ
⊢ ∀ (k : ℕ), 2 * T R (m + 2) * T R (m + 2 + k) = T R (2 * (m + 2) + k) + T R k
[PROOFSTEP]
intro k
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
⊢ 2 * T R (m + 2) * T R (m + 2 + k) = T R (2 * (m + 2) + k) + T R k
[PROOFSTEP]
suffices 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
  by
  have h_nat₁ : 2 * (m + 2) + k = 2 * m + k + 4 := by ring
  have h_nat₂ : m + 2 + k = m + k + 2 := by ring
  simpa [h_nat₁, h_nat₂] using this
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
this : 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
⊢ 2 * T R (m + 2) * T R (m + 2 + k) = T R (2 * (m + 2) + k) + T R k
[PROOFSTEP]
have h_nat₁ : 2 * (m + 2) + k = 2 * m + k + 4 := by ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
this : 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
⊢ 2 * (m + 2) + k = 2 * m + k + 4
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
this : 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
h_nat₁ : 2 * (m + 2) + k = 2 * m + k + 4
⊢ 2 * T R (m + 2) * T R (m + 2 + k) = T R (2 * (m + 2) + k) + T R k
[PROOFSTEP]
have h_nat₂ : m + 2 + k = m + k + 2 := by ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
this : 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
h_nat₁ : 2 * (m + 2) + k = 2 * m + k + 4
⊢ m + 2 + k = m + k + 2
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
this : 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
h_nat₁ : 2 * (m + 2) + k = 2 * m + k + 4
h_nat₂ : m + 2 + k = m + k + 2
⊢ 2 * T R (m + 2) * T R (m + 2 + k) = T R (2 * (m + 2) + k) + T R k
[PROOFSTEP]
simpa [h_nat₁, h_nat₂] using this
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
⊢ 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
[PROOFSTEP]
have H₁ : 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1) :=
  by
  have h_nat₁ : m + 1 + (k + 1) = m + k + 2 := by ring
  have h_nat₂ : 2 * (m + 1) + (k + 1) = 2 * m + k + 3 := by ring
  simpa [h_nat₁, h_nat₂] using
    mul_T (m + 1)
      (k + 1)
        -- clean up the `T` nat indices in the inductive hypothesis applied to `m` and `k + 2`
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
⊢ 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
[PROOFSTEP]
have h_nat₁ : m + 1 + (k + 1) = m + k + 2 := by ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
⊢ m + 1 + (k + 1) = m + k + 2
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
h_nat₁ : m + 1 + (k + 1) = m + k + 2
⊢ 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
[PROOFSTEP]
have h_nat₂ : 2 * (m + 1) + (k + 1) = 2 * m + k + 3 := by ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
h_nat₁ : m + 1 + (k + 1) = m + k + 2
⊢ 2 * (m + 1) + (k + 1) = 2 * m + k + 3
[PROOFSTEP]
ring
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
h_nat₁ : m + 1 + (k + 1) = m + k + 2
h_nat₂ : 2 * (m + 1) + (k + 1) = 2 * m + k + 3
⊢ 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
[PROOFSTEP]
simpa [h_nat₁, h_nat₂] using
  mul_T (m + 1)
    (k + 1)
      -- clean up the `T` nat indices in the inductive hypothesis applied to `m` and `k + 2`
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
H₁ : 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
⊢ 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
[PROOFSTEP]
have H₂ : 2 * T R m * T R (m + k + 2) = T R (2 * m + k + 2) + T R (k + 2) :=
  by
  have h_nat₁ : 2 * m + (k + 2) = 2 * m + k + 2 := by simp [add_assoc]
  have h_nat₂ : m + (k + 2) = m + k + 2 := by simp [add_assoc]
  simpa [h_nat₁, h_nat₂] using
    mul_T m
      (k + 2)
        -- state the `T` recurrence relation for a few useful indices
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
H₁ : 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
⊢ 2 * T R m * T R (m + k + 2) = T R (2 * m + k + 2) + T R (k + 2)
[PROOFSTEP]
have h_nat₁ : 2 * m + (k + 2) = 2 * m + k + 2 := by simp [add_assoc]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
H₁ : 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
⊢ 2 * m + (k + 2) = 2 * m + k + 2
[PROOFSTEP]
simp [add_assoc]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
H₁ : 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
h_nat₁ : 2 * m + (k + 2) = 2 * m + k + 2
⊢ 2 * T R m * T R (m + k + 2) = T R (2 * m + k + 2) + T R (k + 2)
[PROOFSTEP]
have h_nat₂ : m + (k + 2) = m + k + 2 := by simp [add_assoc]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
H₁ : 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
h_nat₁ : 2 * m + (k + 2) = 2 * m + k + 2
⊢ m + (k + 2) = m + k + 2
[PROOFSTEP]
simp [add_assoc]
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
H₁ : 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
h_nat₁ : 2 * m + (k + 2) = 2 * m + k + 2
h_nat₂ : m + (k + 2) = m + k + 2
⊢ 2 * T R m * T R (m + k + 2) = T R (2 * m + k + 2) + T R (k + 2)
[PROOFSTEP]
simpa [h_nat₁, h_nat₂] using
  mul_T m
    (k + 2)
      -- state the `T` recurrence relation for a few useful indices
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
H₁ : 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
H₂ : 2 * T R m * T R (m + k + 2) = T R (2 * m + k + 2) + T R (k + 2)
⊢ 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
[PROOFSTEP]
have h₁ := T_add_two R m
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
H₁ : 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
H₂ : 2 * T R m * T R (m + k + 2) = T R (2 * m + k + 2) + T R (k + 2)
h₁ : T R (m + 2) = 2 * X * T R (m + 1) - T R m
⊢ 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
[PROOFSTEP]
have h₂ : T R (2 * m + k + 4) = 2 * X * T R (2 * m + k + 3) - T R (2 * m + k + 2) := T_add_two R (2 * m + k + 2)
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
H₁ : 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
H₂ : 2 * T R m * T R (m + k + 2) = T R (2 * m + k + 2) + T R (k + 2)
h₁ : T R (m + 2) = 2 * X * T R (m + 1) - T R m
h₂ : T R (2 * m + k + 4) = 2 * X * T R (2 * m + k + 3) - T R (2 * m + k + 2)
⊢ 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
[PROOFSTEP]
have h₃ := T_add_two R k
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m k : ℕ
H₁ : 2 * T R (m + 1) * T R (m + k + 2) = T R (2 * m + k + 3) + T R (k + 1)
H₂ : 2 * T R m * T R (m + k + 2) = T R (2 * m + k + 2) + T R (k + 2)
h₁ : T R (m + 2) = 2 * X * T R (m + 1) - T R m
h₂ : T R (2 * m + k + 4) = 2 * X * T R (2 * m + k + 3) - T R (2 * m + k + 2)
h₃ : T R (k + 2) = 2 * X * T R (k + 1) - T R k
⊢ 2 * T R (m + 2) * T R (m + k + 2) = T R (2 * m + k + 4) + T R k
[PROOFSTEP]
linear_combination 2 * T R (m + k + 2) * h₁ + 2 * (X : R[X]) * H₁ - H₂ - h₂ - h₃
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ ∀ (n : ℕ), T R (0 * n) = comp (T R 0) (T R n)
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ ∀ (n : ℕ), T R (1 * n) = comp (T R 1) (T R n)
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m : ℕ
⊢ ∀ (n : ℕ), T R ((m + 2) * n) = comp (T R (m + 2)) (T R n)
[PROOFSTEP]
intro n
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m n : ℕ
⊢ T R ((m + 2) * n) = comp (T R (m + 2)) (T R n)
[PROOFSTEP]
have : 2 * T R n * T R ((m + 1) * n) = T R ((m + 2) * n) + T R (m * n) := by
  convert mul_T R n (m * n) using 1 <;> ring_nf
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m n : ℕ
⊢ 2 * T R n * T R ((m + 1) * n) = T R ((m + 2) * n) + T R (m * n)
[PROOFSTEP]
convert mul_T R n (m * n) using 1
[GOAL]
case h.e'_2
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m n : ℕ
⊢ 2 * T R n * T R ((m + 1) * n) = 2 * T R n * T R (n + m * n)
[PROOFSTEP]
ring_nf
[GOAL]
case h.e'_3
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m n : ℕ
⊢ T R ((m + 2) * n) + T R (m * n) = T R (2 * n + m * n) + T R (m * n)
[PROOFSTEP]
ring_nf
[GOAL]
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
m n : ℕ
this : 2 * T R n * T R ((m + 1) * n) = T R ((m + 2) * n) + T R (m * n)
⊢ T R ((m + 2) * n) = comp (T R (m + 2)) (T R n)
[PROOFSTEP]
simp [this, T_mul m, ← T_mul (m + 1)]


[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ ((evaluation C D).obj X).map (kernel.ι α) ≫ (Iso.refl (((evaluation C D).obj X).obj F)).hom =
    (PreservesKernel.iso ((evaluation C D).obj X) α).hom ≫ kernel.ι (NatTrans.app α X)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ NatTrans.app (kernel.ι α) X ≫ 𝟙 (F.obj X) =
    (PreservesKernel.iso ((evaluation C D).obj X) α).hom ≫ kernel.ι (NatTrans.app α X)
[PROOFSTEP]
simp only [Category.comp_id, PreservesKernel.iso_hom]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ NatTrans.app (kernel.ι α) X = kernelComparison α ((evaluation C D).obj X) ≫ kernel.ι (NatTrans.app α X)
[PROOFSTEP]
exact (kernelComparison_comp_ι _ ((evaluation C D).obj X)).symm
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ ((evaluation C D).obj X).map (cokernel.π α) ≫ (PreservesCokernel.iso ((evaluation C D).obj X) α).hom =
    (Iso.refl (((evaluation C D).obj X).obj G)).hom ≫ cokernel.π (NatTrans.app α X)
[PROOFSTEP]
apply (cancel_mono (PreservesCokernel.iso ((evaluation C D).obj X) α).inv).1
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ (((evaluation C D).obj X).map (cokernel.π α) ≫ (PreservesCokernel.iso ((evaluation C D).obj X) α).hom) ≫
      (PreservesCokernel.iso ((evaluation C D).obj X) α).inv =
    ((Iso.refl (((evaluation C D).obj X).obj G)).hom ≫ cokernel.π (NatTrans.app α X)) ≫
      (PreservesCokernel.iso ((evaluation C D).obj X) α).inv
[PROOFSTEP]
simp only [Category.assoc, Iso.hom_inv_id]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ ((evaluation C D).obj X).map (cokernel.π α) ≫ 𝟙 (((evaluation C D).obj X).obj (cokernel α)) =
    (Iso.refl (((evaluation C D).obj X).obj G)).hom ≫
      cokernel.π (NatTrans.app α X) ≫ (PreservesCokernel.iso ((evaluation C D).obj X) α).inv
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ NatTrans.app (cokernel.π α) X ≫ 𝟙 ((cokernel α).obj X) =
    𝟙 (G.obj X) ≫ cokernel.π (NatTrans.app α X) ≫ (PreservesCokernel.iso ((evaluation C D).obj X) α).inv
[PROOFSTEP]
simp only [PreservesCokernel.iso_inv, Category.id_comp, Category.comp_id]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ NatTrans.app (cokernel.π α) X = cokernel.π (NatTrans.app α X) ≫ cokernelComparison α ((evaluation C D).obj X)
[PROOFSTEP]
exact (π_comp_cokernelComparison _ ((evaluation C D).obj X)).symm
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ coimageImageComparison (NatTrans.app α X) =
    (coimageObjIso α X).inv ≫ NatTrans.app (coimageImageComparison α) X ≫ (imageObjIso α X).hom
[PROOFSTEP]
ext
[GOAL]
case h.h
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ (coequalizer.π (kernel.ι (NatTrans.app α X)) 0 ≫ coimageImageComparison (NatTrans.app α X)) ≫
      equalizer.ι (cokernel.π (NatTrans.app α X)) 0 =
    (coequalizer.π (kernel.ι (NatTrans.app α X)) 0 ≫
        (coimageObjIso α X).inv ≫ NatTrans.app (coimageImageComparison α) X ≫ (imageObjIso α X).hom) ≫
      equalizer.ι (cokernel.π (NatTrans.app α X)) 0
[PROOFSTEP]
dsimp
[GOAL]
case h.h
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ (cokernel.π (kernel.ι (NatTrans.app α X)) ≫ coimageImageComparison (NatTrans.app α X)) ≫
      kernel.ι (cokernel.π (NatTrans.app α X)) =
    (cokernel.π (kernel.ι (NatTrans.app α X)) ≫
        (coimageObjIso α X).inv ≫ NatTrans.app (coimageImageComparison α) X ≫ (imageObjIso α X).hom) ≫
      kernel.ι (cokernel.π (NatTrans.app α X))
[PROOFSTEP]
dsimp [imageObjIso, coimageObjIso, cokernel.map]
[GOAL]
case h.h
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ (cokernel.π (kernel.ι (NatTrans.app α X)) ≫ coimageImageComparison (NatTrans.app α X)) ≫
      kernel.ι (cokernel.π (NatTrans.app α X)) =
    (cokernel.π (kernel.ι (NatTrans.app α X)) ≫
        (cokernel.desc (kernel.ι (NatTrans.app α X)) (𝟙 (F.obj X) ≫ cokernel.π (NatTrans.app (kernel.ι α) X))
              (_ : kernel.ι (NatTrans.app α X) ≫ 𝟙 (F.obj X) ≫ cokernel.π (NatTrans.app (kernel.ι α) X) = 0) ≫
            (PreservesCokernel.iso ((evaluation C D).obj X) (kernel.ι α)).inv) ≫
          NatTrans.app (coimageImageComparison α) X ≫
            (PreservesKernel.iso ((evaluation C D).obj X) (cokernel.π α)).hom ≫
              kernel.map (NatTrans.app (cokernel.π α) X) (cokernel.π (NatTrans.app α X)) (𝟙 (G.obj X))
                (PreservesCokernel.iso ((evaluation C D).obj X) α).hom
                (_ :
                  ((evaluation C D).obj X).map (cokernel.π α) ≫ (PreservesCokernel.iso ((evaluation C D).obj X) α).hom =
                    (Iso.refl (((evaluation C D).obj X).obj G)).hom ≫ cokernel.π (NatTrans.app α X))) ≫
      kernel.ι (cokernel.π (NatTrans.app α X))
[PROOFSTEP]
simp only [coimage_image_factorisation, PreservesKernel.iso_hom, Category.assoc, kernel.lift_ι, Category.comp_id,
  PreservesCokernel.iso_inv, cokernel.π_desc_assoc, Category.id_comp]
[GOAL]
case h.h
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ NatTrans.app α X =
    cokernel.π (NatTrans.app (kernel.ι α) X) ≫
      cokernelComparison (kernel.ι α) ((evaluation C D).obj X) ≫
        NatTrans.app (coimageImageComparison α) X ≫
          kernelComparison (cokernel.π α) ((evaluation C D).obj X) ≫ kernel.ι (NatTrans.app (cokernel.π α) X)
[PROOFSTEP]
erw [kernelComparison_comp_ι _ ((evaluation C D).obj X), π_comp_cokernelComparison_assoc _ ((evaluation C D).obj X)]
[GOAL]
case h.h
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ NatTrans.app α X =
    ((evaluation C D).obj X).map (cokernel.π (kernel.ι α)) ≫
      NatTrans.app (coimageImageComparison α) X ≫ ((evaluation C D).obj X).map (kernel.ι (cokernel.π α))
[PROOFSTEP]
conv_lhs => rw [← coimage_image_factorisation α]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
| NatTrans.app α X
[PROOFSTEP]
rw [← coimage_image_factorisation α]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
| NatTrans.app α X
[PROOFSTEP]
rw [← coimage_image_factorisation α]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
| NatTrans.app α X
[PROOFSTEP]
rw [← coimage_image_factorisation α]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ NatTrans.app (coimageImageComparison α) X =
    (coimageObjIso α X).hom ≫ coimageImageComparison (NatTrans.app α X) ≫ (imageObjIso α X).inv
[PROOFSTEP]
simp only [coimageImageComparison_app, Iso.hom_inv_id_assoc, Iso.hom_inv_id, Category.assoc, Category.comp_id]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ IsIso (coimageImageComparison α)
[PROOFSTEP]
have : ∀ X : C, IsIso ((Abelian.coimageImageComparison α).app X) :=
  by
  intros
  rw [coimageImageComparison_app']
  infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
⊢ ∀ (X : C), IsIso (NatTrans.app (coimageImageComparison α) X)
[PROOFSTEP]
intros
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X X✝ : C
⊢ IsIso (NatTrans.app (coimageImageComparison α) X✝)
[PROOFSTEP]
rw [coimageImageComparison_app']
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X X✝ : C
⊢ IsIso ((coimageObjIso α X✝).hom ≫ coimageImageComparison (NatTrans.app α X✝) ≫ (imageObjIso α X✝).inv)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type w
inst✝¹ : Category.{z, w} D
inst✝ : Abelian D
F G : C ⥤ D
α : F ⟶ G
X : C
this : ∀ (X : C), IsIso (NatTrans.app (coimageImageComparison α) X)
⊢ IsIso (coimageImageComparison α)
[PROOFSTEP]
apply NatIso.isIso_of_isIso_app