lean/OAI/Geometry/ComplexBundle/Kernel.lean

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