Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Kerr–Newman solves the Einstein equation: Div1 (block 4 of 13)

Definition
NoHair_KerrNewmanEinstein_Div1

by SamenHossain · Oct 13, 2026 · Mathlib 0df444a (Lean v4.33.1)

einstein-maxwellgeneral-relativitykerr-newman

Div1. Differentiability and coordinate divergence of the closed-form Christoffel symbols, group 1 of 4.

This block belongs to a machine-checked proof that the Kerr–Newman metric g=η+f k⊗kg=\eta+f\,k\otimes kg=η+fk⊗k (Kerr–Schild form, f=r2(2mr−e2)/(r4+a2z2)f=r^2(2mr-e^2)/(r^4+a^2z^2)f=r2(2mr−e2)/(r4+a2z2)) and field F=dAF=dAF=dA, A=er3r4+a2z2kA=\frac{e r^3}{r^4+a^2z^2}kA=r4+a2z2er3​k, satisfy the Einstein equation Gμν=2(FμαFνα−14gμνFαβFαβ)G_{\mu\nu}=2(F_{\mu\alpha}F_\nu{}^\alpha-\tfrac14 g_{\mu\nu}F_{\alpha\beta}F^{\alpha\beta})Gμν​=2(Fμα​Fν​α−41​gμν​Fαβ​Fαβ) at every point with r>0r>0r>0, using the definitions NoHair_coordinates and NoHair_kerrNewman (statement NoHair.kerrNewman_einstein). Everything is expressed through the atoms rrr, k1,k2,k3k_1,k_2,k_3k1​,k2​,k3​ and W=1/(r2+a2k32)W=1/(r^2+a^2k_3^2)W=1/(r2+a2k32​), which satisfy k12+k22+k32=1k_1^2+k_2^2+k_3^2=1k12​+k22​+k32​=1 and W(r2+a2k32)=1W(r^2+a^2k_3^2)=1W(r2+a2k32​)=1. The curvature computation becomes polynomial identities modulo these two relations; each identity is closed by linear_combination with cofactors precomputed by a Gröbner-basis division. The proof is split into 13 blocks only so that each compiles within the platform's time limit; they contain no sorry and use only the standard axioms.

Definition code
/-
Kerr–Newman satisfies the Einstein equation (Kerr–Schild coordinates): Div1 (4 of 13).
Differentiability and coordinate divergence of the closed-form Christoffel symbols, group 1 of 4.
The development is split into parts only so that each piece compiles within the platform limits.
-/
import Mathlib
import Definitions.Def_NoHair_KerrNewmanEinstein_Atoms

set_option autoImplicit false
set_option linter.all false
set_option Elab.async false

open scoped BigOperators
open NoHair

namespace NoHair.KNE

theorem dG000 (m a e : ℝ) (z : E4) (hz : 0 < ksRadius a z) :
    DifferentiableAt ℝ (fun w => G000 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z := by
  have hR := hasCP_R a z hz
  have hK1 := hasCP_K1 a z hz
  have hK2 := hasCP_K2 a z hz
  have hK3 := hasCP_K3 a z hz
  have hWc := hasCP_W a z hz
  exact ((HasCP.add (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (2 : ℝ) z) (HasCP.pow hR 3)) (HasCP.pow hWc 3)) (HasCP.cst (m ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-3 : ℝ) z) (HasCP.pow hR 2)) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-2 : ℝ) z) hR) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (m ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul hR (HasCP.pow hWc 3)) (HasCP.cst (e ^ (4 : ℕ)) z)))) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.pow hK3 2) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z)))).diff

theorem dG001 (m a e : ℝ) (z : E4) (hz : 0 < ksRadius a z) :
    DifferentiableAt ℝ (fun w => G001 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z := by
  have hR := hasCP_R a z hz
  have hK1 := hasCP_K1 a z hz
  have hK2 := hasCP_K2 a z hz
  have hK3 := hasCP_K3 a z hz
  have hWc := hasCP_W a z hz
  exact ((HasCP.add (HasCP.add (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.pow hR 4) hK1) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (2 : ℝ) z) (HasCP.pow hR 3)) hK1) (HasCP.pow hWc 3)) (HasCP.cst (m ^ (2 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) (HasCP.pow hR 3)) hK1) (HasCP.pow hWc 3)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) (HasCP.pow hR 3)) hK2) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst m z)))) (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-3 : ℝ) z) (HasCP.pow hR 2)) hK1) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-3 : ℝ) z) (HasCP.pow hR 2)) hK1) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.pow hR 2) hK2) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-2 : ℝ) z) hR) hK1) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (m ^ (2 : ℕ)) z))))) (HasCP.add (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul hR hK1) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul hR hK1) (HasCP.pow hWc 3)) (HasCP.cst (e ^ (4 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (3 : ℝ) z) hR) hK2) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (3 : ℕ)) z)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul hK1 (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z)))) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) hK2) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (3 : ℕ)) z)) (HasCP.cst (e ^ (2 : ℕ)) z))))).diff

theorem dG002 (m a e : ℝ) (z : E4) (hz : 0 < ksRadius a z) :
    DifferentiableAt ℝ (fun w => G002 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z := by
  have hR := hasCP_R a z hz
  have hK1 := hasCP_K1 a z hz
  have hK2 := hasCP_K2 a z hz
  have hK3 := hasCP_K3 a z hz
  have hWc := hasCP_W a z hz
  exact ((HasCP.add (HasCP.add (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.pow hR 4) hK2) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.pow hR 3) hK1) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst m z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (2 : ℝ) z) (HasCP.pow hR 3)) hK2) (HasCP.pow hWc 3)) (HasCP.cst (m ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) (HasCP.pow hR 3)) hK2) (HasCP.pow hWc 3)) (HasCP.cst (e ^ (2 : ℕ)) z)))) (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) (HasCP.pow hR 2)) hK1) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-3 : ℝ) z) (HasCP.pow hR 2)) hK2) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-3 : ℝ) z) (HasCP.pow hR 2)) hK2) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-3 : ℝ) z) hR) hK1) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (3 : ℕ)) z)) (HasCP.cst m z))))) (HasCP.add (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-2 : ℝ) z) hR) hK2) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (m ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul hR hK2) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (e ^ (2 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul hR hK2) (HasCP.pow hWc 3)) (HasCP.cst (e ^ (4 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul hK1 (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (3 : ℕ)) z)) (HasCP.cst (e ^ (2 : ℕ)) z)))) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul hK2 (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z))))).diff

theorem dG003 (m a e : ℝ) (z : E4) (hz : 0 < ksRadius a z) :
    DifferentiableAt ℝ (fun w => G003 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z := by
  have hR := hasCP_R a z hz
  have hK1 := hasCP_K1 a z hz
  have hK2 := hasCP_K2 a z hz
  have hK3 := hasCP_K3 a z hz
  have hWc := hasCP_W a z hz
  exact ((HasCP.add (HasCP.add (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.pow hR 4) hK3) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (2 : ℝ) z) (HasCP.pow hR 3)) hK3) (HasCP.pow hWc 3)) (HasCP.cst (m ^ (2 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) (HasCP.pow hR 3)) hK3) (HasCP.pow hWc 3)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-3 : ℝ) z) (HasCP.pow hR 2)) (HasCP.pow hK3 3)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)))) (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (3 : ℝ) z) (HasCP.pow hR 2)) hK3) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-3 : ℝ) z) (HasCP.pow hR 2)) hK3) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-2 : ℝ) z) hR) (HasCP.pow hK3 3)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (m ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul hR (HasCP.pow hK3 3)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (e ^ (2 : ℕ)) z))))) (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-2 : ℝ) z) hR) hK3) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul hR hK3) (HasCP.pow hWc 3)) (HasCP.cst (e ^ (4 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) (HasCP.pow hK3 3)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (4 : ℕ)) z)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.pow hK3 3) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z)))))).diff

theorem dG100 (m a e : ℝ) (z : E4) (hz : 0 < ksRadius a z) :
    DifferentiableAt ℝ (fun w => G100 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z ∧
    coordPartial (fun w => G100 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) 1 z = DD100 a m e (ksRadius a z) (ksNull a z 1) (ksNull a z 2) (ksNull a z 3) (Wf a z) := by
  have hR := hasCP_R a z hz
  have hK1 := hasCP_K1 a z hz
  have hK2 := hasCP_K2 a z hz
  have hK3 := hasCP_K3 a z hz
  have hWc := hasCP_W a z hz
  have h : HasCP (fun w => G100 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z _ :=
    (HasCP.add (HasCP.add (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.pow hR 4) hK1) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-2 : ℝ) z) (HasCP.pow hR 3)) hK1) (HasCP.pow hWc 3)) (HasCP.cst (m ^ (2 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) (HasCP.pow hR 3)) hK1) (HasCP.pow hWc 3)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) (HasCP.pow hR 3)) hK2) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst m z)))) (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-3 : ℝ) z) (HasCP.pow hR 2)) hK1) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (3 : ℝ) z) (HasCP.pow hR 2)) hK1) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.pow hR 2) hK2) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (2 : ℝ) z) hR) hK1) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (m ^ (2 : ℕ)) z))))) (HasCP.add (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul hR hK1) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) hR) hK1) (HasCP.pow hWc 3)) (HasCP.cst (e ^ (4 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (3 : ℝ) z) hR) hK2) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (3 : ℕ)) z)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) hK1) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z)))) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) hK2) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (3 : ℕ)) z)) (HasCP.cst (e ^ (2 : ℕ)) z))))
  refine ⟨h.diff, ?_⟩
  rw [h.eq]
  simp only [dRt, dKt, dWt, DD100, Matrix.cons_val, Nat.cast_ofNat, Nat.reduceSub, pow_one]
  have hrel := ks_rel a z hz
  have hW := ks_W a z hz
  set R := ksRadius a z
  set K1 := ksNull a z 1
  set K2 := ksNull a z 2
  set K3 := ksNull a z 3
  set W := Wf a z
  linear_combination ((-3 * R ^ (7 : ℕ) * W ^ (5 : ℕ) * m + 4 * R ^ (6 : ℕ) * W ^ (5 : ℕ) * m ^ (2 : ℕ) + 2 * R ^ (6 : ℕ) * W ^ (5 : ℕ) * e ^ (2 : ℕ) - 6 * R ^ (5 : ℕ) * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * m - 3 * R ^ (5 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * m - 3 * R ^ (5 : ℕ) * W ^ (5 : ℕ) * m * e ^ (2 : ℕ) + 4 * R ^ (5 : ℕ) * W ^ (4 : ℕ) * m + 8 * R ^ (4 : ℕ) * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + 4 * R ^ (4 : ℕ) * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * e ^ (2 : ℕ) + 4 * R ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * e ^ (2 : ℕ) - 6 * R ^ (4 : ℕ) * W ^ (4 : ℕ) * m ^ (2 : ℕ) - 3 * R ^ (4 : ℕ) * W ^ (4 : ℕ) * e ^ (2 : ℕ) - 3 * R ^ (3 : ℕ) * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * m + 30 * R ^ (3 : ℕ) * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * m - 6 * R ^ (3 : ℕ) * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) + 6 * R ^ (3 : ℕ) * W ^ (4 : ℕ) * m * e ^ (2 : ℕ) + 4 * R ^ (2 : ℕ) * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * m ^ (2 : ℕ) + 2 * R ^ (2 : ℕ) * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * e ^ (2 : ℕ) - 16 * R ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * e ^ (2 : ℕ) - 2 * R ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) - R ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * e ^ (2 : ℕ) - R ^ (2 : ℕ) * W ^ (4 : ℕ) * e ^ (4 : ℕ) - 15 * R * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (6 : ℕ) * m - 3 * R * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * m * e ^ (2 : ℕ) + 2 * R * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) + 4 * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (6 : ℕ) * e ^ (2 : ℕ))) * hrel + ((3 * R ^ (5 : ℕ) * K2 ^ (2 : ℕ) * W ^ (4 : ℕ) * m + 3 * R ^ (5 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * m - 4 * R ^ (5 : ℕ) * W ^ (4 : ℕ) * m + 6 * R ^ (4 : ℕ) * K1 * K2 * W ^ (4 : ℕ) * a * m - 4 * R ^ (4 : ℕ) * K2 ^ (2 : ℕ) * W ^ (4 : ℕ) * m ^ (2 : ℕ) - 2 * R ^ (4 : ℕ) * K2 ^ (2 : ℕ) * W ^ (4 : ℕ) * e ^ (2 : ℕ) - 4 * R ^ (4 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * m ^ (2 : ℕ) - 2 * R ^ (4 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * e ^ (2 : ℕ) + 6 * R ^ (4 : ℕ) * W ^ (4 : ℕ) * m ^ (2 : ℕ) + 3 * R ^ (4 : ℕ) * W ^ (4 : ℕ) * e ^ (2 : ℕ) - 6 * R ^ (3 : ℕ) * K1 * K2 * W ^ (4 : ℕ) * a * m ^ (2 : ℕ) - 4 * R ^ (3 : ℕ) * K1 * K2 * W ^ (4 : ℕ) * a * e ^ (2 : ℕ) + 3 * R ^ (3 : ℕ) * K2 ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m - 3 * R ^ (3 : ℕ) * K2 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m + 3 * R ^ (3 : ℕ) * K2 ^ (2 : ℕ) * W ^ (4 : ℕ) * m * e ^ (2 : ℕ) + 3 * R ^ (3 : ℕ) * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m - R ^ (3 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m + 3 * R ^ (3 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * m * e ^ (2 : ℕ) - 6 * R ^ (3 : ℕ) * W ^ (4 : ℕ) * m * e ^ (2 : ℕ) + 6 * R ^ (2 : ℕ) * K1 * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m + 6 * R ^ (2 : ℕ) * K1 * K2 * W ^ (4 : ℕ) * a * m * e ^ (2 : ℕ) - 4 * R ^ (2 : ℕ) * K2 ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) - 2 * R ^ (2 : ℕ) * K2 ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * e ^ (2 : ℕ) + 2 * R ^ (2 : ℕ) * K2 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * e ^ (2 : ℕ) - 4 * R ^ (2 : ℕ) * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) - 2 * R ^ (2 : ℕ) * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * e ^ (2 : ℕ) + 2 * R ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + 2 * R ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * e ^ (2 : ℕ) + R ^ (2 : ℕ) * W ^ (4 : ℕ) * e ^ (4 : ℕ) - 2 * R * K1 * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m ^ (2 : ℕ) - 4 * R * K1 * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * e ^ (2 : ℕ) - R * K1 * K2 * W ^ (4 : ℕ) * a * e ^ (4 : ℕ) - 3 * R * K2 ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (4 : ℕ) * m + 3 * R * K2 ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) + 3 * R * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (4 : ℕ) * m + 3 * R * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) - 2 * R * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) + 2 * K1 * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m * e ^ (2 : ℕ) + 2 * K2 ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (4 : ℕ) * e ^ (2 : ℕ) - K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (4 : ℕ) * e ^ (2 : ℕ))) * hW

theorem dG101 (m a e : ℝ) (z : E4) (hz : 0 < ksRadius a z) :
    DifferentiableAt ℝ (fun w => G101 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z ∧
    coordPartial (fun w => G101 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) 1 z = DD101 a m e (ksRadius a z) (ksNull a z 1) (ksNull a z 2) (ksNull a z 3) (Wf a z) := by
  have hR := hasCP_R a z hz
  have hK1 := hasCP_K1 a z hz
  have hK2 := hasCP_K2 a z hz
  have hK3 := hasCP_K3 a z hz
  have hWc := hasCP_W a z hz
  have h : HasCP (fun w => G101 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z _ :=
    (HasCP.add (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-2 : ℝ) z) (HasCP.pow hR 3)) (HasCP.pow hK1 2)) (HasCP.pow hWc 3)) (HasCP.cst (m ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (3 : ℝ) z) (HasCP.pow hR 2)) (HasCP.pow hK1 2)) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (2 : ℝ) z) hR) (HasCP.pow hK1 2)) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (m ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) hR) (HasCP.pow hK1 2)) (HasCP.pow hWc 3)) (HasCP.cst (e ^ (4 : ℕ)) z)))) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) (HasCP.pow hK1 2)) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z)))
  refine ⟨h.diff, ?_⟩
  rw [h.eq]
  simp only [dRt, dKt, dWt, DD101, Matrix.cons_val, Nat.cast_ofNat, Nat.reduceSub, pow_one]
  have hrel := ks_rel a z hz
  have hW := ks_W a z hz
  set R := ksRadius a z
  set K1 := ksNull a z 1
  set K2 := ksNull a z 2
  set K3 := ksNull a z 3
  set W := Wf a z
  linear_combination ((2 * R ^ (6 : ℕ) * K1 * W ^ (5 : ℕ) * m ^ (2 : ℕ) - 6 * R ^ (5 : ℕ) * K2 * W ^ (5 : ℕ) * a * m ^ (2 : ℕ) + 8 * R ^ (4 : ℕ) * K1 * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) - R ^ (4 : ℕ) * K1 * W ^ (5 : ℕ) * e ^ (4 : ℕ) - 6 * R ^ (4 : ℕ) * K1 * W ^ (4 : ℕ) * m ^ (2 : ℕ) + 6 * R ^ (4 : ℕ) * K2 * W ^ (5 : ℕ) * a * m * e ^ (2 : ℕ) - 4 * R ^ (3 : ℕ) * K1 * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) + 6 * R ^ (3 : ℕ) * K1 * W ^ (4 : ℕ) * m * e ^ (2 : ℕ) - 8 * R ^ (3 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (3 : ℕ) * m ^ (2 : ℕ) - R ^ (3 : ℕ) * K2 * W ^ (5 : ℕ) * a * e ^ (4 : ℕ) + 6 * R ^ (3 : ℕ) * K2 * W ^ (4 : ℕ) * a * m ^ (2 : ℕ) + 6 * R ^ (2 : ℕ) * K1 * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * m ^ (2 : ℕ) - R ^ (2 : ℕ) * K1 * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * e ^ (4 : ℕ) - 2 * R ^ (2 : ℕ) * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) - R ^ (2 : ℕ) * K1 * W ^ (4 : ℕ) * e ^ (4 : ℕ) + 8 * R ^ (2 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (3 : ℕ) * m * e ^ (2 : ℕ) - 6 * R ^ (2 : ℕ) * K2 * W ^ (4 : ℕ) * a * m * e ^ (2 : ℕ) - 4 * R * K1 * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * m * e ^ (2 : ℕ) + 2 * R * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) - 2 * R * K2 * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (5 : ℕ) * m ^ (2 : ℕ) - R * K2 * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (3 : ℕ) * e ^ (4 : ℕ) + 2 * R * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m ^ (2 : ℕ) + R * K2 * W ^ (4 : ℕ) * a * e ^ (4 : ℕ) + 2 * K2 * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (5 : ℕ) * m * e ^ (2 : ℕ) - 2 * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m * e ^ (2 : ℕ))) * hrel + ((-2 * R ^ (4 : ℕ) * K1 * K2 ^ (2 : ℕ) * W ^ (4 : ℕ) * m ^ (2 : ℕ) - 2 * R ^ (4 : ℕ) * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * m ^ (2 : ℕ) + 6 * R ^ (4 : ℕ) * K1 * W ^ (4 : ℕ) * m ^ (2 : ℕ) - 6 * R ^ (3 : ℕ) * K1 * W ^ (4 : ℕ) * m * e ^ (2 : ℕ) + 6 * R ^ (3 : ℕ) * K2 ^ (3 : ℕ) * W ^ (4 : ℕ) * a * m ^ (2 : ℕ) + 6 * R ^ (3 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a * m ^ (2 : ℕ) - 6 * R ^ (3 : ℕ) * K2 * W ^ (4 : ℕ) * a * m ^ (2 : ℕ) - 6 * R ^ (2 : ℕ) * K1 * K2 ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + R ^ (2 : ℕ) * K1 * K2 ^ (2 : ℕ) * W ^ (4 : ℕ) * e ^ (4 : ℕ) - 6 * R ^ (2 : ℕ) * K1 * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + 2 * R ^ (2 : ℕ) * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + R ^ (2 : ℕ) * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * e ^ (4 : ℕ) + R ^ (2 : ℕ) * K1 * W ^ (4 : ℕ) * e ^ (4 : ℕ) - 6 * R ^ (2 : ℕ) * K2 ^ (3 : ℕ) * W ^ (4 : ℕ) * a * m * e ^ (2 : ℕ) - 6 * R ^ (2 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a * m * e ^ (2 : ℕ) + 6 * R ^ (2 : ℕ) * K2 * W ^ (4 : ℕ) * a * m * e ^ (2 : ℕ) + 4 * R * K1 * K2 ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) + 4 * R * K1 * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) - 2 * R * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) + 2 * R * K2 ^ (3 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m ^ (2 : ℕ) + R * K2 ^ (3 : ℕ) * W ^ (4 : ℕ) * a * e ^ (4 : ℕ) + 2 * R * K2 * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m ^ (2 : ℕ) - 2 * R * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m ^ (2 : ℕ) + R * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a * e ^ (4 : ℕ) - R * K2 * W ^ (4 : ℕ) * a * e ^ (4 : ℕ) - 2 * K2 ^ (3 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m * e ^ (2 : ℕ) - 2 * K2 * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m * e ^ (2 : ℕ) + 2 * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m * e ^ (2 : ℕ))) * hW

theorem dG102 (m a e : ℝ) (z : E4) (hz : 0 < ksRadius a z) :
    DifferentiableAt ℝ (fun w => G102 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z ∧
    coordPartial (fun w => G102 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) 1 z = DD102 a m e (ksRadius a z) (ksNull a z 1) (ksNull a z 2) (ksNull a z 3) (Wf a z) := by
  have hR := hasCP_R a z hz
  have hK1 := hasCP_K1 a z hz
  have hK2 := hasCP_K2 a z hz
  have hK3 := hasCP_K3 a z hz
  have hWc := hasCP_W a z hz
  have h : HasCP (fun w => G102 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z _ :=
    (HasCP.add (HasCP.add (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-2 : ℝ) z) (HasCP.pow hR 3)) hK1) hK2) (HasCP.pow hWc 3)) (HasCP.cst (m ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (3 : ℝ) z) (HasCP.pow hR 3)) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst m z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) (HasCP.pow hR 3)) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (3 : ℝ) z) (HasCP.pow hR 2)) hK1) hK2) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z)))) (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-2 : ℝ) z) (HasCP.pow hR 2)) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.pow hR 2) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst (e ^ (2 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (2 : ℝ) z) hR) hK1) hK2) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (m ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) hR) hK1) hK2) (HasCP.pow hWc 3)) (HasCP.cst (e ^ (4 : ℕ)) z))))) (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) hR) (HasCP.pow hK3 4)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (3 : ℕ)) z)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (3 : ℝ) z) hR) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (3 : ℕ)) z)) (HasCP.cst m z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) hK1) hK2) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) (HasCP.pow hK3 2)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (3 : ℕ)) z)) (HasCP.cst (e ^ (2 : ℕ)) z)))))
  refine ⟨h.diff, ?_⟩
  rw [h.eq]
  simp only [dRt, dKt, dWt, DD102, Matrix.cons_val, Nat.cast_ofNat, Nat.reduceSub, pow_one]
  have hrel := ks_rel a z hz
  have hW := ks_W a z hz
  set R := ksRadius a z
  set K1 := ksNull a z 1
  set K2 := ksNull a z 2
  set K3 := ksNull a z 3
  set W := Wf a z
  linear_combination ((12 * R ^ (6 : ℕ) * K2 * W ^ (5 : ℕ) * m ^ (2 : ℕ) - 18 * R ^ (5 : ℕ) * K2 * W ^ (5 : ℕ) * m * e ^ (2 : ℕ) - 24 * R ^ (4 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + 6 * R ^ (4 : ℕ) * K2 * W ^ (5 : ℕ) * e ^ (4 : ℕ) - 4 * R ^ (4 : ℕ) * K2 * W ^ (4 : ℕ) * m ^ (2 : ℕ) + 24 * R ^ (3 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) + 3 * R ^ (3 : ℕ) * K2 * W ^ (4 : ℕ) * m * e ^ (2 : ℕ) + 12 * R ^ (2 : ℕ) * K2 * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * m ^ (2 : ℕ) - 6 * R ^ (2 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * e ^ (4 : ℕ) - 4 * R ^ (2 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) - 6 * R * K2 * K3 ^ (4 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * m * e ^ (2 : ℕ) + 3 * R * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ))) * hrel + ((-3 * R ^ (4 : ℕ) * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a * m + 3 * R ^ (4 : ℕ) * K1 * W ^ (4 : ℕ) * a * m - 2 * R ^ (4 : ℕ) * K2 ^ (3 : ℕ) * W ^ (4 : ℕ) * m ^ (2 : ℕ) - 2 * R ^ (4 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * m ^ (2 : ℕ) + 4 * R ^ (4 : ℕ) * K2 * W ^ (4 : ℕ) * m ^ (2 : ℕ) - 6 * R ^ (3 : ℕ) * K1 * K2 ^ (2 : ℕ) * W ^ (4 : ℕ) * a * m ^ (2 : ℕ) - 2 * R ^ (3 : ℕ) * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a * m ^ (2 : ℕ) - 2 * R ^ (3 : ℕ) * K1 * W ^ (4 : ℕ) * a * e ^ (2 : ℕ) + 3 * R ^ (3 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m - 3 * R ^ (3 : ℕ) * K2 * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m - 3 * R ^ (3 : ℕ) * K2 * W ^ (4 : ℕ) * m * e ^ (2 : ℕ) + 6 * R ^ (2 : ℕ) * K1 * K2 ^ (2 : ℕ) * W ^ (4 : ℕ) * a * m * e ^ (2 : ℕ) - 3 * R ^ (2 : ℕ) * K1 * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m + 3 * R ^ (2 : ℕ) * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m + 3 * R ^ (2 : ℕ) * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a * m * e ^ (2 : ℕ) - 6 * R ^ (2 : ℕ) * K2 ^ (3 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + R ^ (2 : ℕ) * K2 ^ (3 : ℕ) * W ^ (4 : ℕ) * e ^ (4 : ℕ) - 6 * R ^ (2 : ℕ) * K2 * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + 4 * R ^ (2 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + R ^ (2 : ℕ) * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * e ^ (4 : ℕ) + 2 * R ^ (2 : ℕ) * K2 * W ^ (4 : ℕ) * a ^ (2 : ℕ) * e ^ (2 : ℕ) - 2 * R * K1 * K2 ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m ^ (2 : ℕ) - R * K1 * K2 ^ (2 : ℕ) * W ^ (4 : ℕ) * a * e ^ (4 : ℕ) + 2 * R * K1 * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m ^ (2 : ℕ) - 2 * R * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * e ^ (2 : ℕ) - R * K1 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a * e ^ (4 : ℕ) + 4 * R * K2 ^ (3 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) + 3 * R * K2 * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (4 : ℕ) * m + 4 * R * K2 * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) - 3 * R * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (4 : ℕ) * m - 3 * R * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) + 2 * K1 * K2 ^ (2 : ℕ) * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m * e ^ (2 : ℕ) - K1 * K3 ^ (4 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m * e ^ (2 : ℕ) + 2 * K2 * K3 ^ (2 : ℕ) * W ^ (4 : ℕ) * a ^ (4 : ℕ) * e ^ (2 : ℕ))) * hW

theorem dG103 (m a e : ℝ) (z : E4) (hz : 0 < ksRadius a z) :
    DifferentiableAt ℝ (fun w => G103 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z ∧
    coordPartial (fun w => G103 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) 1 z = DD103 a m e (ksRadius a z) (ksNull a z 1) (ksNull a z 2) (ksNull a z 3) (Wf a z) := by
  have hR := hasCP_R a z hz
  have hK1 := hasCP_K1 a z hz
  have hK2 := hasCP_K2 a z hz
  have hK3 := hasCP_K3 a z hz
  have hWc := hasCP_W a z hz
  have h : HasCP (fun w => G103 a m e (ksRadius a w) (ksNull a w 1) (ksNull a w 2) (ksNull a w 3) (Wf a w)) z _ :=
    (HasCP.add (HasCP.add (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-2 : ℝ) z) (HasCP.pow hR 3)) hK1) hK3) (HasCP.pow hWc 3)) (HasCP.cst (m ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-3 : ℝ) z) (HasCP.pow hR 3)) hK2) hK3) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst m z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-3 : ℝ) z) (HasCP.pow hR 2)) hK1) hK3) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (3 : ℝ) z) (HasCP.pow hR 2)) hK1) hK3) (HasCP.pow hWc 3)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z)))) (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (2 : ℝ) z) (HasCP.pow hR 2)) hK2) hK3) (HasCP.pow hWc 3)) (HasCP.cst a z)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (2 : ℝ) z) hR) hK1) (HasCP.pow hK3 3)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (m ^ (2 : ℕ)) z))) (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (2 : ℝ) z) hR) hK1) hK3) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst (e ^ (2 : ℕ)) z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) hR) hK1) hK3) (HasCP.pow hWc 3)) (HasCP.cst (e ^ (4 : ℕ)) z))))) (HasCP.add (HasCP.add (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul hR hK2) (HasCP.pow hK3 3)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (3 : ℕ)) z)) (HasCP.cst m z)) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul hK1 (HasCP.pow hK3 3)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (4 : ℕ)) z)) (HasCP.cst m z))) (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.mul (HasCP.cst (-1 : ℝ) z) hK1) (HasCP.pow hK3 3)) (HasCP.pow hWc 3)) (HasCP.cst (a ^ (2 : ℕ)) z)) (HasCP.cst m z)) (HasCP.cst (e ^ (2 : ℕ)) z))))
  refine ⟨h.diff, ?_⟩
  rw [h.eq]
  simp only [dRt, dKt, dWt, DD103, Matrix.cons_val, Nat.cast_ofNat, Nat.reduceSub, pow_one]
  have hrel := ks_rel a z hz
  have hW := ks_W a z hz
  set R := ksRadius a z
  set K1 := ksNull a z 1
  set K2 := ksNull a z 2
  set K3 := ksNull a z 3
  set W := Wf a z
  linear_combination ((2 * R ^ (6 : ℕ) * K3 * W ^ (5 : ℕ) * m ^ (2 : ℕ) - 12 * R ^ (5 : ℕ) * K3 * W ^ (5 : ℕ) * a ^ (2 : ℕ) * m + 8 * R ^ (4 : ℕ) * K3 ^ (3 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + 12 * R ^ (4 : ℕ) * K3 * W ^ (5 : ℕ) * a ^ (2 : ℕ) * e ^ (2 : ℕ) - R ^ (4 : ℕ) * K3 * W ^ (5 : ℕ) * e ^ (4 : ℕ) - 4 * R ^ (4 : ℕ) * K3 * W ^ (4 : ℕ) * m ^ (2 : ℕ) + 36 * R ^ (3 : ℕ) * K3 ^ (3 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * m - 4 * R ^ (3 : ℕ) * K3 ^ (3 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) - 3 * R ^ (3 : ℕ) * K3 * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m + 3 * R ^ (3 : ℕ) * K3 * W ^ (4 : ℕ) * m * e ^ (2 : ℕ) + 6 * R ^ (2 : ℕ) * K3 ^ (5 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * m ^ (2 : ℕ) - 12 * R ^ (2 : ℕ) * K3 ^ (3 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * e ^ (2 : ℕ) - R ^ (2 : ℕ) * K3 ^ (3 : ℕ) * W ^ (5 : ℕ) * a ^ (2 : ℕ) * e ^ (4 : ℕ) - 4 * R ^ (2 : ℕ) * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) - 4 * R * K3 ^ (5 : ℕ) * W ^ (5 : ℕ) * a ^ (4 : ℕ) * m * e ^ (2 : ℕ) - 3 * R * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (4 : ℕ) * m + 3 * R * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ))) * hrel + ((3 * R ^ (4 : ℕ) * K1 * K2 * K3 * W ^ (4 : ℕ) * a * m - 2 * R ^ (4 : ℕ) * K2 ^ (2 : ℕ) * K3 * W ^ (4 : ℕ) * m ^ (2 : ℕ) - 2 * R ^ (4 : ℕ) * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * m ^ (2 : ℕ) + 4 * R ^ (4 : ℕ) * K3 * W ^ (4 : ℕ) * m ^ (2 : ℕ) - 4 * R ^ (3 : ℕ) * K1 * K2 * K3 * W ^ (4 : ℕ) * a * m ^ (2 : ℕ) - 6 * R ^ (3 : ℕ) * K2 ^ (2 : ℕ) * K3 * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m - 3 * R ^ (3 : ℕ) * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m + 3 * R ^ (3 : ℕ) * K3 * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m - 3 * R ^ (3 : ℕ) * K3 * W ^ (4 : ℕ) * m * e ^ (2 : ℕ) + 3 * R ^ (2 : ℕ) * K1 * K2 * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m - 3 * R ^ (2 : ℕ) * K1 * K2 * K3 * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m + 3 * R ^ (2 : ℕ) * K1 * K2 * K3 * W ^ (4 : ℕ) * a * m * e ^ (2 : ℕ) - 6 * R ^ (2 : ℕ) * K2 ^ (2 : ℕ) * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + R ^ (2 : ℕ) * K2 ^ (2 : ℕ) * K3 * W ^ (4 : ℕ) * e ^ (4 : ℕ) - 6 * R ^ (2 : ℕ) * K3 ^ (5 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + 4 * R ^ (2 : ℕ) * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m ^ (2 : ℕ) + R ^ (2 : ℕ) * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * e ^ (4 : ℕ) - 4 * R * K1 * K2 * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m ^ (2 : ℕ) - 6 * R * K2 ^ (2 : ℕ) * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (4 : ℕ) * m + 4 * R * K2 ^ (2 : ℕ) * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) - 3 * R * K3 ^ (5 : ℕ) * W ^ (4 : ℕ) * a ^ (4 : ℕ) * m + 4 * R * K3 ^ (5 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) + 3 * R * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (4 : ℕ) * m - 3 * R * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (2 : ℕ) * m * e ^ (2 : ℕ) - 3 * K1 * K2 * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (5 : ℕ) * m + 3 * K1 * K2 * K3 ^ (3 : ℕ) * W ^ (4 : ℕ) * a ^ (3 : ℕ) * m * e ^ (2 : ℕ))) * hW

end NoHair.KNE
Source
Original formalization for the Prove2Me mission *No-Hair Conjecture: Uniqueness of Stationary Kerr–Newman Black Holes*. Kerr–Newman metric: E. T. Newman et al., J. Math. Phys. 6 (1965) 918, https://doi.org/10.1063/1.1704351; Kerr–Schild form as in the platform definition `NoHair_kerrNewman`.

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me