Download data/lean/OAI/Geometry/ComplexBundle/Kernel.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 20.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Kernel.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ComplexBundle/Kernel.lean
-
curl -L -o Kernel.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Kernel.lean
20.9 kB
| import Mathlib.Analysis.Calculus.ContDiff.FiniteDimension | |
| import Mathlib.Analysis.Calculus.ContDiff.Operations | |
| import Mathlib.Analysis.Complex.Basic | |
| import Mathlib.Analysis.Normed.Module.FiniteDimension | |
| import Mathlib.Analysis.Normed.Operator.Banach | |
| import Mathlib.Geometry.Manifold.VectorBundle.Basic | |
| import Mathlib.LinearAlgebra.Complex.FiniteDimensional | |
| import Mathlib.LinearAlgebra.Dimension.Free | |
| import Mathlib.LinearAlgebra.FiniteDimensional.Lemmas | |
| import Mathlib.Topology.Homeomorph.Defs | |
| import Mathlib.Topology.VectorBundle.Basic | |
| namespace OAI | |
| noncomputable section | |
| /-! Smooth splittings, kernel charts, and realization of kernel bundles. -/ | |
| section | |
| open scoped ContDiff | |
| namespace Kaplansky.SmoothKernel | |
| section | |
| variable {V W : Type*} [NormedAddCommGroup V] [NormedSpace β V] | |
| [NormedAddCommGroup W] [NormedSpace β W] | |
| /-- Right inverse on the open neighborhood where A R is invertible. -/ | |
| def localRightInverse (R : W βL[β] V) (A : V βL[β] W) : W βL[β] V := | |
| R.comp (Ring.inverse (A.comp R)) | |
| def kernelProjection (R : W βL[β] V) (A : V βL[β] W) : V βL[β] V := | |
| ContinuousLinearMap.id β V - (localRightInverse R A).comp A | |
| def splitDomain (R : W βL[β] V) : Set (V βL[β] W) := {A | IsUnit (A.comp R)} | |
| theorem splitDomain_open [CompleteSpace W] (R : W βL[β] V) : IsOpen (splitDomain R) := by | |
| change IsOpen ((fun A : V βL[β] W => A.comp R) β»ΒΉ' {B : W βL[β] W | IsUnit B}) | |
| exact Units.isOpen.preimage (continuous_id.clm_comp continuous_const) | |
| theorem localRightInverse_right (R : W βL[β] V) (A : V βL[β] W) | |
| (hA : A β splitDomain R) (w : W) : A (localRightInverse R A w)=w := by | |
| exact congrArg (fun T : W βL[β] W => T w) (Ring.mul_inverse_cancel (A.comp R) hA) | |
| theorem localRightInverse_on_range (R : W βL[β] V) (A : V βL[β] W) | |
| (hA : A β splitDomain R) (w : W) : localRightInverse R A (A (R w))=R w := by | |
| have h := congrArg (fun T : W βL[β] W => T w) (Ring.inverse_mul_cancel (A.comp R) hA) | |
| exact congrArg R h | |
| theorem kernelProjection_mem (R : W βL[β] V) (A : V βL[β] W) | |
| (hA : A β splitDomain R) (v : V) : A (kernelProjection R A v)=0 := by | |
| change A (v-localRightInverse R A (A v))=0 | |
| rw [map_sub,localRightInverse_right R A hA,sub_self] | |
| theorem kernelProjection_fix (R : W βL[β] V) (A : V βL[β] W) (v : V) | |
| (hv : A v=0) : kernelProjection R A v=v := by | |
| change v-localRightInverse R A (A v)=v | |
| rw [hv,map_zero,sub_zero] | |
| theorem kernelProjection_kill (R : W βL[β] V) (A : V βL[β] W) | |
| (hA : A β splitDomain R) (w : W) : kernelProjection R A (R w)=0 := by | |
| change R w-localRightInverse R A (A (R w))=0 | |
| rw [localRightInverse_on_range R A hA,sub_self] | |
| theorem kernelProjection_absorb (R : W βL[β] V) (A B : V βL[β] W) | |
| (hA : A β splitDomain R) (v : V) : | |
| kernelProjection R A (kernelProjection R B v)=kernelProjection R A v := by | |
| change kernelProjection R A (v-R (Ring.inverse (B.comp R) (B v)))=_ | |
| rw [map_sub,kernelProjection_kill R A hA,sub_zero] | |
| /-- Explicit linear identification of the actual kernels throughout the split | |
| neighborhood. Both maps are restrictions of the constructed projections. -/ | |
| def kernelEquiv (R : W βL[β] V) (L A : V βL[β] W) | |
| (hL : L β splitDomain R) (hA : A β splitDomain R) : | |
| LinearMap.ker L.toLinearMap ββ[β] LinearMap.ker A.toLinearMap where | |
| toFun v := β¨kernelProjection R A v.val,kernelProjection_mem R A hA v.valβ© | |
| invFun v := β¨kernelProjection R L v.val,kernelProjection_mem R L hL v.valβ© | |
| left_inv v := by | |
| apply Subtype.ext | |
| exact (kernelProjection_absorb R L A hL v.val).trans (kernelProjection_fix R L v.val v.property) | |
| right_inv v := by | |
| apply Subtype.ext | |
| exact (kernelProjection_absorb R A L hA v.val).trans (kernelProjection_fix R A v.val v.property) | |
| map_add' v w := by apply Subtype.ext; exact map_add _ _ _ | |
| map_smul' c v := by apply Subtype.ext; exact map_smul _ _ _ | |
| variable [CompleteSpace W] | |
| theorem localRightInverse_smooth (R : W βL[β] V) (A : V βL[β] W) | |
| (hA : A β splitDomain R) : ContDiffAt β β (localRightInverse R) A := by | |
| obtain β¨u,huβ© := hA | |
| have hi : ContDiffAt β β Ring.inverse (A.comp R) := by | |
| rw [β hu] | |
| exact contDiffAt_ringInverse β u | |
| exact contDiffAt_const.clm_comp (hi.comp A (contDiffAt_id.clm_comp contDiffAt_const)) | |
| theorem kernelProjection_smooth (R : W βL[β] V) (A : V βL[β] W) | |
| (hA : A β splitDomain R) : ContDiffAt β β (kernelProjection R) A := | |
| contDiffAt_const.sub ((localRightInverse_smooth R A hA).clm_comp contDiffAt_id) | |
| theorem kernelProjection_apply_smooth (R : W βL[β] V) (A : V βL[β] W) | |
| (hA : A β splitDomain R) (v : V) : | |
| ContDiffAt β β (fun p : (V βL[β] W) Γ V => kernelProjection R p.1 p.2) (A,v) := | |
| ((kernelProjection_smooth R A hA).comp (A,v) contDiffAt_fst).clm_apply contDiffAt_snd | |
| end | |
| variable {V W : Type*} [NormedAddCommGroup V] [NormedSpace β V] | |
| [NormedAddCommGroup W] [NormedSpace β W] [CompleteSpace W] | |
| def kernelRetraction (R : W βL[β] V) (L : V βL[β] W) (hL : L β splitDomain R) : | |
| V βL[β] LinearMap.ker L.toLinearMap := | |
| (kernelProjection R L).codRestrict _ (kernelProjection_mem R L hL) | |
| abbrev SplitBase (R : W βL[β] V) := {A : V βL[β] W // A β splitDomain R} | |
| /-- The actual incidence subset, with the topology induced from parameters and V. -/ | |
| abbrev SplitIncidence (R : W βL[β] V) := {p : SplitBase R Γ V // p.1.val p.2=0} | |
| /-- A homeomorphism over the parameter base between the actual local kernel | |
| incidence space and the product with one fixed kernel. -/ | |
| def kernelChartHomeomorph (R : W βL[β] V) (L : V βL[β] W) (hL : L β splitDomain R) : | |
| SplitIncidence R ββ SplitBase R Γ LinearMap.ker L.toLinearMap where | |
| toFun p := (p.val.1, kernelRetraction R L hL p.val.2) | |
| invFun p := β¨(p.1,kernelProjection R p.1.val p.2.val),kernelProjection_mem R _ p.1.property _β© | |
| left_inv p := by | |
| apply Subtype.ext | |
| apply Prod.ext | |
| Β· rfl | |
| Β· exact (kernelProjection_absorb R p.val.1.val L p.val.1.property p.val.2).trans | |
| (kernelProjection_fix R _ _ p.property) | |
| right_inv p := by | |
| apply Prod.ext | |
| Β· rfl | |
| Β· apply Subtype.ext | |
| exact (kernelProjection_absorb R L p.1.val hL p.2.val).trans | |
| (kernelProjection_fix R L p.2.val p.2.property) | |
| continuous_toFun := | |
| (continuous_fst.comp continuous_subtype_val).prodMk | |
| ((kernelRetraction R L hL).continuous.comp (continuous_snd.comp continuous_subtype_val)) | |
| continuous_invFun := by | |
| have hc : Continuous (fun A : SplitBase R => kernelProjection R A.val) := by | |
| apply continuous_iff_continuousAt.mpr | |
| intro A | |
| exact (kernelProjection_smooth R A.val A.property).continuousAt.comp | |
| continuous_subtype_val.continuousAt | |
| exact (continuous_fst.prodMk ((hc.comp continuous_fst).clm_apply | |
| (continuous_subtype_val.comp continuous_snd))).subtype_mk _ | |
| /-- The fiber coordinate transition really is projection onto the second | |
| fixed kernel after reconstruction in the varying kernel. -/ | |
| def kernelCoordinateChange (R R' : W βL[β] V) (L L' : V βL[β] W) | |
| (hL' : L' β splitDomain R') (A : V βL[β] W) : | |
| LinearMap.ker L.toLinearMap βL[β] LinearMap.ker L'.toLinearMap := | |
| (kernelRetraction R' L' hL').comp ((kernelProjection R A).comp | |
| (LinearMap.ker L.toLinearMap).subtypeL) | |
| theorem kernelCoordinateChange_smooth (R R' : W βL[β] V) (L L' : V βL[β] W) | |
| (hL' : L' β splitDomain R') (A : V βL[β] W) (hA : A β splitDomain R) : | |
| ContDiffAt β β (kernelCoordinateChange R R' L L' hL') A := | |
| contDiffAt_const.clm_comp ((kernelProjection_smooth R A hA).clm_comp contDiffAt_const) | |
| theorem kernelCoordinateChange_smooth_real (R R' : W βL[β] V) (L L' : V βL[β] W) | |
| (hL' : L' β splitDomain R') (A : V βL[β] W) (hA : A β splitDomain R) : | |
| ContDiffAt β β (kernelCoordinateChange R R' L L' hL') A := | |
| (kernelCoordinateChange_smooth R R' L L' hL' A hA).restrict_scalars β | |
| end Kaplansky.SmoothKernel | |
| end | |
| namespace Kaplansky.SmoothKernel | |
| variable {B V W : Type*} [TopologicalSpace B] | |
| [NormedAddCommGroup V] [NormedSpace β V] [FiniteDimensional β V] | |
| [NormedAddCommGroup W] [NormedSpace β W] [FiniteDimensional β W] | |
| abbrev KernelModel (V W : Type*) [NormedAddCommGroup V] [NormedSpace β V] | |
| [NormedAddCommGroup W] [NormedSpace β W] := | |
| Fin (Module.finrank β V-Module.finrank β W) β β | |
| /-- Ordinary continuous, surjective linear families. No kernel bundle is part | |
| of the input: the following construction supplies it. -/ | |
| structure SurjectiveFamily (B V W : Type*) [TopologicalSpace B] | |
| [NormedAddCommGroup V] [NormedSpace β V] | |
| [NormedAddCommGroup W] [NormedSpace β W] where | |
| map : B β V βL[β] W | |
| continuous : Continuous map | |
| surjective : β b, Function.Surjective (map b) | |
| local instance : CompleteSpace W := FiniteDimensional.complete β W | |
| namespace SurjectiveFamily | |
| variable (A : SurjectiveFamily B V W) | |
| def rightInverse (b : B) : W βL[β] V := | |
| ((A.map b).toLinearMap.exists_rightInverse_of_surjective | |
| (LinearMap.range_eq_top.mpr (A.surjective b))).choose.toContinuousLinearMap | |
| omit [FiniteDimensional β V] in | |
| theorem rightInverse_spec (b : B) : (A.map b).comp (A.rightInverse b)=1 := by | |
| apply ContinuousLinearMap.ext | |
| intro w | |
| exact congrArg (fun T : W ββ[β] W => T w) | |
| ((A.map b).toLinearMap.exists_rightInverse_of_surjective | |
| (LinearMap.range_eq_top.mpr (A.surjective b))).choose_spec | |
| omit [FiniteDimensional β V] in | |
| theorem center_mem (b : B) : A.map b β splitDomain (A.rightInverse b) := by | |
| change IsUnit ((A.map b).comp (A.rightInverse b)) | |
| rw [A.rightInverse_spec] | |
| exact isUnit_one | |
| omit [FiniteDimensional β W] in | |
| theorem kernel_finrank (b : B) : Module.finrank β (LinearMap.ker (A.map b).toLinearMap)= | |
| Module.finrank β V-Module.finrank β W := by | |
| have h := (A.map b).toLinearMap.finrank_range_add_finrank_ker | |
| rw [LinearMap.range_eq_top.mpr (A.surjective b),finrank_top] at h | |
| omega | |
| def modelEquiv (b : B) : KernelModel V W βL[β] LinearMap.ker (A.map b).toLinearMap := | |
| ((FiniteDimensional.nonempty_linearEquiv_iff_finrank_eq | |
| (R := β) (M := KernelModel V W) (M' := LinearMap.ker (A.map b).toLinearMap)).mpr | |
| (by simp [KernelModel,A.kernel_finrank])).some.toContinuousLinearEquiv | |
| def baseSet (i : B) : Set B := {b | A.map b β splitDomain (A.rightInverse i)} | |
| omit [FiniteDimensional β V] in | |
| theorem baseSet_open (i : B) : IsOpen (A.baseSet i) := | |
| (splitDomain_open (A.rightInverse i)).preimage A.continuous | |
| def toModel (i : B) : V βL[β] KernelModel V W := | |
| (A.modelEquiv i).symm.toContinuousLinearMap.comp | |
| (kernelRetraction (A.rightInverse i) (A.map i) (A.center_mem i)) | |
| def fromModel (i b : B) : KernelModel V W βL[β] V := | |
| (kernelProjection (A.rightInverse i) (A.map b)).comp | |
| (((LinearMap.ker (A.map i).toLinearMap).subtypeL).comp (A.modelEquiv i).toContinuousLinearMap) | |
| theorem fromModel_mem (i b : B) (hb : b β A.baseSet i) (z : KernelModel V W) : | |
| A.map b (A.fromModel i b z)=0 := | |
| kernelProjection_mem (A.rightInverse i) (A.map b) hb _ | |
| theorem toModel_fromModel (i b : B) (z : KernelModel V W) : | |
| A.toModel i (A.fromModel i b z)=z := by | |
| change (A.modelEquiv i).symm | |
| β¨kernelProjection (A.rightInverse i) (A.map i) | |
| (kernelProjection (A.rightInverse i) (A.map b) (A.modelEquiv i z).val),_β©=z | |
| have h := kernelProjection_absorb (A.rightInverse i) (A.map i) (A.map b) | |
| (A.center_mem i) (A.modelEquiv i z).val | |
| have hf := kernelProjection_fix (A.rightInverse i) (A.map i) | |
| (A.modelEquiv i z).val (A.modelEquiv i z).property | |
| have he : (β¨kernelProjection (A.rightInverse i) (A.map i) | |
| (kernelProjection (A.rightInverse i) (A.map b) (A.modelEquiv i z).val), | |
| kernelProjection_mem _ _ (A.center_mem i) _β© : LinearMap.ker (A.map i).toLinearMap)= | |
| A.modelEquiv i z := Subtype.ext (h.trans hf) | |
| rw [he,(A.modelEquiv i).symm_apply_apply] | |
| theorem fromModel_toModel (i b : B) (hb : b β A.baseSet i) (v : V) | |
| (hv : A.map b v=0) : A.fromModel i b (A.toModel i v)=v := by | |
| change kernelProjection (A.rightInverse i) (A.map b) | |
| (A.modelEquiv i ((A.modelEquiv i).symm (kernelRetraction _ _ _ v))).val=v | |
| rw [(A.modelEquiv i).apply_symm_apply] | |
| exact (kernelProjection_absorb (A.rightInverse i) (A.map b) (A.map i) hb v).trans | |
| (kernelProjection_fix _ _ v hv) | |
| def transition (i j b : B) : KernelModel V W βL[β] KernelModel V W := | |
| (A.toModel j).comp (A.fromModel i b) | |
| theorem transition_self (i b : B) (z : KernelModel V W) : A.transition i i b z=z := | |
| A.toModel_fromModel i b z | |
| theorem transition_comp (i j k b : B) (hi : b β A.baseSet i) (hj : b β A.baseSet j) | |
| (z : KernelModel V W) : | |
| A.transition j k b (A.transition i j b z)=A.transition i k b z := by | |
| change A.toModel k (A.fromModel j b (A.toModel j (A.fromModel i b z)))=_ | |
| rw [A.fromModel_toModel j b hj _ (A.fromModel_mem i b hi z)] | |
| rfl | |
| theorem continuousOn_fromModel (i : B) : ContinuousOn (A.fromModel i) (A.baseSet i) := by | |
| intro b hb | |
| exact (((kernelProjection_smooth (A.rightInverse i) (A.map b) hb).continuousAt.comp | |
| A.continuous.continuousAt).clm_comp continuousAt_const).continuousWithinAt | |
| /-- The kernel bundle core has the actual rank dim(V)-dim(W), with local | |
| transitions constructed from the family and its right inverses. -/ | |
| def core : VectorBundleCore β B (KernelModel V W) B where | |
| baseSet := A.baseSet | |
| isOpen_baseSet := A.baseSet_open | |
| indexAt b := b | |
| mem_baseSet_at b := A.center_mem b | |
| coordChange := A.transition | |
| coordChange_self i b _ z := A.transition_self i b z | |
| continuousOn_coordChange i j := | |
| (continuousOn_const (c := A.toModel j)).clm_comp | |
| ((A.continuousOn_fromModel i).mono Set.inter_subset_left) | |
| coordChange_comp i j k b hb z := A.transition_comp i j k b hb.1.1 hb.1.2 z | |
| /-- Every constructed fiber is linearly identified with the actual kernel. -/ | |
| def fiberEquiv (b : B) : A.core.Fiber b ββ[β] LinearMap.ker (A.map b).toLinearMap := | |
| (A.modelEquiv b).toLinearEquiv | |
| end SurjectiveFamily | |
| end Kaplansky.SmoothKernel | |
| section | |
| open scoped ContDiff Manifold | |
| namespace Kaplansky.SmoothKernel.SurjectiveFamily | |
| variable {B V W : Type*} [TopologicalSpace B] | |
| [NormedAddCommGroup V] [NormedSpace β V] [FiniteDimensional β V] | |
| [NormedAddCommGroup W] [NormedSpace β W] [FiniteDimensional β W] | |
| local instance : CompleteSpace W := FiniteDimensional.complete β W | |
| variable (A : SurjectiveFamily B V W) | |
| def realCore : VectorBundleCore β B (KernelModel V W) B where | |
| baseSet := A.baseSet | |
| isOpen_baseSet := A.baseSet_open | |
| indexAt b := b | |
| mem_baseSet_at b := A.center_mem b | |
| coordChange i j b := (A.transition i j b).restrictScalars β | |
| coordChange_self i b _ z := A.transition_self i b z | |
| continuousOn_coordChange i j := | |
| (ContinuousLinearMap.restrictScalarsL β (KernelModel V W) (KernelModel V W) β β).continuous.comp_continuousOn | |
| ((continuousOn_const (c := A.toModel j)).clm_comp | |
| ((A.continuousOn_fromModel i).mono Set.inter_subset_left)) | |
| coordChange_comp i j k b hb z := A.transition_comp i j k b hb.1.1 hb.1.2 z | |
| instance realFiberComplexModule (b : B) : Module β (A.realCore.Fiber b) := | |
| inferInstanceAs (Module β (KernelModel V W)) | |
| def realFiberEquiv (b : B) : A.realCore.Fiber b ββ[β] LinearMap.ker (A.map b).toLinearMap := | |
| (A.modelEquiv b).toLinearEquiv | |
| omit [FiniteDimensional β V] [FiniteDimensional β W] in | |
| theorem kernel_model_real_finrank : Module.finrank β (KernelModel V W)= | |
| 2*(Module.finrank β V-Module.finrank β W) := by | |
| rw [finrank_real_of_complex] | |
| simp [KernelModel] | |
| variable {X : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| variable (D : SurjectiveFamily X V W) | |
| theorem transition_contDiffAt (hD : ContDiff β β D.map) (i j x : X) (hx : x β D.baseSet i) : | |
| ContDiffAt β β (D.transition i j) x := by | |
| have hc : ContDiff β β (fun P : V βL[β] V => (D.toModel j).comp | |
| (P.comp (((LinearMap.ker (D.map i).toLinearMap).subtypeL).comp | |
| (D.modelEquiv i).toContinuousLinearMap))) := | |
| contDiff_const.clm_comp (contDiff_id.clm_comp contDiff_const) | |
| exact (hc.restrict_scalars β).contDiffAt.comp x | |
| (((kernelProjection_smooth (D.rightInverse i) (D.map x) hx).restrict_scalars β).comp x | |
| hD.contDiffAt) | |
| /-- A genuinely smooth kernel bundle, derived from smoothness and surjectivity | |
| of the original family. Smoothness of the kernel bundle is not an assumption. -/ | |
| theorem realCore_isContMDiff (hD : ContDiff β β D.map) : | |
| D.realCore.IsContMDiff π(β,X) β where | |
| contMDiffOn_coordChange i j := by | |
| apply ContDiffOn.contMDiffOn | |
| intro x hx | |
| exact ((ContinuousLinearMap.restrictScalarsL β (KernelModel V W) (KernelModel V W) β β).contDiff.contDiffAt.comp x | |
| (D.transition_contDiffAt hD i j x hx.1)).contDiffWithinAt | |
| end Kaplansky.SmoothKernel.SurjectiveFamily | |
| end | |
| open Topology Bundle | |
| namespace Kaplansky.SmoothKernel.SurjectiveFamily | |
| variable {B V W : Type*} [TopologicalSpace B] | |
| [NormedAddCommGroup V] [NormedSpace β V] [FiniteDimensional β V] | |
| [NormedAddCommGroup W] [NormedSpace β W] [FiniteDimensional β W] | |
| local instance : CompleteSpace W := FiniteDimensional.complete β W | |
| variable (A : SurjectiveFamily B V W) | |
| theorem fromModel_center (b : B) (z : KernelModel V W) : | |
| A.fromModel b b z=(A.modelEquiv b z).val := | |
| kernelProjection_fix _ _ _ (A.modelEquiv b z).property | |
| abbrev IncidenceTotal := {z : B Γ V // A.map z.1 z.2=0} | |
| def realization (z : TotalSpace (KernelModel V W) A.realCore.Fiber) : V := | |
| (A.realFiberEquiv z.proj z.2).val | |
| theorem realization_chart (b : B) (z : A.realCore.Fiber b) (i : B) (hi : b β A.baseSet i) : | |
| (A.realFiberEquiv b z).val=A.fromModel i b ((A.realCore.localTriv i β¨b,zβ©).2) := by | |
| change KernelModel V W at z | |
| change (A.modelEquiv b z).val=A.fromModel i b (A.toModel i (A.fromModel b b z)) | |
| rw [A.fromModel_center,A.fromModel_toModel i b hi _ (A.modelEquiv b z).property] | |
| theorem continuous_realization : Continuous A.realization := by | |
| apply continuous_iff_continuousAt.mpr | |
| intro z | |
| let C := A.realCore | |
| let i := z.proj | |
| have hi : z.proj β A.baseSet i := A.center_mem z.proj | |
| have hp : Continuous (Ο (KernelModel V W) C.Fiber) := FiberBundle.continuous_proj _ _ | |
| have hx : z β (C.localTriv i).source := (C.localTriv i).mem_source.mpr hi | |
| have hc := ((C.localTriv i).continuousAt hx).snd | |
| have hf := ((A.continuousOn_fromModel i z.proj hi).continuousAt | |
| ((A.baseSet_open i).mem_nhds hi)).comp hp.continuousAt | |
| apply (hf.clm_apply hc).congr_of_eventuallyEq | |
| filter_upwards [hp.continuousAt ((A.baseSet_open i).mem_nhds hi)] with w hw | |
| exact A.realization_chart w.proj w.2 i hw | |
| def toIncidence (z : TotalSpace (KernelModel V W) A.realCore.Fiber) : A.IncidenceTotal := | |
| β¨(z.proj,A.realization z),(A.realFiberEquiv z.proj z.2).propertyβ© | |
| def fromIncidence (z : A.IncidenceTotal) : TotalSpace (KernelModel V W) A.realCore.Fiber := | |
| β¨z.val.1,(A.realFiberEquiv z.val.1).symm β¨z.val.2,z.propertyβ©β© | |
| theorem fromIncidence_chart (z : A.IncidenceTotal) (i : B) : | |
| ((A.realCore.localTriv i) (A.fromIncidence z)).2=A.toModel i z.val.2 := by | |
| change A.toModel i (A.fromModel z.val.1 z.val.1 | |
| ((A.modelEquiv z.val.1).symm β¨z.val.2,z.propertyβ©))=_ | |
| rw [A.fromModel_center,(A.modelEquiv z.val.1).apply_symm_apply] | |
| theorem continuous_fromIncidence : Continuous A.fromIncidence := by | |
| apply continuous_iff_continuousAt.mpr | |
| intro z | |
| rw [FiberBundle.continuousAt_totalSpace] | |
| have hp : Continuous (fun z : A.IncidenceTotal => z.val.1) := continuous_subtype_val.fst | |
| refine β¨hp.continuousAt,?_β© | |
| let i := z.val.1 | |
| have hc : ContinuousAt (fun w : A.IncidenceTotal => A.toModel i w.val.2) z := | |
| (A.toModel i).continuous.continuousAt.comp continuous_subtype_val.snd.continuousAt | |
| exact hc.congr (Filter.Eventually.of_forall (fun w => (A.fromIncidence_chart w i).symm)) | |
| /-- The constructed smooth real bundle realizes the exact complex kernel | |
| incidence subset, including its ambient subspace topology. -/ | |
| def incidenceHomeomorph : TotalSpace (KernelModel V W) A.realCore.Fiber ββ A.IncidenceTotal where | |
| toFun := A.toIncidence | |
| invFun := A.fromIncidence | |
| left_inv z := by | |
| rcases z with β¨b,vβ© | |
| change (β¨b,(A.realFiberEquiv b).symm (A.realFiberEquiv b v)β© : | |
| TotalSpace (KernelModel V W) A.realCore.Fiber)=β¨b,vβ© | |
| rw [LinearEquiv.symm_apply_apply] | |
| right_inv z := by | |
| apply Subtype.ext | |
| apply Prod.ext | |
| Β· rfl | |
| Β· exact congrArg Subtype.val ((A.realFiberEquiv z.val.1).apply_symm_apply β¨z.val.2,z.propertyβ©) | |
| continuous_toFun := (FiberBundle.continuous_proj _ _).prodMk A.continuous_realization |>.subtype_mk _ | |
| continuous_invFun := A.continuous_fromIncidence | |
| end Kaplansky.SmoothKernel.SurjectiveFamily | |
| end | |
| end OAI | |