File size: 3,984 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
import Mathlib

namespace OAI

noncomputable section
open Filter
open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace

namespace MainGap
variable {A : Type*} [CStarAlgebra A]
variable [PartialOrder A] [StarOrderedRing A]

lemma norm_add_one_of_nonneg [Nontrivial A] {d : A} (hd : 0 ≀ d) :
    β€–d + 1β€– = β€–dβ€– + 1 := by
  apply le_antisymm
  Β· simpa using norm_add_le d 1
  have hh := norm_apply_le_norm_cfc (fun t : ℝ => t + 1) d
    (CStarAlgebra.norm_mem_spectrum_of_nonneg d hd)
  have he : cfc (fun t : ℝ => t + 1) d = d + 1 := by
    rw [cfc_add_const (1 : ℝ) (fun t : ℝ => t) d, cfc_id' ℝ d, map_one]
  simpa only [he, Real.norm_eq_abs, abs_of_nonneg (by positivity : 0 ≀ β€–dβ€– + 1)] using hh

lemma real_norm_one_positive (F : A β†’L[ℝ] ℝ) (hF : β€–Fβ€– ≀ 1) (h1 : F 1 = 1)
    {h : A} (hh : 0 ≀ h) : 0 ≀ F h := by
  have hu : h ≀ algebraMap ℝ A β€–hβ€– :=
    IsSelfAdjoint.le_algebraMap_norm_self h (.of_nonneg hh)
  have hp : 0 ≀ algebraMap ℝ A β€–hβ€– - h := sub_nonneg.mpr hu
  have hb : β€–algebraMap ℝ A β€–hβ€– - hβ€– ≀ β€–hβ€– :=
    (CStarAlgebra.norm_le_iff_le_algebraMap _ (norm_nonneg _) hp).2 (sub_le_self _ hh)
  have he := F.le_opNorm (algebraMap ℝ A β€–hβ€– - h)
  have hx : F (algebraMap ℝ A β€–hβ€– - h) = β€–hβ€– - F h := by
    rw [map_sub, Algebra.algebraMap_eq_smul_one, map_smul, h1, smul_eq_mul, mul_one]
  have : F (algebraMap ℝ A β€–hβ€– - h) ≀ β€–hβ€– :=
    (le_abs_self _).trans (he.trans ((mul_le_mul_of_nonneg_right hF (norm_nonneg _)).trans
      (by simpa using hb)))
  linarith

def realPartCLM : A β†’L[ℝ] A :=
  ((selfAdjoint.submodule ℝ A).subtype.comp (realPart : A β†’β‚—[ℝ] selfAdjoint A)).mkContinuous 1
    (fun a => by
      change β€–(realPart a : A)β€– ≀ 1 * β€–aβ€–
      simpa using realPart.norm_le a)

omit [PartialOrder A] [StarOrderedRing A] in
@[simp] lemma realPartCLM_apply (a : A) : realPartCLM a = (realPart a : A) := rfl

omit [PartialOrder A] [StarOrderedRing A] in
lemma norm_realPartCLM : β€–(realPartCLM : A β†’L[ℝ] A)β€– ≀ 1 := by
  apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one
  intro a
  simpa using realPart.norm_le a

lemma exists_norming_positive [Nontrivial A] {d : A} (hd : 0 ≀ d) :
    βˆƒ f : A β†’β‚š[β„‚] β„‚, (βˆ€ a, β€–f aβ€– ≀ β€–aβ€–) ∧ f d = (β€–dβ€– : β„‚) := by
  obtain ⟨F, hF, hFd⟩ := exists_dual_vector'' ℝ (d + 1)
  have hFa (a : A) : F a ≀ β€–aβ€– :=
    (le_abs_self _).trans ((F.le_opNorm a).trans
      (by simpa using mul_le_mul_of_nonneg_right hF (norm_nonneg a)))
  have h1 : F 1 = 1 := by
    rw [map_add, norm_add_one_of_nonneg hd] at hFd
    simp only [RCLike.ofReal_real_eq_id, id_eq] at hFd
    have h1' := hFa 1
    have hd' := hFa d
    simp only [norm_one] at h1'
    linarith
  have hFd' : F d = β€–dβ€– := by
    rw [map_add, norm_add_one_of_nonneg hd, h1] at hFd
    simpa only [RCLike.ofReal_real_eq_id, id_eq, add_left_inj] using hFd
  let G : A β†’L[ℝ] ℝ := F.comp realPartCLM
  let H : A β†’L[β„‚] β„‚ := StrongDual.extendRCLike G
  have hG : β€–Gβ€– ≀ 1 := (ContinuousLinearMap.opNorm_comp_le _ _).trans
    ((mul_le_mul hF norm_realPartCLM (norm_nonneg _) zero_le_one).trans (by norm_num))
  have hH (a : A) (ha : IsSelfAdjoint a) : H a = (F a : β„‚) := by
    simp [H, StrongDual.extendRCLike_apply, G, ha.coe_realPart, realPart_I_smul,
      ha.imaginaryPart]
  let f : A β†’β‚š[β„‚] β„‚ :=
    { H.toLinearMap with
      monotone' := fun a b hab => by
        have hn : 0 ≀ H (b - a) := by
          rw [hH _ (.of_nonneg (sub_nonneg.mpr hab))]
          exact_mod_cast real_norm_one_positive F hF h1 (sub_nonneg.mpr hab)
        change H a ≀ H b
        simpa only [map_sub, sub_nonneg] using hn }
  refine ⟨f, fun a => ?_, ?_⟩
  Β· change β€–H aβ€– ≀ β€–aβ€–
    exact (H.le_opNorm a).trans (by
      simpa [H] using mul_le_mul_of_nonneg_right hG (norm_nonneg a))
  Β· change H d = _
    rw [hH d (.of_nonneg hd), hFd']
end MainGap

end

end OAI