| import Mathlib |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace PackingSufficiencySupport.DiagonalQuadrics |
| open scoped ContDiff Topology |
| open Set Function |
|
|
| variable {m : ℕ} |
| abbrev Affine (m : ℕ) := ℂ × (Fin m → ℂ) |
|
|
| def equations (a : Fin m → ℂ) (z : Affine m) : Fin m → ℂ := |
| fun j => z.2 j ^ 2 - z.1 ^ 2 + a j |
|
|
| def locus (a : Fin m → ℂ) : Set (Affine m) := equations a ⁻¹' {0} |
|
|
| def jacobian (z : Affine m) : Affine m →L[ℂ] (Fin m → ℂ) := |
| ContinuousLinearMap.pi fun j => |
| (2*z.2 j) • ((ContinuousLinearMap.proj j).comp (ContinuousLinearMap.snd ℂ ℂ (Fin m → ℂ))) - |
| (2*z.1) • ContinuousLinearMap.fst ℂ ℂ (Fin m → ℂ) |
|
|
| @[simp] theorem jacobian_apply (z v : Affine m) (j : Fin m) : |
| jacobian z v j = 2*z.2 j*v.2 j-2*z.1*v.1 := rfl |
|
|
| theorem equations_contDiff (a : Fin m → ℂ) : ContDiff ℂ ∞ (equations a) := by |
| apply contDiff_pi.mpr |
| intro j |
| exact (((contDiff_apply ℂ ℂ j).comp contDiff_snd).pow 2).sub |
| (contDiff_fst.pow 2) |>.add contDiff_const |
|
|
| theorem equations_hasFDerivAt (a : Fin m → ℂ) (z : Affine m) : |
| HasFDerivAt (equations a) (jacobian z) z := by |
| apply hasFDerivAt_pi.mpr |
| intro j |
| convert! ((((ContinuousLinearMap.proj j).comp (ContinuousLinearMap.snd ℂ ℂ (Fin m → ℂ))).hasFDerivAt.pow 2).sub |
| ((ContinuousLinearMap.fst ℂ ℂ (Fin m → ℂ)).hasFDerivAt.pow 2)).add_const (a j) using 1 |
| simp |
|
|
| @[simp] theorem mem_locus {a : Fin m → ℂ} {z : Affine m} : |
| z∈locus a ↔ ∀ j,z.2 j^2=z.1^2-a j := by |
| simp only [locus,mem_preimage,mem_singleton_iff,funext_iff,equations,Pi.zero_apply] |
| constructor <;> intro h j <;> have := h j <;> linear_combination this |
|
|
| theorem locus_isClosed (a : Fin m → ℂ) : IsClosed (locus a) := |
| isClosed_singleton.preimage (equations_contDiff a).continuous |
|
|
| theorem at_most_one_zero {a : Fin m → ℂ} (ha : Injective a) {z : Affine m} |
| (hz : z∈locus a) {i j : Fin m} (hi : z.2 i=0) (hj : z.2 j=0) : i=j := by |
| apply ha |
| have hzi := (mem_locus.mp hz) i |
| have hzj := (mem_locus.mp hz) j |
| rw [hi,zero_pow (by decide)] at hzi |
| rw [hj,zero_pow (by decide)] at hzj |
| linear_combination hzi-hzj |
|
|
| theorem base_ne_zero_at_branch {a : Fin m → ℂ} (ha : ∀ j,a j≠0) {z : Affine m} |
| (hz : z∈locus a) {i : Fin m} (hi : z.2 i=0) : z.1≠0 := by |
| intro ht |
| have hzi := (mem_locus.mp hz) i |
| apply ha i |
| simpa only [hi,ht,zero_pow (by decide : (2:ℕ)≠0),zero_sub,eq_neg_iff_add_eq_zero,zero_add] using hzi |
|
|
| theorem jacobian_surjective {a : Fin m → ℂ} (ha : Injective a) (ha0 : ∀ j,a j≠0) |
| {z : Affine m} (hz : z∈locus a) : Surjective (jacobian z) := by |
| classical |
| by_cases hw : ∀ j,z.2 j≠0 |
| · intro y |
| refine ⟨(0,fun j => y j/(2*z.2 j)),?_⟩ |
| ext j |
| simp only [jacobian_apply,mul_zero,sub_zero] |
| exact mul_div_cancel₀ (y j) (mul_ne_zero (by norm_num) (hw j)) |
| · push Not at hw |
| obtain ⟨i,hi⟩ := hw |
| have ht := base_ne_zero_at_branch ha0 hz hi |
| intro y |
| let v : ℂ := -y i/(2*z.1) |
| refine ⟨(v,fun j => if j=i then 0 else (y j+2*z.1*v)/(2*z.2 j)),?_⟩ |
| have hv : 2*z.1*v= -y i := mul_div_cancel₀ (-y i) (mul_ne_zero (by norm_num) ht) |
| ext j |
| simp only [jacobian_apply] |
| by_cases hji : j=i |
| · subst j |
| simp only [hi,mul_zero,zero_mul,zero_sub,hv,neg_neg] |
| · have hj : z.2 j≠0 := fun hj => hji (at_most_one_zero ha hz hj hi) |
| rw [ite_eq_right hji,mul_div_cancel₀ _ (mul_ne_zero (by norm_num) hj),add_sub_cancel_right] |
|
|
| theorem ordinary_augmented_bijective {z : Affine m} (hw : ∀ j,z.2 j≠0) : |
| Bijective ((ContinuousLinearMap.fst ℂ ℂ (Fin m → ℂ)).prod (jacobian z)) := by |
| constructor |
| · intro v w h |
| have ht : v.1=w.1 := by |
| have ht := congrArg (fun x : Affine m => x.1) h |
| exact ht |
| apply Prod.ext ht |
| funext j |
| have he := congrArg (fun x : Affine m => x.2 j) h |
| change 2*z.2 j*v.2 j-2*z.1*v.1=2*z.2 j*w.2 j-2*z.1*w.1 at he |
| rw [ht] at he |
| have hm : (2*z.2 j)*v.2 j=(2*z.2 j)*w.2 j := by linear_combination he |
| exact mul_left_cancel₀ (mul_ne_zero (by norm_num : (2:ℂ)≠0) (hw j)) hm |
| · rintro ⟨t,y⟩ |
| refine ⟨(t,fun j => (y j+2*z.1*t)/(2*z.2 j)),?_⟩ |
| apply Prod.ext |
| · rfl |
| · funext j |
| change 2*z.2 j*((y j+2*z.1*t)/(2*z.2 j))-2*z.1*t=y j |
| rw [mul_div_cancel₀ _ (mul_ne_zero (by norm_num) (hw j)),add_sub_cancel_right] |
|
|
| theorem branch_augmented_bijective {a : Fin m → ℂ} (ha : Injective a) (ha0 : ∀ j,a j≠0) |
| {z : Affine m} (hz : z∈locus a) {i : Fin m} (hi : z.2 i=0) : |
| Bijective (((ContinuousLinearMap.proj i).comp (ContinuousLinearMap.snd ℂ ℂ (Fin m → ℂ))).prod |
| (jacobian z)) := by |
| classical |
| have ht := base_ne_zero_at_branch ha0 hz hi |
| constructor |
| · intro v w h |
| have hwi : v.2 i=w.2 i := congrArg Prod.fst h |
| have he j := congrArg (fun x : Affine m => x.2 j) h |
| have hti := he i |
| simp only [ContinuousLinearMap.prod_apply,jacobian_apply,hi,mul_zero,zero_mul,zero_sub, |
| neg_inj] at hti |
| have htv : v.1=w.1 := mul_left_cancel₀ (mul_ne_zero (by norm_num) ht) hti |
| apply Prod.ext htv |
| funext j |
| by_cases hji : j=i |
| · subst j |
| exact hwi |
| · have hj : z.2 j≠0 := fun hj => hji (at_most_one_zero ha hz hj hi) |
| have hej := he j |
| change 2*z.2 j*v.2 j-2*z.1*v.1=2*z.2 j*w.2 j-2*z.1*w.1 at hej |
| rw [htv] at hej |
| have hm : (2*z.2 j)*v.2 j=(2*z.2 j)*w.2 j := by linear_combination hej |
| exact mul_left_cancel₀ (mul_ne_zero (by norm_num : (2:ℂ)≠0) hj) hm |
| · rintro ⟨t,y⟩ |
| let v : ℂ := -y i/(2*z.1) |
| refine ⟨(v,fun j => if j=i then t else (y j+2*z.1*v)/(2*z.2 j)),?_⟩ |
| apply Prod.ext |
| · change (if i=i then t else (y i+2*z.1*v)/(2*z.2 i))=t |
| simp only [ite_true] |
| · have hv : 2*z.1*v= -y i := mul_div_cancel₀ (-y i) (mul_ne_zero (by norm_num) ht) |
| funext j |
| change 2*z.2 j*(if j=i then t else (y j+2*z.1*v)/(2*z.2 j))-2*z.1*v=y j |
| by_cases hji : j=i |
| · subst j |
| simp only [hi,mul_zero,zero_mul,zero_sub,hv,neg_neg] |
| · have hj : z.2 j≠0 := fun hj => hji (at_most_one_zero ha hz hj hi) |
| rw [ite_eq_right hji,mul_div_cancel₀ _ (mul_ne_zero (by norm_num) hj),add_sub_cancel_right] |
|
|
| @[simp] theorem sqrt_sq_complex (z : ℂ) : Complex.sqrt z ^ 2=z := by |
| exact Complex.cpow_nat_inv_pow z (by decide : (2:ℕ)≠0) |
|
|
| theorem sqrt_of_sq_pos {z : ℂ} (hz : 0<z.re) : Complex.sqrt (z^2)=z := |
| Complex.sq_cpow_two_inv hz |
|
|
| theorem sqrt_re_pos {z : ℂ} (hz : 0<z.re) : 0<(Complex.sqrt z).re := by |
| rw [Complex.sqrt,Complex.cpow_inv_two_re] |
| apply Real.sqrt_pos.mpr |
| positivity |
|
|
| theorem sqrt_contDiffAt {z : ℂ} (hz : 0<z.re) : ContDiffAt ℂ ∞ Complex.sqrt z := |
| ((Complex.differentiableOn_sqrt.contDiffOn Complex.isOpen_slitPlane) z (Or.inl hz)).contDiffAt |
| (Complex.isOpen_slitPlane.mem_nhds (Or.inl hz)) |
|
|
| namespace Explicit |
| variable (m : ℕ) |
|
|
| def parameters (j : Fin (m+2)) : ℂ := (j.val : ℂ)+1 |
|
|
| instance parameters_injective : Fact (Injective (parameters m)) := ⟨by |
| intro i j h |
| apply Fin.ext |
| have he : (i.val : ℂ)=(j.val : ℂ) := add_right_cancel h |
| exact_mod_cast he⟩ |
|
|
| instance parameters_nonzero : Fact (∀ j,parameters m j≠0) := ⟨by |
| intro j |
| have hp : 0<(j.val : ℝ)+1 := by positivity |
| intro h |
| have he := congrArg Complex.re h |
| simp only [parameters,Complex.add_re,Complex.natCast_re,Complex.one_re,Complex.zero_re] at he |
| linarith⟩ |
|
|
| @[simp] theorem parameters_zero : parameters m 0=1 := by simp [parameters] |
| @[simp] theorem parameters_one : parameters m 1=2 := by norm_num [parameters] |
|
|
| def plus (s : ℂ) : ℂ := (s+s⁻¹)/2 |
| def minus (s : ℂ) : ℂ := (s-s⁻¹)/2 |
| def baseSquare (s : ℂ) : ℂ := 1+plus s^2 |
|
|
| @[simp] theorem plus_add_minus (s : ℂ) : plus s+minus s=s := by unfold plus minus; ring |
|
|
| theorem plus_sq_sub_minus_sq {s : ℂ} (hs : s≠0) : plus s^2-minus s^2=1 := by |
| unfold plus minus |
| field_simp |
| ring |
|
|
| def annulusPoint (s : ℂ) : Affine (m+2) := |
| (Complex.sqrt (baseSquare s),fun j => |
| if j=0 then plus s else if j=1 then minus s |
| else Complex.I*Complex.sqrt (parameters m j-baseSquare s)) |
|
|
| @[simp] theorem annulusPoint_zero (s : ℂ) : (annulusPoint m s).2 0=plus s := by simp [annulusPoint] |
| @[simp] theorem annulusPoint_one (s : ℂ) : (annulusPoint m s).2 1=minus s := by |
| have hn : (1 : Fin (m+2))≠0 := by simp |
| simp [annulusPoint,hn] |
|
|
| theorem annulusPoint_mem {s : ℂ} (hs : s≠0) : annulusPoint m s∈locus (parameters m) := by |
| rw [mem_locus] |
| intro j |
| change (annulusPoint m s).2 j^2=Complex.sqrt (baseSquare s)^2-parameters m j |
| rw [sqrt_sq_complex] |
| by_cases hj0 : j=0 |
| · subst j |
| simp [baseSquare] |
| by_cases hj1 : j=1 |
| · subst j |
| have he := plus_sq_sub_minus_sq hs |
| simp only [annulusPoint_one,parameters_one,baseSquare] |
| linear_combination -he |
| · simp only [annulusPoint,ite_eq_right hj0,ite_eq_right hj1,mul_pow,Complex.I_sq,sqrt_sq_complex] |
| ring |
|
|
| def annulusDomain : Set ℂ := {s | s≠0 ∧ 0<(baseSquare s).re ∧ |
| ∀ j : Fin (m+2),1<j.val → 0<(parameters m j-baseSquare s).re} |
|
|
| end Explicit |
|
|
| def endSign (b : Bool) : ℂ := if b then -1 else 1 |
| @[simp] theorem endSign_sq (b : Bool) : endSign b^2=1 := by cases b <;> norm_num [endSign] |
| @[simp] theorem endSign_mul_self (b : Bool) : endSign b*endSign b=1 := by |
| simpa only [pow_two] using endSign_sq b |
| @[simp] theorem endSign_re (b : Bool) : (endSign b).re=if b then -1 else 1 := by |
| cases b <;> rfl |
| @[simp] theorem endSign_im (b : Bool) : (endSign b).im=0 := by cases b <;> simp [endSign] |
| theorem endSign_ne_zero (b : Bool) : endSign b≠0 := by cases b <;> norm_num [endSign] |
|
|
| def infinityRoot (a : Fin m → ℂ) (ε : Fin m → Bool) (s : ℂ) (j : Fin m) : ℂ := |
| endSign (ε j)*Complex.sqrt (1-a j*s^2) |
| def infinityPoint (a : Fin m → ℂ) (ε : Fin m → Bool) (s : ℂ) : Affine m := |
| (s⁻¹,fun j => s⁻¹*infinityRoot a ε s j) |
| def infinityRegion (a : Fin m → ℂ) : Set ℂ := {s | ∀ j,0<(1-a j*s^2).re} |
| def infinityDomain (a : Fin m → ℂ) : Set ℂ := {s | s≠0 ∧ s∈infinityRegion a} |
|
|
| @[simp] theorem infinityRoot_sq (a : Fin m → ℂ) (ε : Fin m → Bool) (s : ℂ) (j : Fin m) : |
| infinityRoot a ε s j^2=1-a j*s^2 := by |
| simp only [infinityRoot,mul_pow,endSign_sq,sqrt_sq_complex,one_mul] |
|
|
| theorem infinityPoint_mem (a : Fin m → ℂ) (ε : Fin m → Bool) {s : ℂ} (hs : s≠0) : |
| infinityPoint a ε s∈locus a := by |
| apply mem_locus.mpr |
| intro j |
| change (s⁻¹*infinityRoot a ε s j)^2=(s⁻¹)^2-a j |
| rw [mul_pow,infinityRoot_sq] |
| field_simp |
|
|
| @[simp] theorem infinityPoint_coordinate (a : Fin m → ℂ) (ε : Fin m → Bool) (s : ℂ) : |
| (infinityPoint a ε s).1⁻¹=s := inv_inv s |
|
|
| theorem infinityRoot_positive (a : Fin m → ℂ) (ε : Fin m → Bool) {s : ℂ} |
| (hs : s∈infinityRegion a) (j : Fin m) : 0<(endSign (ε j)*infinityRoot a ε s j).re := by |
| rw [infinityRoot,← mul_assoc,endSign_mul_self,one_mul] |
| exact sqrt_re_pos (hs j) |
|
|
| theorem infinityRegion_open (a : Fin m → ℂ) : IsOpen (infinityRegion a) := by |
| change IsOpen {s : ℂ | ∀ j,0<(1-a j*s^2).re} |
| simp only [ofPred_forall] |
| apply isOpen_iInter_of_finite |
| intro j |
| apply isOpen_lt continuous_const |
| fun_prop |
|
|
| theorem infinityDomain_open (a : Fin m → ℂ) : IsOpen (infinityDomain a) := |
| isOpen_ne_fun continuous_id continuous_const |>.inter (infinityRegion_open a) |
|
|
| @[simp] theorem zero_mem_infinityRegion (a : Fin m → ℂ) : (0 : ℂ)∈infinityRegion a := by |
| intro j |
| norm_num |
|
|
| theorem infinityRoot_contDiffAt (a : Fin m → ℂ) (ε : Fin m → Bool) {s : ℂ} |
| (hs : s∈infinityRegion a) : ContDiffAt ℂ ∞ (infinityRoot a ε) s := by |
| apply contDiffAt_pi.mpr |
| intro j |
| exact contDiffAt_const.mul ((sqrt_contDiffAt (hs j)).comp s |
| (contDiffAt_const.sub (contDiffAt_const.mul (contDiffAt_id.pow 2)))) |
|
|
| theorem infinityPoint_contDiffAt (a : Fin m → ℂ) (ε : Fin m → Bool) {s : ℂ} |
| (hs : s∈infinityDomain a) : ContDiffAt ℂ ∞ (infinityPoint a ε) s := by |
| apply (contDiffAt_id.inv hs.1).prodMk |
| apply contDiffAt_pi.mpr |
| intro j |
| exact (contDiffAt_id.inv hs.1).mul (contDiffAt_pi.mp (infinityRoot_contDiffAt a ε hs.2) j) |
|
|
| theorem infinityRegion_contains_ball (a : Fin m → ℂ) : |
| ∃ r : ℝ,0<r ∧ Metric.ball 0 r⊆infinityRegion a := |
| Metric.isOpen_iff.mp (infinityRegion_open a) 0 (zero_mem_infinityRegion a) |
|
|
| theorem branch_augmented_regular_bijective {z : Affine m} (ht : z.1≠0) |
| (i : Fin m) (hw : ∀ j,j≠i → z.2 j≠0) : |
| Bijective (((ContinuousLinearMap.proj i).comp (ContinuousLinearMap.snd ℂ ℂ (Fin m → ℂ))).prod |
| (jacobian z)) := by |
| classical |
| constructor |
| · intro v w h |
| have hwi : v.2 i=w.2 i := congrArg (fun x : Affine m => x.1) h |
| have he j := congrArg (fun x : Affine m => x.2 j) h |
| have hti := he i |
| change 2*z.2 i*v.2 i-2*z.1*v.1=2*z.2 i*w.2 i-2*z.1*w.1 at hti |
| have hm : 2*z.1*v.1=2*z.1*w.1 := by rw [hwi] at hti; linear_combination -hti |
| have htv : v.1=w.1 := mul_left_cancel₀ (mul_ne_zero (by norm_num : (2:ℂ)≠0) ht) hm |
| apply Prod.ext htv |
| funext j |
| by_cases hji : j=i |
| · subst j; exact hwi |
| · have hej := he j |
| change 2*z.2 j*v.2 j-2*z.1*v.1=2*z.2 j*w.2 j-2*z.1*w.1 at hej |
| rw [htv] at hej |
| have hm : (2*z.2 j)*v.2 j=(2*z.2 j)*w.2 j := by linear_combination hej |
| exact mul_left_cancel₀ (mul_ne_zero (by norm_num : (2:ℂ)≠0) (hw j hji)) hm |
| · rintro ⟨t,y⟩ |
| let v : ℂ := (2*z.2 i*t-y i)/(2*z.1) |
| have hv : 2*z.1*v=2*z.2 i*t-y i := |
| mul_div_cancel₀ _ (mul_ne_zero (by norm_num : (2:ℂ)≠0) ht) |
| refine ⟨(v,fun j => if j=i then t else (y j+2*z.1*v)/(2*z.2 j)),?_⟩ |
| apply Prod.ext |
| · change (if i=i then t else (y i+2*z.1*v)/(2*z.2 i))=t |
| simp only [ite_true] |
| · funext j |
| change 2*z.2 j*(if j=i then t else (y j+2*z.1*v)/(2*z.2 j))-2*z.1*v=y j |
| by_cases hji : j=i |
| · subst j |
| rw [ite_eq_left rfl,hv] |
| ring |
| · rw [ite_eq_right hji,mul_div_cancel₀ _ (mul_ne_zero (by norm_num) (hw j hji)),add_sub_cancel_right] |
|
|
| def curveCoordinate : Option (Fin m) → Affine m →L[ℂ] ℂ |
| | none => ContinuousLinearMap.fst ℂ ℂ (Fin m → ℂ) |
| | some i => (ContinuousLinearMap.proj i).comp (ContinuousLinearMap.snd ℂ ℂ (Fin m → ℂ)) |
|
|
| def regularCoordinate : Option (Fin m) → Set (Affine m) |
| | none => {z | ∀ j,z.2 j≠0} |
| | some i => {z | z.1≠0 ∧ ∀ j,j≠i → z.2 j≠0} |
|
|
| theorem regularCoordinate_isOpen (c : Option (Fin m)) : IsOpen (regularCoordinate c) := by |
| cases c with |
| | none => |
| simp only [regularCoordinate,ofPred_forall] |
| exact isOpen_iInter_of_finite fun j => isOpen_ne_fun (by fun_prop) continuous_const |
| | some i => |
| change IsOpen ({z : Affine m | z.1≠0} ∩ {z | ∀ j,j≠i → z.2 j≠0}) |
| apply IsOpen.inter (isOpen_ne_fun continuous_fst continuous_const) |
| simp only [ofPred_forall] |
| exact isOpen_iInter_of_finite fun j => isOpen_iInter_of_finite fun _ => |
| isOpen_ne_fun (by fun_prop) continuous_const |
|
|
| theorem regularCoordinate_bijective (c : Option (Fin m)) {z : Affine m} |
| (hz : z∈regularCoordinate c) : Bijective ((curveCoordinate c).prod (jacobian z)) := by |
| cases c with |
| | none => exact ordinary_augmented_bijective hz |
| | some i => exact branch_augmented_regular_bijective hz.1 i hz.2 |
|
|
| theorem exists_regularCoordinate {a : Fin m → ℂ} (ha : Injective a) (ha0 : ∀ j,a j≠0) |
| {z : Affine m} (hz : z∈locus a) : ∃ c,z∈regularCoordinate c := by |
| by_cases hw : ∀ j,z.2 j≠0 |
| · exact ⟨none,hw⟩ |
| · push Not at hw |
| obtain ⟨i,hi⟩ := hw |
| exact ⟨some i,base_ne_zero_at_branch ha0 hz hi, |
| fun j hji hj => hji (at_most_one_zero ha hz hj hi)⟩ |
|
|
| def normalCoordinates (a : Fin m → ℂ) (c : Option (Fin m)) (z : Affine m) : Affine m := |
| (curveCoordinate c z,equations a z) |
|
|
| theorem normalCoordinates_contDiff (a : Fin m → ℂ) (c : Option (Fin m)) : |
| ContDiff ℂ ∞ (normalCoordinates a c) := |
| (curveCoordinate c).contDiff.prodMk (equations_contDiff a) |
|
|
| theorem normalCoordinates_hasFDerivAt (a : Fin m → ℂ) (c : Option (Fin m)) (z : Affine m) : |
| HasFDerivAt (normalCoordinates a c) ((curveCoordinate c).prod (jacobian z)) z := |
| (curveCoordinate c).hasFDerivAt.prodMk (equations_hasFDerivAt a z) |
|
|
| theorem exists_normal_straightening (a : Fin m → ℂ) (c : Option (Fin m)) |
| {z : Affine m} (hz : z∈regularCoordinate c) : |
| ∃ e : OpenPartialHomeomorph (Affine m) (Affine m), |
| z∈e.source ∧ e.source⊆regularCoordinate c ∧ |
| (e : Affine m → Affine m)=normalCoordinates a c ∧ |
| ContDiff ℂ ∞ (e : Affine m → Affine m) ∧ |
| ContDiffOn ℂ ∞ (e.symm : Affine m → Affine m) e.target := by |
| let A := (curveCoordinate c).prod (jacobian z) |
| have hb := regularCoordinate_bijective c hz |
| let L : Affine m ≃L[ℂ] Affine m := ContinuousLinearEquiv.ofBijective A |
| (LinearMap.ker_eq_bot.mpr hb.1) (LinearMap.range_eq_top.mpr hb.2) |
| have hd : HasFDerivAt (normalCoordinates a c) (L : Affine m →L[ℂ] Affine m) z := |
| normalCoordinates_hasFDerivAt a c z |
| let e₀ := (normalCoordinates_contDiff a c).contDiffAt.toOpenPartialHomeomorph |
| (normalCoordinates a c) hd (by simp) |
| let e := e₀.restrOpen (regularCoordinate c) (regularCoordinate_isOpen c) |
| have he : (e : Affine m → Affine m)=normalCoordinates a c := rfl |
| have heSub : e.source⊆regularCoordinate c := inter_subset_right |
| refine ⟨e,⟨ContDiffAt.mem_toOpenPartialHomeomorph_source _ hd (by simp),hz⟩, |
| heSub,he,normalCoordinates_contDiff a c,?_⟩ |
| intro y hy |
| have hreg := heSub (e.map_target hy) |
| have hb' := regularCoordinate_bijective c hreg |
| let B := (curveCoordinate c).prod (jacobian (e.symm y)) |
| let K : Affine m ≃L[ℂ] Affine m := ContinuousLinearEquiv.ofBijective B |
| (LinearMap.ker_eq_bot.mpr hb'.1) (LinearMap.range_eq_top.mpr hb'.2) |
| exact (e.contDiffAt_symm (𝕜 := ℂ) (f₀' := K) hy |
| (normalCoordinates_hasFDerivAt a c (e.symm y)) |
| (normalCoordinates_contDiff a c).contDiffAt).contDiffWithinAt |
|
|
| structure NormalChart (a : Fin m → ℂ) where |
| coordinate : Option (Fin m) |
| ambient : OpenPartialHomeomorph (Affine m) (Affine m) |
| coe_eq : (ambient : Affine m → Affine m)=normalCoordinates a coordinate |
| smooth_inverse : ContDiffOn ℂ ∞ (ambient.symm : Affine m → Affine m) ambient.target |
|
|
| theorem exists_normalChart_at {a : Fin m → ℂ} (ha : Injective a) (ha0 : ∀ j,a j≠0) |
| (x : locus a) : ∃ e : NormalChart a,(x : Affine m)∈e.ambient.source := by |
| obtain ⟨c,hc⟩ := exists_regularCoordinate ha ha0 x.property |
| obtain ⟨e,he,_hreg,heq,_hf,hg⟩ := exists_normal_straightening a c hc |
| exact ⟨⟨c,e,heq,hg⟩,he⟩ |
|
|
| namespace NormalChart |
| variable {a : Fin m → ℂ} (e : NormalChart a) |
|
|
| @[simp] theorem ambient_apply (x : Affine m) : |
| e.ambient x=(curveCoordinate e.coordinate x,equations a x) := by |
| rw [e.coe_eq] |
| rfl |
|
|
| theorem inverse_on_slice {t : ℂ} (ht : (t,0)∈e.ambient.target) : |
| e.ambient.symm (t,0)∈locus a := by |
| have h := congrArg Prod.snd (e.ambient.right_inv ht) |
| rw [e.ambient_apply] at h |
| exact h |
|
|
| def sliceInverse (x : locus a) (t : ℂ) : locus a := by |
| classical |
| exact if h : (t,0)∈e.ambient.target then ⟨e.ambient.symm (t,0),e.inverse_on_slice h⟩ else x |
|
|
| theorem sliceInverse_eq (x : locus a) {t : ℂ} (ht : (t,0)∈e.ambient.target) : |
| (e.sliceInverse x t : Affine m)=e.ambient.symm (t,0) := by |
| simp only [sliceInverse,dite_eq_left ht] |
|
|
| def sliceChart (x : locus a) : OpenPartialHomeomorph (locus a) ℂ where |
| toFun y := curveCoordinate e.coordinate y.val |
| invFun := e.sliceInverse x |
| source := Subtype.val ⁻¹' e.ambient.source |
| target := (fun t : ℂ => (t,(0 : Fin m → ℂ))) ⁻¹' e.ambient.target |
| map_source' := by |
| intro y hy |
| have he := e.ambient.map_source hy |
| rw [e.ambient_apply] at he |
| have hy0 : equations a y.val=0 := y.property |
| change (curveCoordinate e.coordinate y.val,(0 : Fin m → ℂ))∈e.ambient.target |
| simpa only [hy0] using he |
| map_target' := by |
| intro t ht |
| change (e.sliceInverse x t : Affine m)∈e.ambient.source |
| rw [e.sliceInverse_eq x ht] |
| exact e.ambient.map_target ht |
| left_inv' := by |
| intro y hy |
| have hy0 : equations a y.val=0 := y.property |
| have hyt : (curveCoordinate e.coordinate y.val,0)∈e.ambient.target := by |
| simpa only [e.ambient_apply,hy0] using e.ambient.map_source hy |
| apply Subtype.ext |
| rw [e.sliceInverse_eq x hyt] |
| have he : (curveCoordinate e.coordinate y.val,0)=e.ambient y.val := by |
| rw [e.ambient_apply,hy0] |
| rw [he] |
| exact e.ambient.left_inv hy |
| right_inv' := by |
| intro t ht |
| rw [e.sliceInverse_eq x ht] |
| simpa only [e.ambient_apply] using congrArg Prod.fst (e.ambient.right_inv ht) |
| open_source := e.ambient.open_source.preimage continuous_subtype_val |
| open_target := e.ambient.open_target.preimage (continuous_id.prodMk continuous_const) |
| continuousOn_toFun := ((curveCoordinate e.coordinate).continuous.comp continuous_subtype_val).continuousOn |
| continuousOn_invFun := by |
| rw [continuousOn_iff_continuous_domRestrict] |
| apply continuous_induced_rng.mpr |
| have hc := e.ambient.continuousOn_symm.comp |
| (show Continuous (fun t : ℂ => (t,(0 : Fin m → ℂ))) from |
| continuous_id.prodMk continuous_const).continuousOn (mapsTo_preimage _ _) |
| rw [continuousOn_iff_continuous_domRestrict] at hc |
| exact hc.congr (fun t => (e.sliceInverse_eq x t.property).symm) |
|
|
| @[simp] theorem sliceChart_apply (x y : locus a) : |
| e.sliceChart x y=curveCoordinate e.coordinate y.val := rfl |
|
|
| @[simp] theorem sliceChart_source (x : locus a) : |
| (e.sliceChart x).source=Subtype.val ⁻¹' e.ambient.source := rfl |
|
|
| @[simp] theorem sliceChart_target (x : locus a) : |
| (e.sliceChart x).target=(fun t : ℂ => (t,(0 : Fin m → ℂ))) ⁻¹' e.ambient.target := rfl |
|
|
| theorem sliceChart_symm_eq (x : locus a) {t : ℂ} (ht : t∈(e.sliceChart x).target) : |
| ((e.sliceChart x).symm t : Affine m)=e.ambient.symm (t,0) := e.sliceInverse_eq x ht |
|
|
| theorem sliceChart_inverse_smooth (x : locus a) : |
| ContDiffOn ℂ ∞ (fun t => ((e.sliceChart x).symm t : Affine m)) (e.sliceChart x).target := by |
| have hs : ContDiff ℂ ∞ (fun t : ℂ => (t,(0 : Fin m → ℂ))) := |
| contDiff_id.prodMk contDiff_const |
| have hc := e.smooth_inverse.comp hs.contDiffOn (mapsTo_preimage _ _) |
| exact hc.congr (fun t ht => e.sliceChart_symm_eq x ht) |
|
|
| theorem transition_smooth (x : locus a) (f : NormalChart a) (y : locus a) : |
| ContDiffOn ℂ ∞ ((e.sliceChart x).symm.trans (f.sliceChart y)) |
| ((e.sliceChart x).symm.trans (f.sliceChart y)).source := by |
| have hc := (curveCoordinate f.coordinate).contDiff.comp_contDiffOn (e.sliceChart_inverse_smooth x) |
| exact hc.mono inter_subset_left |
|
|
| end NormalChart |
|
|
| end PackingSufficiencySupport.DiagonalQuadrics |
| end |
|
|
| end OAI |
|
|
