File size: 5,326 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
import Mathlib
import OAI.Geometry.Borsuk.MatrixGeometry.MatrixFibre
import OAI.Geometry.Borsuk.Projectors.NegativeQuadratic

namespace OAI

open Set MeasureTheory
namespace BorsukNine
open scoped MatrixOrder RealInnerProductSpace Matrix.Norms.L2Operator
section BlockParts
variable {ΞΌ Ξ½ ΞΉ : Type*} [Fintype ΞΌ] [Fintype Ξ½] [DecidableEq ΞΌ] [DecidableEq Ξ½]
  [Nonempty Ξ½] [Fintype ΞΉ]
local notation "W" => EuclideanSpace ℝ ΞΌ
local notation "E" => EuclideanSpace ℝ Ξ½
local notation "M" => Matrix Ξ½ Ξ½ ℝ
local notation "op" => Matrix.toEuclideanCLM (π•œ := ℝ)

omit [Nonempty Ξ½] in
lemma matrixCompress_rankOne (e : W β†’β‚—α΅’[ℝ] E) {c : E} (he : βˆ€ v, βŸͺc,e v⟫ = 0) :
    matrixCompress e (rankOne c) = 0 := by
  apply (Matrix.toEuclideanCLM (n := ΞΌ) (π•œ := ℝ)).injective
  apply ContinuousLinearMap.ext
  intro v
  change op (matrixCompress e (rankOne c)) v = op (0 : Matrix ΞΌ ΞΌ ℝ) v
  rw [matrixCompress_action,rankOne_action,he,zero_smul,map_zero,map_zero,
    zero_apply]

omit [Nonempty Ξ½] in
lemma blockCorner_rankOne (e : W β†’β‚—α΅’[ℝ] E) {c : E} (he : βˆ€ v, βŸͺc,e v⟫ = 0) :
    blockCorner e (rankOne c) = 0 := by
  rw [blockCorner,matrixCompress_rankOne e he,map_zero]

omit [Nonempty Ξ½] in
lemma block_decomposition {c : E} (e : W β†’β‚—α΅’[ℝ] E) (hc : β€–cβ€– = 1)
    (he : βˆ€ v, βŸͺc,e v⟫ = 0) (hes : βˆ€ u, βŸͺc,u⟫ = 0 β†’ βˆƒ v, e v = u)
    {A : M} (hA : IsSelfAdjoint A) (hb : blockOff c e A = 0) :
    A = blockScalar c A β€’ rankOne c + blockCorner e A := by
  have hAc : op A c = blockScalar c A β€’ c := by
    have hd := frame_decomposition c e hc he hes (op A c)
    change e (blockOff c e A) = op A c - blockScalar c A β€’ c at hd
    rw [hb,map_zero] at hd
    exact sub_eq_zero.mp hd.symm
  have hP := (rankOne_nonneg c).isSelfAdjoint
  have hB : IsSelfAdjoint (A - blockScalar c A β€’ rankOne c) := hA.sub ((IsSelfAdjoint.all _).smul hP)
  have hk : op (A - blockScalar c A β€’ rankOne c) c = 0 := by
    rw [map_sub,sub_apply,map_smul,smul_apply,
      rankOne_action,real_inner_self_eq_norm_sq,hc,one_pow,one_smul,hAc,sub_self]
  have hh := blockCorner_of_kernel e hes hB hk
  have hC : blockCorner e (A - blockScalar c A β€’ rankOne c) = blockCorner e A := by
    simp only [blockCorner,map_sub,map_smul,matrixCompress_rankOne e he,smul_zero,sub_zero]
  rw [hC] at hh
  rw [hh]
  abel

lemma Admissible.signedExtension_nonpos {f : E β†’ ΞΉ β†’ ℝ} (hf : Admissible f)
    {A : M} (hA : IsSelfAdjoint A) (hs : βˆ€ i, signedExtension f A i ≀ 0) : A ≀ 0 := by
  have hp (i : ι) : positiveExtension f A⁺ i = 0 := by
    apply le_antisymm _ (hf.positiveExtension_nonneg A⁺ i)
    apply le_of_not_gt
    intro h
    have hd := hf.positiveExtension_orthogonal (CFC.posPart_nonneg A)
      (CFC.negPart_nonneg A) (CFC.posPart_mul_negPart A) i
    have hn := (mul_eq_zero.mp hd).resolve_left (ne_of_gt h)
    have hh := hs i
    simp only [signedExtension,Pi.sub_apply,hn,sub_zero] at hh
    exact (not_lt_of_ge hh) h
  have hz : A⁺ = 0 := matrix_psd_trace_zero (CFC.posPart_nonneg A) (by
    rw [← hf.positiveExtension_sum (CFC.posPart_nonneg A)]
    simp [hp])
  have he := CFC.posPart_sub_negPart A hA
  rw [hz,zero_sub] at he
  rw [← he]
  exact neg_nonpos.mpr (CFC.negPart_nonneg A)

omit [Nonempty Ξ½] in
lemma block_parts {c : E} (e : W β†’β‚—α΅’[ℝ] E) (hc : β€–cβ€– = 1)
    (he : βˆ€ v, βŸͺc,e v⟫ = 0) (hes : βˆ€ u, βŸͺc,u⟫ = 0 β†’ βˆƒ v, e v = u)
    {A : M} (hA : IsSelfAdjoint A) (hb : blockOff c e A = 0)
    (ha : 0 ≀ blockScalar c A) (hC : blockCorner e A ≀ 0) :
    A⁺ = blockScalar c A β€’ rankOne c ∧ A⁻ = -blockCorner e A := by
  have hk : op (-blockCorner e A) c = 0 := by
    rw [map_neg,neg_apply,blockCorner_kernel e he,neg_zero]
  have hp := rankOne_split_parts (neg_nonneg.mpr hC) hk ha (show (0:ℝ) ≀ 1 by norm_num)
  have heq : A = blockScalar c A β€’ rankOne c - (1:ℝ) β€’ (-blockCorner e A) := by
    rw [one_smul,sub_neg_eq_add]
    exact block_decomposition e hc he hes hA hb
  rw [← heq] at hp
  simpa only [one_smul] using hp

lemma Admissible.block_extension {f : E β†’ ΞΉ β†’ ℝ} (hf : Admissible f)
    {c : E} (e : W β†’β‚—α΅’[ℝ] E) (hc : β€–cβ€– = 1)
    (he : βˆ€ v, βŸͺc,e v⟫ = 0) (hes : βˆ€ u, βŸͺc,u⟫ = 0 β†’ βˆƒ v, e v = u)
    {A : M} (hA : IsSelfAdjoint A) (hb : blockOff c e A = 0)
    (ha : 0 ≀ blockScalar c A) (hC : blockCorner e A ≀ 0) :
    signedExtension f A = blockScalar c A β€’ f c + signedExtension f (blockCorner e A) := by
  obtain ⟨hp,hn⟩ := block_parts e hc he hes hA hb ha hC
  have hCp : (blockCorner e A)⁺ = 0 := (CFC.posPart_eq_zero_iff _ (blockCorner_selfAdjoint e hA)).mpr hC
  have hCn : (blockCorner e A)⁻ = -blockCorner e A := by
    have h := CFC.posPart_sub_negPart (blockCorner e A) (blockCorner_selfAdjoint e hA)
    rw [hCp,zero_sub] at h
    exact (neg_eq_iff_eq_neg.mp h)
  ext i
  simp only [signedExtension,Pi.sub_apply,hp,hn,hCp,hCn,positiveExtension_smul_nonneg f (rankOne_nonneg c) ha,
    hf.positiveExtension_rankOne c hc,Pi.add_apply,Pi.smul_apply,smul_eq_mul]
  have hz : positiveExtension f (0:M) = 0 := by
    simpa only [zero_smul] using positiveExtension_smul_nonneg f (Q := (0:M)) le_rfl (t := 0) le_rfl
  rw [hz]
  simp only [Pi.zero_apply,sub_eq_add_neg,zero_add]
end BlockParts
end BorsukNine

end OAI