File size: 6,869 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
import OAI.AlgebraicGeometry.CycleClass.Geometric.ComplexNormalEq
import Mathlib.Analysis.Complex.Basic
import Mathlib.Analysis.Normed.Operator.Prod
import Mathlib.Topology.Algebra.Module.Equiv

/-! # Complex Normal Block -/

namespace OAI.AlgebraicGeometry.CycleClass.Geometric.ComplexNormalBlock.Cycles

noncomputable section

/-!
# The normal block of a tangent-preserving complex linear equivalence

If an ambient continuous linear equivalence and its inverse preserve the
horizontal subspace, its second coordinate descends to a continuous linear
equivalence of the normal factors. No finite-dimensionality or completeness
assumption is needed. The resulting map agrees with the existing construction
of the induced map on the actual quotient by the tangent subspace.
-/

universe uE uF

variable {E : Type uE} [NormedAddCommGroup E] [NormedSpace β„‚ E]
variable {F : Type uF} [NormedAddCommGroup F] [NormedSpace β„‚ F]

/-- The bottom-right continuous linear block of an ambient equivalence. -/
def normalBlockMap (L : (E Γ— F) ≃L[β„‚] (E Γ— F)) : F β†’L[β„‚] F :=
  (ContinuousLinearMap.snd β„‚ E F).comp
    (L.toContinuousLinearMap.comp (ContinuousLinearMap.inr β„‚ E F))

@[simp]
theorem normalBlockMap_apply (L : (E Γ— F) ≃L[β„‚] (E Γ— F)) (y : F) :
    normalBlockMap L y = (L (0, y)).2 :=
  rfl

/-- Preservation of the horizontal subspace makes the second coordinate
depend only on the normal coordinate. -/
theorem normalBlockMap_projection (L : (E Γ— F) ≃L[β„‚] (E Γ— F))
    (hL : βˆ€ x : E, (L (x, 0)).2 = 0) (z : E Γ— F) :
    (L z).2 = normalBlockMap L z.2 := by
  have h := congrArg Prod.snd
    (ContinuousLinearMap.comp_inl_add_comp_inr L.toContinuousLinearMap z)
  change (L (z.1, 0)).2 + (L (0, z.2)).2 = (L z).2 at h
  rw [hL z.1, zero_add] at h
  exact h.symm

/-- The normal block is invertible because the ambient equivalence and its
inverse both preserve the horizontal subspace. Its inverse is the normal
block of the ambient inverse. -/
def normalBlock (L : (E Γ— F) ≃L[β„‚] (E Γ— F))
    (hL : βˆ€ x : E, (L (x, 0)).2 = 0)
    (hLi : βˆ€ x : E, (L.symm (x, 0)).2 = 0) : F ≃L[β„‚] F where
  toFun := normalBlockMap L
  invFun := normalBlockMap L.symm
  left_inv y := by
    change normalBlockMap L.symm (L (0, y)).2 = y
    rw [← normalBlockMap_projection L.symm hLi (L (0, y))]
    exact congrArg Prod.snd (L.symm_apply_apply (0, y))
  right_inv y := by
    change normalBlockMap L (L.symm (0, y)).2 = y
    rw [← normalBlockMap_projection L hL (L.symm (0, y))]
    exact congrArg Prod.snd (L.apply_symm_apply (0, y))
  map_add' := (normalBlockMap L).map_add
  map_smul' := (normalBlockMap L).map_smul
  continuous_toFun := (normalBlockMap L).continuous
  continuous_invFun := (normalBlockMap L.symm).continuous

@[simp]
theorem normalBlock_apply (L : (E Γ— F) ≃L[β„‚] (E Γ— F))
    (hL : βˆ€ x : E, (L (x, 0)).2 = 0)
    (hLi : βˆ€ x : E, (L.symm (x, 0)).2 = 0) (y : F) :
    normalBlock L hL hLi y = (L (0, y)).2 :=
  rfl

@[simp]
theorem normalBlock_symm_apply (L : (E Γ— F) ≃L[β„‚] (E Γ— F))
    (hL : βˆ€ x : E, (L (x, 0)).2 = 0)
    (hLi : βˆ€ x : E, (L.symm (x, 0)).2 = 0) (y : F) :
    (normalBlock L hL hLi).symm y = (L.symm (0, y)).2 :=
  rfl

@[simp]
theorem normalBlock_toContinuousLinearMap (L : (E Γ— F) ≃L[β„‚] (E Γ— F))
    (hL : βˆ€ x : E, (L (x, 0)).2 = 0)
    (hLi : βˆ€ x : E, (L.symm (x, 0)).2 = 0) :
    (normalBlock L hL hLi).toContinuousLinearMap =
      (ContinuousLinearMap.snd β„‚ E F).comp
        (L.toContinuousLinearMap.comp (ContinuousLinearMap.inr β„‚ E F)) :=
  rfl

theorem normalBlock_projection (L : (E Γ— F) ≃L[β„‚] (E Γ— F))
    (hL : βˆ€ x : E, (L (x, 0)).2 = 0)
    (hLi : βˆ€ x : E, (L.symm (x, 0)).2 = 0) (z : E Γ— F) :
    (L z).2 = normalBlock L hL hLi z.2 :=
  normalBlockMap_projection L hL z

/-- The second projection intertwines the ambient and normal equivalences. -/
theorem normalBlock_comp_snd (L : (E Γ— F) ≃L[β„‚] (E Γ— F))
    (hL : βˆ€ x : E, (L (x, 0)).2 = 0)
    (hLi : βˆ€ x : E, (L.symm (x, 0)).2 = 0) :
    (normalBlock L hL hLi).toContinuousLinearMap.comp (ContinuousLinearMap.snd β„‚ E F) =
      (ContinuousLinearMap.snd β„‚ E F).comp L.toContinuousLinearMap := by
  apply ContinuousLinearMap.ext
  intro z
  exact (normalBlock_projection L hL hLi z).symm

@[simp]
theorem normalBlock_symm (L : (E Γ— F) ≃L[β„‚] (E Γ— F))
    (hL : βˆ€ x : E, (L (x, 0)).2 = 0)
    (hLi : βˆ€ x : E, (L.symm (x, 0)).2 = 0) :
    (normalBlock L hL hLi).symm = normalBlock L.symm hLi hL := by
  ext y
  rfl

/-- The two preservation hypotheses give exactly the submodule equality
required by the existing induced normal-quotient equivalence. -/
theorem normalBlock_tangent_map (L : (E Γ— F) ≃L[β„‚] (E Γ— F))
    (hL : βˆ€ x : E, (L (x, 0)).2 = 0)
    (hLi : βˆ€ x : E, (L.symm (x, 0)).2 = 0) :
    (LinearMap.ker (LinearMap.snd β„‚ E F)).map L.toLinearEquiv.toLinearMap =
      LinearMap.ker (LinearMap.snd β„‚ E F) := by
  ext z
  constructor
  · rintro ⟨w, hw, rfl⟩
    change (L w).2 = 0
    rw [normalBlockMap_projection L hL w]
    change w.2 = 0 at hw
    rw [hw, map_zero]
  Β· intro hz
    refine ⟨L.symm z, ?_, L.apply_symm_apply z⟩
    change (L.symm z).2 = 0
    rw [normalBlockMap_projection L.symm hLi z]
    change z.2 = 0 at hz
    rw [hz, map_zero]

/-- Under the native quotient identification with the normal factor, the
existing induced quotient equivalence is exactly the normal block. -/
theorem normalBlock_quotient (L : (E Γ— F) ≃L[β„‚] (E Γ— F))
    (hL : βˆ€ x : E, (L (x, 0)).2 = 0)
    (hLi : βˆ€ x : E, (L.symm (x, 0)).2 = 0)
    (z : ComplexNormalEq.Cycles.ComplexNormal (LinearMap.ker (LinearMap.snd β„‚ E F))) :
    let e := (LinearMap.snd β„‚ E F).quotKerEquivOfSurjective
      (fun y => ⟨(0, y), rfl⟩)
    e (ComplexNormalEq.Cycles.complexNormalEquiv _ _ L.toLinearEquiv (normalBlock_tangent_map L hL hLi) z) =
      normalBlock L hL hLi (e z) := by
  induction z using Submodule.Quotient.induction_on with
  | _ z => exact normalBlock_projection L hL hLi z

/-- The generic quotient comparison specializes to the existing displayed
coordinate-normal equivalence without changing its definition. -/
theorem normalBlock_coordinateNormalEquiv (n p : β„•)
    (L : ((Fin n β†’ β„‚) Γ— (Fin p β†’ β„‚)) ≃L[β„‚] ((Fin n β†’ β„‚) Γ— (Fin p β†’ β„‚)))
    (hL : βˆ€ x : Fin n β†’ β„‚, (L (x, 0)).2 = 0)
    (hLi : βˆ€ x : Fin n β†’ β„‚, (L.symm (x, 0)).2 = 0)
    (z : ComplexNormalEq.Cycles.ComplexNormal (ComplexNormalEq.Cycles.coordinateTangent n p)) :
    ComplexNormalEq.Cycles.coordinateNormalEquiv n p
        (ComplexNormalEq.Cycles.complexNormalEquiv _ _ L.toLinearEquiv (normalBlock_tangent_map L hL hLi) z) =
      normalBlock L hL hLi (ComplexNormalEq.Cycles.coordinateNormalEquiv n p z) :=
  normalBlock_quotient L hL hLi z

end

end OAI.AlgebraicGeometry.CycleClass.Geometric.ComplexNormalBlock.Cycles