| import OAI.Geometry.Arnold.MidpointDerivative |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators ContDiff |
| open scoped Topology NNReal |
| open Set Filter |
|
|
| namespace ArnoldCounterexample.Construction |
| open ArnoldCounterexample.Quadric ArnoldCounterexample.Field ArnoldCounterexample.Factors |
| open ArnoldCounterexample.ThreePoints |
| open scoped ContDiff Topology Matrix |
| open Set Filter |
|
|
| def kernelVector : CV := ![0,-1/4,Complex.I/4,1/4,Complex.I/4] |
|
|
| lemma kernelVector_ne_zero : kernelVector ≠ 0 := by |
| intro h |
| have := congrFun h 1 |
| norm_num [kernelVector] at this |
|
|
| lemma kernelVector_horizontal : Horizontal zeroVector kernelVector := by |
| constructor <;> apply Complex.ext <;> |
| norm_num [Horizontal, zeroVector, kernelVector, Fin.sum_univ_succ, |
| Complex.mul_re, Complex.mul_im, map_ofNat, vec_five_two, vec_five_three, vec_five_four] |
|
|
| lemma zero_left : leftSphere zeroVector = pole := congrArg Prod.fst zeroVector_factors |
| lemma zero_right : rightSphere zeroVector = -east := congrArg Prod.snd zeroVector_factors |
| lemma zero_casimir : casimir zeroVector = 1 := casimir_unit zeroLift (by rfl) |
| lemma zero_pairing : pairing zeroVector = 0 := by |
| simp only [pairing, zero_left, zero_right] |
| norm_num [pole,east,Fin.sum_univ_succ] |
|
|
| lemma zero_leftOperator (i : Fin 3) : leftOperator i zeroVector = |
| (![![0,Complex.I/2,1/2,-Complex.I/2,1/2], |
| ![0,-1/2,Complex.I/2,1/2,Complex.I/2], |
| ![0,-Complex.I/2,-1/2,-Complex.I/2,1/2]] : Fin 3 → CV) i := by |
| fin_cases i <;> ext j <;> fin_cases j <;> |
| norm_num [leftOperator, rotor_apply, Pi.single_apply, zeroVector, |
| vec_five_two, vec_five_three, vec_five_four, Matrix.cons_val_two, Fin.ext_iff] <;> ring |
|
|
| lemma zero_rightOperator (i : Fin 3) : rightOperator i zeroVector = |
| (![![0,Complex.I/2,1/2,Complex.I/2,-1/2], |
| ![0,-1/2,-Complex.I/2,1/2,-Complex.I/2], |
| ![0,-Complex.I/2,1/2,Complex.I/2,1/2]] : Fin 3 → CV) i := by |
| fin_cases i <;> ext j <;> fin_cases j <;> |
| norm_num [rightOperator, rotor_apply, Pi.single_apply, zeroVector, |
| vec_five_two, vec_five_three, vec_five_four, Matrix.cons_val_two, Fin.ext_iff] <;> ring |
|
|
| lemma left_kernel (i : Fin 3) : symplectic (leftOperator i zeroVector) kernelVector = east i := by |
| rw [zero_leftOperator, symplectic_apply] |
| fin_cases i <;> norm_num [omega, kernelVector, Fin.sum_univ_succ, Complex.mul_im, east, |
| vec_five_two, vec_five_three, vec_five_four, Matrix.cons_val_two, map_ofNat] |
|
|
| lemma right_kernel (i : Fin 3) : symplectic (rightOperator i zeroVector) kernelVector = 0 := by |
| rw [zero_rightOperator, symplectic_apply] |
| fin_cases i <;> norm_num [omega, kernelVector, Fin.sum_univ_succ, Complex.mul_im, |
| vec_five_two, vec_five_three, vec_five_four, Matrix.cons_val_two, map_ofNat] |
|
|
| lemma zero_operator_cancel : rightOperator 0 zeroVector + leftOperator 2 zeroVector = 0 := by |
| rw [zero_leftOperator, zero_rightOperator] |
| ext i |
| fin_cases i <;> norm_num [vec_five_two, vec_five_three, vec_five_four, Matrix.cons_val_two] <;> ring |
|
|
| def kernelCurve (t : ℝ) : CV := zeroVector + t • kernelVector |
| lemma kernelCurve_zero : kernelCurve 0 = zeroVector := by simp [kernelCurve] |
| lemma kernelCurve_derivative : HasDerivAt kernelCurve kernelVector 0 := by |
| convert! (hasDerivAt_const (0:ℝ) zeroVector).add ((hasDerivAt_id (0:ℝ)).smul_const kernelVector) using 1 |
| simp |
|
|
| lemma left_curve (i : Fin 3) : HasDerivAt (fun t ↦ leftSphere (kernelCurve t) i) (east i) 0 := by |
| convert! (left_hasFDerivAt i (kernelCurve 0)).comp_hasDerivAt 0 kernelCurve_derivative using 1 |
| simp only [kernelCurve_zero, left_kernel] |
| lemma right_curve (i : Fin 3) : HasDerivAt (fun t ↦ rightSphere (kernelCurve t) i) 0 0 := by |
| convert! (right_hasFDerivAt i (kernelCurve 0)).comp_hasDerivAt 0 kernelCurve_derivative using 1 |
| simp only [kernelCurve_zero, right_kernel] |
|
|
| lemma casimir_curve : HasDerivAt (fun t ↦ casimir (kernelCurve t)) 0 0 := by |
| have h := HasDerivAt.fun_sum (u := Finset.univ) (fun i : Fin 3 ↦ fun _ ↦ (left_curve i).pow 2) |
| convert! h using 1 |
| norm_num [kernelCurve_zero, zero_left, pole, east, Fin.sum_univ_succ] |
|
|
| lemma pairing_curve : HasDerivAt (fun t ↦ pairing (kernelCurve t)) (-1) 0 := by |
| have h := HasDerivAt.fun_sum (u := Finset.univ) (fun i : Fin 3 ↦ fun _ ↦ (left_curve i).mul (right_curve i)) |
| convert! h using 1 |
| norm_num [kernelCurve_zero, zero_left, zero_right, pole, east, Fin.sum_univ_succ] |
|
|
| lemma mixed_curve : HasDerivAt (fun t ↦ mixedField (kernelCurve t)) |
| (-leftOperator 0 kernelVector + rightOperator 2 kernelVector + rightOperator 0 zeroVector) 0 := by |
| have h := HasDerivAt.fun_sum (u := Finset.univ) (fun i : Fin 3 ↦ fun _ ↦ |
| ((right_curve i).smul ((leftOperator i).hasFDerivAt.comp_hasDerivAt 0 kernelCurve_derivative)).add |
| ((left_curve i).smul ((rightOperator i).hasFDerivAt.comp_hasDerivAt 0 kernelCurve_derivative))) |
| convert! h using 1 |
| simp [kernelCurve_zero, zero_left, zero_right, pole, east, Fin.sum_univ_succ] |
| module |
|
|
| lemma core_curve : HasDerivAt (fun t ↦ core (kernelCurve t)) 0 0 := by |
| have hb : HasDerivAt (fun t ↦ radial (casimir (kernelCurve t))) 0 0 := by |
| convert! (radial_smooth.differentiable (by simp) (casimir (kernelCurve 0))).hasDerivAt.comp 0 casimir_curve using 1 |
| simp only [mul_zero] |
| have hds : ContDiff ℝ ∞ (deriv radial) := (contDiff_infty_iff_deriv.mp radial_smooth).2 |
| have hdb : HasDerivAt (fun t ↦ deriv radial (casimir (kernelCurve t))) 0 0 := by |
| convert! (hds.differentiable (by simp) (casimir (kernelCurve 0))).hasDerivAt.comp 0 casimir_curve using 1 |
| simp only [mul_zero] |
| have hc : HasDerivAt (fun t ↦ 2 * deriv radial (casimir (kernelCurve t)) * pairing (kernelCurve t)) 1 0 := by |
| convert! (hdb.const_mul 2).mul pairing_curve using 1 |
| simp [kernelCurve_zero, zero_casimir, zero_pairing, radial_at_one.2] |
| have hs : HasDerivAt (fun t ↦ selfField (kernelCurve t)) |
| (fderiv ℝ selfField zeroVector kernelVector) 0 := by |
| convert! (self_smooth.differentiable (by simp) (kernelCurve 0)).hasFDerivAt.comp_hasDerivAt 0 kernelCurve_derivative using 1 |
| simp only [kernelCurve_zero] |
| have h := (((leftOperator 0).hasFDerivAt.comp_hasDerivAt 0 kernelCurve_derivative).sub |
| ((rightOperator 2).hasFDerivAt.comp_hasDerivAt 0 kernelCurve_derivative)).add (hb.smul mixed_curve) |>.add (hc.smul hs) |
| convert! h using 1 |
| simp [kernelCurve_zero, zero_casimir, zero_pairing, radial_at_one.1, selfField, |
| zero_left, pole, Fin.sum_univ_succ] |
| calc |
| _ = rightOperator 0 zeroVector + leftOperator 2 zeroVector := zero_operator_cancel.symm |
| _ = _ := by module |
|
|
| lemma core_kernel : fderiv ℝ core zeroVector kernelVector = 0 := by |
| have h := (core_smooth.differentiable (by simp) (kernelCurve 0)).hasFDerivAt.comp_hasDerivAt 0 kernelCurve_derivative |
| simpa only [kernelCurve_zero] using h.unique core_curve |
|
|
| lemma vectorField_zeroVector : vectorField zeroVector = 0 := by |
| rw [vectorField, core_zeroVector, smul_zero] |
|
|
| lemma vectorField_kernel : fderiv ℝ vectorField zeroVector kernelVector = 0 := by |
| have h := vectorField_local_core (by rw [zeroVector_unit.1]; norm_num : normSquared zeroVector < 4) |
| rw [h.fderiv_eq] |
| exact core_kernel |
|
|
| end ArnoldCounterexample.Construction |
|
|
| end |
|
|
| end OAI |
|
|
