File size: 5,253 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
import OAI.Geometry.Kakeya.Quadratic.Lift
import Mathlib.Analysis.Normed.Module.FiniteDimension
import Mathlib.Analysis.Normed.Group.Quotient

/-! A coordinate-free construction of the sharp quadratic compression.
It replaces the nilpotent Jordan-block computation by quotient maps. -/

open Set Module LinearMap
open scoped Topology ContDiff

noncomputable section
namespace OAI.Geometry.Kakeya.Quadratic

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [FiniteDimensional ℝ E]

def compressionSubspace (B : E β†’β‚—[ℝ] E) : Submodule ℝ E := B.ker βŠ” B.range

abbrev CompressionSpace (B : E β†’β‚—[ℝ] E) := E β§Έ compressionSubspace B

theorem finrank_compressionSpace (B : E β†’β‚—[ℝ] E) :
    finrank ℝ (CompressionSpace B) = finrank ℝ B.range - finrank ℝ (B.comp B).range := by
  have h₁ := B.finrank_range_add_finrank_ker
  have hβ‚‚ := (B.comp B.range.subtype).finrank_range_add_finrank_ker
  rw [range_restricted, (restrictedKerEquiv B).finrank_eq] at hβ‚‚
  have h₃ := Submodule.finrank_sup_add_finrank_inf_eq B.ker B.range
  have hβ‚„ := Submodule.finrank_quotient_add_finrank (compressionSubspace B)
  change finrank ℝ (CompressionSpace B) + finrank ℝ (B.ker βŠ” B.range : Submodule ℝ E) = _ at hβ‚„
  omega

omit [FiniteDimensional ℝ E] in
theorem compression_quotient_B (B : E β†’β‚—[ℝ] E) (x : E) :
    (compressionSubspace B).mkQ (B x) = 0 := by
  apply (Submodule.Quotient.mk_eq_zero _).mpr
  exact (show B.range ≀ compressionSubspace B from le_sup_right) (mem_range_self B x)

/-- There is P with P B = Q, where Q is the quotient by ker B + range B. -/
theorem exists_compression_first (B : E β†’β‚—[ℝ] E) :
    βˆƒ P : E β†’β‚—[ℝ] CompressionSpace B,
      P.comp B = (compressionSubspace B).mkQ := by
  let Q := (compressionSubspace B).mkQ
  obtain ⟨r, hr⟩ := B.rangeRestrict.exists_rightInverse_of_surjective B.range_rangeRestrict
  obtain ⟨P, hP⟩ := (Q.comp r).exists_extend
  refine ⟨P, ?_⟩
  ext x
  have hPr : P (B x) = Q (r (B.rangeRestrict x)) :=
    congrArg (fun f : B.range β†’β‚—[ℝ] CompressionSpace B => f (B.rangeRestrict x)) hP
  rw [LinearMap.comp_apply, hPr]
  apply sub_eq_zero.mp
  rw [← map_sub]
  apply (Submodule.Quotient.mk_eq_zero _).mpr
  apply (show B.ker ≀ compressionSubspace B from le_sup_left)
  change B (r (B.rangeRestrict x) - x) = 0
  rw [map_sub]
  apply sub_eq_zero.mpr
  exact congrArg (fun f : B.range β†’β‚—[ℝ] B.range => (f (B.rangeRestrict x) : E)) hr

omit [FiniteDimensional ℝ E] in
/-- The two row families are jointly independent. -/
theorem compression_pair_surjective (B : E β†’β‚—[ℝ] E)
    (P : E β†’β‚—[ℝ] CompressionSpace B) (hP : P.comp B = (compressionSubspace B).mkQ) :
    Function.Surjective (P.prod (compressionSubspace B).mkQ) := by
  rintro ⟨a, b⟩
  obtain ⟨x, hx⟩ := (compressionSubspace B).mkQ_surjective b
  obtain ⟨y, hy⟩ := (compressionSubspace B).mkQ_surjective (a - P x)
  refine ⟨x + B y, ?_⟩
  apply Prod.ext
  Β· change P (x + B y) = a
    have hPy : P (B y) = (compressionSubspace B).mkQ y :=
      congrArg (fun f : E β†’β‚—[ℝ] CompressionSpace B => f y) hP
    rw [map_add, hPy, hy]
    abel
  Β· change (compressionSubspace B).mkQ (x + B y) = b
    rw [map_add, compression_quotient_B, add_zero, hx]

/-- The sharp compression maps, constructed for every real linear B. -/
theorem exists_compression_maps (B : E β†’β‚—[ℝ] E) :
    βˆƒ (P : E β†’β‚—[ℝ] CompressionSpace B) (C : E β†’β‚—[ℝ] E),
      P.comp B = (compressionSubspace B).mkQ ∧
      P.comp C = 0 ∧ (compressionSubspace B).mkQ.comp C = P ∧
      Function.Surjective (P.prod (compressionSubspace B).mkQ) := by
  obtain ⟨P, hP⟩ := exists_compression_first B
  have hsur := compression_pair_surjective B P hP
  obtain ⟨R, hR⟩ := (P.prod (compressionSubspace B).mkQ).exists_rightInverse_of_surjective
    (LinearMap.range_eq_top.mpr hsur)
  let C : E β†’β‚—[ℝ] E := R.comp ((0 : E β†’β‚—[ℝ] CompressionSpace B).prod P)
  refine ⟨P, C, hP, ?_, ?_, hsur⟩
  Β· ext x
    exact congrArg (fun f : CompressionSpace B Γ— CompressionSpace B β†’β‚—[ℝ]
      CompressionSpace B Γ— CompressionSpace B => (f (0, P x)).1) hR
  Β· ext x
    exact congrArg (fun f : CompressionSpace B Γ— CompressionSpace B β†’β‚—[ℝ]
      CompressionSpace B Γ— CompressionSpace B => (f (0, P x)).2) hR

omit [FiniteDimensional ℝ E] in
/-- Every curve in the explicit compact example lies in the ruled
codimension-d set P(x)=t Q(x). -/
theorem compressed_curve_equation (B : E β†’β‚—[ℝ] E)
    (P : E β†’β‚—[ℝ] CompressionSpace B) (C : E β†’β‚—[ℝ] E)
    (hPB : P.comp B = (compressionSubspace B).mkQ)
    (hPC : P.comp C = 0) (hQC : (compressionSubspace B).mkQ.comp C = P)
    (y : E) (t : ℝ) :
    P (curve B y (C y) t).1 = t β€’ (compressionSubspace B).mkQ (curve B y (C y) t).1 := by
  have h₁ : P (B y) = (compressionSubspace B).mkQ y := congrArg (fun f => f y) hPB
  have hβ‚‚ : P (C y) = 0 := congrArg (fun f => f y) hPC
  have h₃ : (compressionSubspace B).mkQ (C y) = P y := congrArg (fun f => f y) hQC
  simp only [curve, map_add, map_smul, h₁, hβ‚‚, h₃, compression_quotient_B,
    smul_zero, zero_add, add_zero, smul_add, smul_smul, pow_two]

end OAI.Geometry.Kakeya.Quadratic