File size: 12,321 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
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.Types
import OAI.Algorithms.SubexponentialSAT.RowInterpolation
import OAI.Algorithms.SubexponentialSAT.MatrixSupport
import OAI.Algorithms.SubexponentialSAT.SubspaceDimension

namespace OAI.Algorithms

/-!
# Annihilation of the incidence-specific row paths

Section 5.3 is a finite linear-algebra statement once the row evaluations and
matrix support property are known.  This file proves that statement for actual
matrices and vectors, and specializes it to the universal type block.  It does
not assume the annihilation conclusion as a hypothesis.
-/

namespace SubexponentialSAT.Annihilation

open scoped BigOperators
open Matrix

variable {V K : Type*} [Fintype V] [DecidableEq V] [Ring K]

/-- Extend a row indexed by a subset by zero on its complement. -/
noncomputable def extendRow (J : Set V) (m : J β†’ K) : V β†’ K := by
  classical
  exact fun y => if hy : y ∈ J then m ⟨y, hy⟩ else 0

omit [Fintype V] [DecidableEq V] in
@[simp] theorem extendRow_mem (J : Set V) (m : J β†’ K) (y : J) :
    extendRow J m y = m y := by
  classical
  simp [extendRow, y.property]

omit [Fintype V] [DecidableEq V] in
@[simp] theorem extendRow_not_mem (J : Set V) (m : J β†’ K)
    (y : V) (hy : y βˆ‰ J) : extendRow J m y = 0 := by
  classical
  simp [extendRow, hy]

omit [DecidableEq V] in
/-- Zero extension preserves the sum pairing with a restricted vector. -/
theorem extendRow_dotProduct (J : Set V) [Fintype J] (m : J β†’ K) (r : V β†’ K) :
    extendRow J m ⬝α΅₯ r = m ⬝α΅₯ (fun y : J => r y) := by
  classical
  change (βˆ‘ y : V, extendRow J m y * r y) = βˆ‘ y : J, m y * r y
  calc
    (βˆ‘ y : V, extendRow J m y * r y) =
        βˆ‘ y ∈ J.toFinset, extendRow J m y * r y := by
      symm
      apply Finset.sum_subset (Finset.subset_univ _)
      intro y _ hy
      have hyJ : y βˆ‰ J := by simpa using hy
      simp [extendRow, hyJ]
    _ = βˆ‘ y : J, extendRow J m y * r y :=
      Finset.sum_subtype J.toFinset (fun _ => Set.mem_toFinset) _
    _ = βˆ‘ y : J, m y * r y := by
      apply Finset.sum_congr rfl
      intro y _
      simp

omit [Fintype V] [DecidableEq V] in
/-- A row supported on `Y` stays supported on `Y` after zero extension. -/
theorem extendRow_eq_zero_outside (J : Set V) (Y : Finset V) (m : J β†’ K)
    (hm : βˆ€ y : J, (y : V) βˆ‰ Y β†’ m y = 0)
    (y : V) (hy : y βˆ‰ Y) : extendRow J m y = 0 := by
  classical
  by_cases hj : y ∈ J
  · simp [extendRow, hj, hm ⟨y, hj⟩ hy]
  Β· simp [extendRow, hj]

/-- If the selected coordinate is off the active side, all terms vanish.
Only correction values on the active side and inside `Y` need to be specified. -/
theorem annihilates_of_head_outside (S : Set V) (Y : Finset V)
    (u : V) (c r : V β†’ K)
    (hu : u βˆ‰ S)
    (hr : βˆ€ y, y βˆ‰ S β†’ r y = 0)
    (hc : βˆ€ y, y βˆ‰ Y β†’ c y = 0)
    (hcS : βˆ€ y, y ∈ S β†’ y ∈ Y β†’ c y = 0) :
    (Pi.single u 1 + c) ⬝α΅₯ r = 0 := by
  rw [add_dotProduct, single_dotProduct, one_mul, hr u hu, zero_add]
  apply Finset.sum_eq_zero
  intro y _
  by_cases hyS : y ∈ S
  · by_cases hyY : y ∈ Y
    Β· rw [hcS y hyS hyY, zero_mul]
    Β· rw [hc y hyY, zero_mul]
  Β· rw [hr y hyS, mul_zero]

/-- On the active side, the correction agrees with a negative matrix row.
The support hypothesis supplies all omitted correction coordinates. -/
theorem annihilates_of_head_inside (S J : Set V) (Y : Finset V)
    [Fintype J] (M : Matrix J J K) (u : J) (c r : V β†’ K)
    (hr : βˆ€ y, y βˆ‰ S β†’ r y = 0)
    (hc : βˆ€ y, y βˆ‰ Y β†’ c y = 0)
    (hm : βˆ€ y : J, (y : V) βˆ‰ Y β†’ M u y = 0)
    (hcS : βˆ€ y, y ∈ S β†’ y ∈ Y β†’ c y = -extendRow J (M u) y)
    (hfix : M *α΅₯ (fun y : J => r y) = fun y : J => r y) :
    (Pi.single (u : V) 1 + c) ⬝α΅₯ r = 0 := by
  classical
  have hpair : c ⬝α΅₯ r = (-extendRow J (M u)) ⬝α΅₯ r := by
    apply Finset.sum_congr rfl
    intro y _
    by_cases hyS : y ∈ S
    · by_cases hyY : y ∈ Y
      Β· rw [hcS y hyS hyY]
        rfl
      Β· simp only [hc y hyY, Pi.neg_apply,
          extendRow_eq_zero_outside J Y (M u) hm y hyY, neg_zero, zero_mul]
    Β· rw [hr y hyS]
      simp
  rw [add_dotProduct, single_dotProduct, one_mul, hpair, neg_dotProduct,
    extendRow_dotProduct]
  have huFix := congrFun hfix u
  change r u + -(M *α΅₯ (fun y : J => r y)) u = 0
  rw [huFix, add_neg_cancel]

section TypeBlock

open _root_.OAI.Algorithms.SubexponentialSAT.Types

variable {Q Ξ” : β„•}

/-- The two head cases of Section 5.3 for the actual universal type indices.
The matrix support implication and interpolated correction values remain
explicit hypotheses; the conclusion is the required row annihilation. -/
theorem typeBlock_annihilation
    (t : Fin Q) (i : Fin Ξ”) (u : UniversalType Q Ξ”)
    (Y : Finset (UniversalType Q Ξ”))
    (M : Matrix (Joint t (u.slot i t) i) (Joint t (u.slot i t) i) K)
    (c r : UniversalType Q Ξ” β†’ K)
    (hr : βˆ€ y, y.head t β‰  u.slot i t β†’ r y = 0)
    (hc : βˆ€ y, y βˆ‰ Y β†’ c y = 0)
    (hm : βˆ€ (hu : u.head t = u.slot i t) (y : Joint t (u.slot i t) i),
      M ⟨u, hu, rfl⟩ y β‰  0 β†’ (y : UniversalType Q Ξ”) ∈ Y)
    (hcEval : βˆ€ y, y ∈ Y β†’ y.head t = u.slot i t β†’
      c y = if hu : u.head t = u.slot i t then
        -extendRow (joint t (u.slot i t) i) (M ⟨u, hu, rfl⟩) y else 0)
    (hfix : M *α΅₯ (fun y : Joint t (u.slot i t) i => r y) =
      fun y : Joint t (u.slot i t) i => r y) :
    (Pi.single u 1 + c) ⬝α΅₯ r = 0 := by
  classical
  by_cases hu : u.head t = u.slot i t
  Β· apply annihilates_of_head_inside
      (side t (u.slot i t)) (joint t (u.slot i t) i) Y M ⟨u, hu, rfl⟩ c r
      hr hc ?_ ?_ hfix
    Β· intro y hy
      by_contra hne
      exact hy (hm hu y hne)
    Β· intro y hyS hyY
      simpa only [dite_eq_left hu] using hcEval y hyY hyS
  Β· apply annihilates_of_head_outside (side t (u.slot i t)) Y u c r
      hu hr hc
    intro y hyS hyY
    simpa only [dite_eq_right hu] using hcEval y hyY hyS

end TypeBlock

section ScalarExtension

variable {L J : Type*} [Ring L] [Fintype J]

/-- A fixed-vector equation survives a coefficient ring homomorphism. No
injectivity or extra equations on the original vector are needed. -/
theorem map_fixedVector (Ο† : K β†’+* L) (M : Matrix J J K) (r : J β†’ K)
    (hfix : M *α΅₯ r = r) : M.map Ο† *α΅₯ (Ο† ∘ r) = Ο† ∘ r := by
  funext j
  calc
    (M.map Ο† *α΅₯ (Ο† ∘ r)) j = Ο† ((M *α΅₯ r) j) :=
      (Ο†.map_mulVec M r j).symm
    _ = Ο† (r j) := congrArg Ο† (congrFun hfix j)

end ScalarExtension

section UniversalPolynomial

open _root_.OAI.Algorithms.SubexponentialSAT.Types

variable {F E : Type*} [Field F] [Field E] {Q Ξ” : β„•}

/-- The prescribed values of the correction polynomials from Section 5.3.
The matrix is the actual projector construction, over the base field `F`.
The homomorphism permits the interpolation polynomial to live over `E`. -/
noncomputable def universalPrescription (Ο† : F β†’+* E)
    (u : UniversalType Q Ξ”) (i : Fin Ξ”) (R : β„•) (coeff : β„• β†’ F)
    (y : UniversalType Q Ξ”) (t : Fin Q) : E := by
  classical
  exact if hu : u.head t = u.slot i t then
    -extendRow (joint t (u.slot i t) i)
      (fun z => Ο† (MatrixSupport.jointMatrix i t (u.slot i t) R coeff
        ⟨u, hu, rfl⟩ z)) y
  else 0

/-- The actual incidence row polynomial on the universal type block. -/
noncomputable def universalRow (Ο† : F β†’+* E)
    (u : UniversalType Q Ξ”) (i : Fin Ξ”) (R : β„•) (coeff : β„• β†’ F)
    (nodes : Fin Q β†’ E) (hinj : Function.Injective nodes)
    (hne : βˆ€ t, nodes t β‰  0) : UniversalType Q Ξ” β†’ Polynomial E :=
  RowInterpolation.universalRowPath u i R nodes hinj hne
    (universalPrescription Ο† u i R coeff)

/-- The row starts at the coordinate-selection row, including its diagonal. -/
theorem universalRow_origin (Ο† : F β†’+* E)
    (u : UniversalType Q Ξ”) (i : Fin Ξ”) (R : β„•) (coeff : β„• β†’ F)
    (nodes : Fin Q β†’ E) (hinj : Function.Injective nodes)
    (hne : βˆ€ t, nodes t β‰  0) :
    (fun y => (universalRow Ο† u i R coeff nodes hinj hne y).eval 0) =
      Pi.single u (1 : E) :=
  RowInterpolation.universalRowPath_eval_zero u i R nodes hinj hne _

/-- At most R interpolation constraints are imposed on each correction. -/
theorem universalRow_degree (Ο† : F β†’+* E)
    (u : UniversalType Q Ξ”) (i : Fin Ξ”) (R : β„•) (coeff : β„• β†’ F)
    (nodes : Fin Q β†’ E) (hinj : Function.Injective nodes)
    (hne : βˆ€ t, nodes t β‰  0) (y : UniversalType Q Ξ”) :
    (universalRow Ο† u i R coeff nodes hinj hne y).natDegree ≀ R :=
  RowInterpolation.universalRowPath_natDegree_le u i R nodes hinj hne _ y

/-- Concrete row annihilation from support and the selected slot's fixed-vector
equation. The matrix support theorem discharges the Y-sparsity obligation. -/
theorem universalRow_annihilates_of_fixed (Ο† : F β†’+* E)
    (u : UniversalType Q Ξ”) (i : Fin Ξ”) (R : β„•) (coeff : β„• β†’ F)
    (nodes : Fin Q β†’ E) (hinj : Function.Injective nodes)
    (hne : βˆ€ t, nodes t β‰  0) (t : Fin Q) (r : UniversalType Q Ξ” β†’ F)
    (hr : βˆ€ y, y.head t β‰  u.slot i t β†’ r y = 0)
    (hfix : MatrixSupport.jointMatrix i t (u.slot i t) R coeff *α΅₯
      (fun y : Joint t (u.slot i t) i => r y) =
      fun y : Joint t (u.slot i t) i => r y) :
    (fun y => (universalRow Ο† u i R coeff nodes hinj hne y).eval (nodes t))
      ⬝α΅₯ (fun y => Ο† (r y)) = 0 := by
  classical
  unfold universalRow RowInterpolation.universalRowPath
  rw [RowInterpolation.eval_rowPath]
  apply typeBlock_annihilation t i u
    (RowInterpolation.correctionColumns (u.slot i) R)
    ((MatrixSupport.jointMatrix i t (u.slot i t) R coeff).map Ο†)
  Β· intro y hy
    simp only [hr y hy, map_zero]
  Β· intro y hy
    rw [RowInterpolation.universalCorrection_of_not_mem _ _ _ _ _ _ _ hy]
    simp
  Β· intro hu y hneM
    apply (RowInterpolation.mem_correctionColumns (u.slot i) R y.val).mpr
    have hbase : MatrixSupport.jointMatrix i t (u.slot i t) R coeff
        ⟨u, hu, rfl⟩ y β‰  0 := by
      intro hz
      apply hneM
      simp only [Matrix.map_apply, hz, map_zero]
    exact MatrixSupport.jointMatrix_support i t (u.slot i t) R coeff
      ⟨u, hu, rfl⟩ y hbase
  Β· intro y hy hyt
    rw [RowInterpolation.universalCorrection_eval_node _ _ _ _ _ _ y
      ((RowInterpolation.mem_correctionColumns (u.slot i) R y).mp hy) t hyt]
    rfl
  Β· exact map_fixedVector Ο† _ _ hfix

/-- The full base-field subspace, imposing every slot's fixed-vector equation. -/
noncomputable def universalSpace (R : β„•) (coeff : β„• β†’ F)
    (t : Fin Q) (g : Bool) : Submodule F (UniversalType Q Ξ” β†’ F) :=
  SubspaceDimension.universalFixedSpace t g
    (fun i => (MatrixSupport.jointMatrix i t g R coeff).mulVecLin)

/-- Membership exposes the concrete support and matrix equations. -/
theorem mem_universalSpace (R : β„•) (coeff : β„• β†’ F)
    (t : Fin Q) (g : Bool) (r : UniversalType Q Ξ” β†’ F) :
    r ∈ universalSpace R coeff t g ↔
      (βˆ€ y, y.head t β‰  g β†’ r y = 0) ∧
      βˆ€ i : Fin Ξ”, MatrixSupport.jointMatrix i t g R coeff *α΅₯
        (fun y : Joint t g i => r y.val) = fun y : Joint t g i => r y.val := by
  rw [universalSpace, SubspaceDimension.universalFixedSpace_mem_iff]
  constructor
  · rintro ⟨hs, hf⟩
    exact ⟨fun y hy => hs y hy, fun i => (hf i).symm⟩
  · rintro ⟨hs, hf⟩
    exact ⟨fun y hy => hs y hy, fun i => (hf i).symm⟩

/-- Section 5.3, instantiated to the actual matrix, actual interpolated row,
and actual base-field fixed subspace. No annihilation or support hypothesis
remains: only membership in that independently defined subspace is required. -/
theorem universalRow_annihilates (Ο† : F β†’+* E)
    (u : UniversalType Q Ξ”) (i : Fin Ξ”) (R : β„•) (coeff : β„• β†’ F)
    (nodes : Fin Q β†’ E) (hinj : Function.Injective nodes)
    (hne : βˆ€ t, nodes t β‰  0) (t : Fin Q) (r : UniversalType Q Ξ” β†’ F)
    (hr : r ∈ universalSpace R coeff t (u.slot i t)) :
    (fun y => (universalRow Ο† u i R coeff nodes hinj hne y).eval (nodes t))
      ⬝α΅₯ (fun y => Ο† (r y)) = 0 := by
  have h := (mem_universalSpace R coeff t (u.slot i t) r).mp hr
  exact universalRow_annihilates_of_fixed Ο† u i R coeff nodes hinj hne t r h.1 (h.2 i)

end UniversalPolynomial

end SubexponentialSAT.Annihilation

end OAI.Algorithms