File size: 6,385 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
import Mathlib.Algebra.Star.Subalgebra
import Mathlib.Analysis.Complex.Basic
import Mathlib.LinearAlgebra.Matrix.Hermitian
import Mathlib.LinearAlgebra.Matrix.Notation
import Mathlib.Tactic.FinCases

namespace OAI

namespace Generator.MatrixEncoding

/-! Algebraic encoding of four corner operators by two self-adjoint matrices. -/
section
variable {R : Type*} [Ring R] [StarRing R]
local notation "Mat" => Matrix (Fin 2) (Fin 2) R

def E11 : Mat := !![1, 0; 0, 0]
def E12 : Mat := !![0, 1; 0, 0]
def E21 : Mat := !![0, 0; 1, 0]
def E22 : Mat := !![0, 0; 0, 1]
def corner (a : R) : Mat := !![a, 0; 0, 0]
def encodeA (a₁ aβ‚‚ C : R) : Mat := !![a₁, 0; 0, aβ‚‚ + C]
def encodeB (a₃ aβ‚„ : R) : Mat := !![a₃, 1; 1, aβ‚„]

theorem encodeA_selfAdjoint {a₁ aβ‚‚ C : R}
    (h₁ : IsSelfAdjoint a₁) (hβ‚‚ : IsSelfAdjoint aβ‚‚) (hC : IsSelfAdjoint C) :
    IsSelfAdjoint (encodeA a₁ aβ‚‚ C) := by
  apply Matrix.IsHermitian.isSelfAdjoint
  apply Matrix.IsHermitian.ext
  intro i j
  fin_cases i <;> fin_cases j <;>
    simp [encodeA, h₁.star_eq, hβ‚‚.star_eq, hC.star_eq]

theorem encodeB_selfAdjoint {a₃ aβ‚„ : R}
    (h₃ : IsSelfAdjoint a₃) (hβ‚„ : IsSelfAdjoint aβ‚„) :
    IsSelfAdjoint (encodeB a₃ aβ‚„) := by
  apply Matrix.IsHermitian.isSelfAdjoint
  apply Matrix.IsHermitian.ext
  intro i j
  fin_cases i <;> fin_cases j <;> simp [encodeB, h₃.star_eq, hβ‚„.star_eq]

omit [StarRing R] in
theorem complement : (1 : Mat) - E11 = E22 := by
  ext i j
  fin_cases i <;> fin_cases j <;> simp [E11, E22]

theorem star_E12 : star (E12 : Mat) = E21 := by
  ext i j
  fin_cases i <;> fin_cases j <;> simp [E12, E21, Matrix.star_apply]

omit [StarRing R] in
theorem cut_offDiagonal (a₃ aβ‚„ : R) : E11 * encodeB a₃ aβ‚„ * E22 = E12 := by
  ext i j
  fin_cases i <;> fin_cases j <;>
    simp [E11, E12, E22, encodeB, Matrix.mul_apply, Fin.sum_univ_two]

omit [StarRing R] in
theorem cut_a₁ (a₁ aβ‚‚ C : R) : E11 * encodeA a₁ aβ‚‚ C * E11 = corner a₁ := by
  ext i j
  fin_cases i <;> fin_cases j <;>
    simp [E11, encodeA, corner, Matrix.mul_apply, Fin.sum_univ_two]

omit [StarRing R] in
theorem cut_aβ‚‚ (a₁ aβ‚‚ C : R) :
    E12 * encodeA a₁ aβ‚‚ C * E21 - corner C = corner aβ‚‚ := by
  ext i j
  fin_cases i <;> fin_cases j <;>
    simp [E12, E21, encodeA, corner]

omit [StarRing R] in
theorem cut_a₃ (a₃ aβ‚„ : R) : E11 * encodeB a₃ aβ‚„ * E11 = corner a₃ := by
  ext i j
  fin_cases i <;> fin_cases j <;>
    simp [E11, encodeB, corner, Matrix.mul_apply, Fin.sum_univ_two]

omit [StarRing R] in
theorem cut_aβ‚„ (a₃ aβ‚„ : R) : E12 * encodeB a₃ aβ‚„ * E21 = corner aβ‚„ := by
  ext i j
  fin_cases i <;> fin_cases j <;>
    simp [E12, E21, encodeB, corner, Matrix.mul_apply, Fin.sum_univ_two]

omit [StarRing R] in
theorem matrix_reconstruction (X : Mat) :
    X = corner (X 0 0) + corner (X 0 1) * E12 +
      E21 * corner (X 1 0) + E21 * corner (X 1 1) * E12 := by
  ext i j
  fin_cases i <;> fin_cases j <;>
    simp [corner, E12, E21]

variable {π•œ : Type*} [CommRing π•œ] [StarRing π•œ] [Algebra π•œ R] [StarModule π•œ R]

theorem matrix_units_mem (NQ : StarSubalgebra π•œ Mat) {a₃ aβ‚„ : R} (hE : (E11 : Mat) ∈ NQ)
    (hB : encodeB a₃ aβ‚„ ∈ NQ) :
    (E22 : Mat) ∈ NQ ∧ (E12 : Mat) ∈ NQ ∧ (E21 : Mat) ∈ NQ := by
  have h22 : (E22 : Mat) ∈ NQ := (complement (R := R)) β–Έ sub_mem NQ.one_mem hE
  have h12 : (E12 : Mat) ∈ NQ := cut_offDiagonal a₃ aβ‚„ β–Έ
    NQ.mul_mem (NQ.mul_mem hE hB) h22
  exact ⟨h22, h12, (star_E12 (R := R)) β–Έ star_mem h12⟩

theorem encoded_corners_mem (NQ : StarSubalgebra π•œ Mat) {a₁ aβ‚‚ a₃ aβ‚„ C : R}
    (hE : (E11 : Mat) ∈ NQ) (hA : encodeA a₁ aβ‚‚ C ∈ NQ)
    (hB : encodeB a₃ aβ‚„ ∈ NQ) (hC : corner C ∈ NQ) :
    corner a₁ ∈ NQ ∧ corner aβ‚‚ ∈ NQ ∧ corner a₃ ∈ NQ ∧ corner aβ‚„ ∈ NQ := by
  obtain ⟨_, h12, h21⟩ := matrix_units_mem NQ hE hB
  exact ⟨cut_a₁ a₁ aβ‚‚ C β–Έ NQ.mul_mem (NQ.mul_mem hE hA) hE,
    cut_aβ‚‚ a₁ aβ‚‚ C β–Έ sub_mem (NQ.mul_mem (NQ.mul_mem h12 hA) h21) hC,
    cut_a₃ a₃ aβ‚„ β–Έ NQ.mul_mem (NQ.mul_mem hE hB) hE,
    cut_aβ‚„ a₃ aβ‚„ β–Έ NQ.mul_mem (NQ.mul_mem h12 hB) h21⟩

omit [StarRing R] [StarRing π•œ] [StarModule π•œ R] in
theorem corner_algebraMap (c : π•œ) :
    corner (algebraMap π•œ R c) = c β€’ (E11 : Mat) := by
  ext i j
  fin_cases i <;> fin_cases j <;>
    simp [corner, E11, Algebra.algebraMap_eq_smul_one]

/-- The source's shift C 1_N needs no extra corner-membership hypothesis. -/
theorem encoded_corners_mem_scalar (NQ : StarSubalgebra π•œ Mat)
    {a₁ aβ‚‚ a₃ aβ‚„ : R} (C : π•œ)
    (hE : (E11 : Mat) ∈ NQ) (hA : encodeA a₁ aβ‚‚ (algebraMap π•œ R C) ∈ NQ)
    (hB : encodeB a₃ aβ‚„ ∈ NQ) :
    corner a₁ ∈ NQ ∧ corner aβ‚‚ ∈ NQ ∧ corner a₃ ∈ NQ ∧ corner aβ‚„ ∈ NQ := by
  apply encoded_corners_mem NQ hE hA hB
  rw [corner_algebraMap]
  exact NQ.smul_mem hE C

theorem eq_top_of_corner_and_units (NQ : StarSubalgebra π•œ Mat) (hc : βˆ€ a : R, corner a ∈ NQ)
    (h12 : (E12 : Mat) ∈ NQ) (h21 : (E21 : Mat) ∈ NQ) : NQ = ⊀ := by
  apply top_unique
  intro X _
  rw [matrix_reconstruction X]
  exact NQ.add_mem (NQ.add_mem (NQ.add_mem (hc _) (NQ.mul_mem (hc _) h12))
    (NQ.mul_mem h21 (hc _))) (NQ.mul_mem (NQ.mul_mem h21 (hc _)) h12)

end

/-! Algebraic diagonal identities used by the analytic gap recovery. -/
variable {R : Type*} [Ring R] [StarRing R] [Algebra β„‚ R] [StarModule β„‚ R]

omit [StarRing R] [Algebra β„‚ R] [StarModule β„‚ R] in
theorem E22_idempotent : (E22 : Matrix (Fin 2) (Fin 2) R)*E22=E22 := by
  ext i j
  fin_cases i <;> fin_cases j <;> simp [E22]

omit [StarRing R] [Algebra β„‚ R] [StarModule β„‚ R] in
theorem E22_commute_encodeA (a₁ aβ‚‚ : R) : Commute E22 (encodeA a₁ aβ‚‚ 0) := by
  show E22*encodeA a₁ aβ‚‚ 0=encodeA a₁ aβ‚‚ 0*E22
  ext i j
  fin_cases i <;> fin_cases j <;> simp [E22,encodeA]

omit [StarRing R] [StarModule β„‚ R] in
theorem encodeA_scalar_shift (a₁ aβ‚‚ : R) (C : β„‚) :
    encodeA a₁ aβ‚‚ (algebraMap β„‚ R C)=C β€’ E22+encodeA a₁ aβ‚‚ 0 := by
  ext i j
  fin_cases i <;> fin_cases j <;>
    simp [encodeA,E22,Algebra.algebraMap_eq_smul_one,add_comm]

theorem scalar_shift_selfAdjoint (C : ℝ) : IsSelfAdjoint (algebraMap β„‚ R (C : β„‚)) := by
  simp [IsSelfAdjoint,← algebraMap_star_comm]

end Generator.MatrixEncoding

end OAI