File size: 11,394 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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.BinomialMatrix
import OAI.Algorithms.SubexponentialSAT.MatrixSupport

namespace OAI.Algorithms

/-!
# Interpolation at consecutive integer weights

The coefficient construction uses the inverse of an actual finite matrix.
It applies over any commutative ring whose evaluation matrix has unit determinant.
The binomial evaluation matrix has determinant one, including in small characteristic.
-/

namespace SubexponentialSAT.BinomialInterpolation

open scoped BigOperators
open Matrix

noncomputable section

variable {K : Type*} [CommRing K] {n : Type*} [Fintype n] [DecidableEq n]

/-- The coefficients solving a square interpolation system. -/
def coefficients (M : Matrix n n K) (target : n → K) : n → K :=
  M⁻¹ *ᵥ target

/-- Inverting a matrix with unit determinant realizes any prescribed target. -/
theorem mulVec_coefficients (M : Matrix n n K) (hM : IsUnit M.det)
    (target : n → K) : M *ᵥ coefficients M target = target := by
  rw [coefficients, Matrix.mulVec_mulVec, Matrix.mul_nonsing_inv M hM,
    Matrix.one_mulVec]

/-- The coefficient vector is the unique solution of the interpolation system. -/
theorem coefficients_unique (M : Matrix n n K) (hM : IsUnit M.det)
    (target c : n → K) (hc : M *ᵥ c = target) : c = coefficients M target := by
  calc
    c = M⁻¹ *ᵥ (M *ᵥ c) := by
      rw [Matrix.mulVec_mulVec, Matrix.nonsing_inv_mul M hM, Matrix.one_mulVec]
    _ = coefficients M target := by rw [hc, coefficients]

theorem existsUnique_mulVec_eq (M : Matrix n n K) (hM : IsUnit M.det)
    (target : n → K) : ∃! c : n → K, M *ᵥ c = target := by
  exact ⟨coefficients M target, mulVec_coefficients M hM target,
    fun c hc => coefficients_unique M hM target c hc⟩

/-- The determinant-one binomial matrix is invertible in every characteristic. -/
theorem isUnit_det_binomial (A R : ℕ) :
    IsUnit (BinomialMatrix.B K A R).det := by
  rw [BinomialMatrix.det_B]
  exact isUnit_one

/-- Coefficients realizing a target on the consecutive integer weights
`A, ..., A + R - 1`. These are integer binomial evaluations, not ordinary
univariate evaluations at the residues of these weights. -/
def binomialCoefficients (A R : ℕ) (target : Fin R → K) : Fin R → K :=
  coefficients (BinomialMatrix.B K A R) target

theorem binomialCoefficients_spec (A R : ℕ) (target : Fin R → K) (d : Fin R) :
    ∑ j : Fin R, binomialCoefficients A R target j *
      ((A + d.val).choose j.val : K) = target d := by
  have h := congrFun
    (mulVec_coefficients (BinomialMatrix.B K A R) (isUnit_det_binomial A R) target) d
  simpa only [binomialCoefficients, Matrix.mulVec, dotProduct,
    BinomialMatrix.B_apply, mul_comm] using h

/-- Arbitrary target values admit a unique binomial-basis coefficient vector. -/
theorem existsUnique_binomial_interpolation (A R : ℕ) (target : Fin R → K) :
    ∃! c : Fin R → K, ∀ d : Fin R,
      ∑ j : Fin R, c j * ((A + d.val).choose j.val : K) = target d := by
  refine ⟨binomialCoefficients A R target, binomialCoefficients_spec A R target, ?_⟩
  intro c hc
  apply coefficients_unique (BinomialMatrix.B K A R) (isUnit_det_binomial A R) target c
  funext d
  simpa only [Matrix.mulVec, dotProduct, BinomialMatrix.B_apply, mul_comm] using hc d

/-- The coefficient vector used for the alternating target in equation (5.3). -/
def parityCoefficients (A R : ℕ) : Fin R → K :=
  binomialCoefficients A R (fun d => (-1 : K) ^ (A + d.val))

theorem parityCoefficients_spec (A R : ℕ) (d : Fin R) :
    ∑ j : Fin R, parityCoefficients (K := K) A R j *
      ((A + d.val).choose j.val : K) = (-1 : K) ^ (A + d.val) :=
  binomialCoefficients_spec A R (fun d => (-1 : K) ^ (A + d.val)) d

/-- The scalar eigenvalue of the corrected permutation product. -/
def spectralValue {R : ℕ} (c : Fin R → K) (w : ℕ) : K :=
  (-1 : K) ^ w * ∑ j : Fin R, c j * (w.choose j.val : K)

theorem spectralValue_parity (A R : ℕ) (d : Fin R) :
    spectralValue (parityCoefficients (K := K) A R) (A + d.val) = 1 := by
  rw [spectralValue, parityCoefficients_spec, ← mul_pow]
  simp

/-- The corrected eigenvalue equals one at every integer weight in the chosen interval. -/
theorem spectralValue_parity_of_mem (A R w : ℕ) (hA : A ≤ w) (hR : w < A + R) :
    spectralValue (parityCoefficients (K := K) A R) w = 1 := by
  let d : Fin R := ⟨w - A, Nat.sub_lt_right_of_lt_add hA (by simpa [Nat.add_comm] using hR)⟩
  have hd : A + d.val = w := Nat.add_sub_of_le hA
  simpa only [hd] using spectralValue_parity (K := K) A R d

/-- Extend a finite coefficient vector by zero outside its specified range. -/
def extendCoefficients {R : ℕ} (c : Fin R → K) (j : ℕ) : K :=
  if h : j < R then c ⟨j, h⟩ else 0

@[simp] theorem extendCoefficients_fin {R : ℕ} (c : Fin R → K) (j : Fin R) :
    extendCoefficients c j.val = c j := by
  simp [extendCoefficients, j.isLt]

theorem extendCoefficients_eq_zero {R : ℕ} (c : Fin R → K) (j : ℕ) (hj : R ≤ j) :
    extendCoefficients c j = 0 := by
  simp [extendCoefficients, Nat.not_lt.mpr hj]

/-- The zero extension connects finite-vector sums to the matrix construction's
natural-number-indexed sum over `range R`. -/
theorem sum_range_extendCoefficients {R : ℕ} (c : Fin R → K) (w : ℕ) :
    (∑ j ∈ Finset.range R, extendCoefficients c j * (w.choose j : K)) =
      ∑ j : Fin R, c j * (w.choose j.val : K) := by
  simpa only [extendCoefficients_fin] using
    (Fin.sum_univ_eq_sum_range
      (fun j : ℕ => extendCoefficients c j * (w.choose j : K)) R).symm

theorem sum_range_extend_parity (A R : ℕ) (d : Fin R) :
    (∑ j ∈ Finset.range R, extendCoefficients (parityCoefficients (K := K) A R) j *
      ((A + d.val).choose j : K)) = (-1 : K) ^ (A + d.val) := by
  rw [sum_range_extendCoefficients, parityCoefficients_spec]

theorem sum_range_extend_parity_of_mem (A R w : ℕ) (hA : A ≤ w) (hR : w < A + R) :
    (∑ j ∈ Finset.range R, extendCoefficients (parityCoefficients (K := K) A R) j *
      (w.choose j : K)) = (-1 : K) ^ w := by
  let d : Fin R := ⟨w - A, Nat.sub_lt_right_of_lt_add hA (by simpa [Nat.add_comm] using hR)⟩
  have hd : A + d.val = w := Nat.add_sub_of_le hA
  simpa only [hd] using sum_range_extend_parity (K := K) A R d

section ElementarySymmetric

variable {S : Type*} [CommSemiring S]

omit [Fintype n] in
/-- The elementary symmetric sum of an indicator is the binomial coefficient
in the integer size of its support. The ambient set may be larger than the support. -/
theorem sum_powersetCard_prod_indicator (active ones : Finset n)
    (hsubset : ones ⊆ active) (j : ℕ) :
    (∑ t ∈ active.powersetCard j, ∏ i ∈ t, if i ∈ ones then (1 : S) else 0) =
      (ones.card.choose j : S) := by
  classical
  have hfilter :
      (active.powersetCard j).filter
          (fun t => t ⊆ ones) = ones.powersetCard j := by
    ext t
    simp only [Finset.mem_filter, Finset.mem_powersetCard]
    constructor
    · rintro ⟨⟨_, hcard⟩, hto⟩
      exact ⟨hto, hcard⟩
    · rintro ⟨hto, hcard⟩
      exact ⟨⟨Finset.Subset.trans hto hsubset, hcard⟩, hto⟩
  simp only [Finset.prod_boole]
  trans ∑ t ∈ active.powersetCard j,
    if t ⊆ ones then (1 : S) else 0
  · apply Finset.sum_congr rfl
    intro t _
    by_cases h : t ⊆ ones
    · have h' : ∀ i ∈ t, i ∈ ones := fun i hi => h hi
      rw [ite_eq_left h', ite_eq_left h]
    · have h' : ¬(∀ i ∈ t, i ∈ ones) := fun h' => h (fun i hi => h' i hi)
      rw [ite_eq_right h', ite_eq_right h]
  · rw [Finset.sum_boole, hfilter, Finset.card_powersetCard]

/-- Evaluating the actual elementary symmetric polynomial on an indicator
vector counts subsets of its support, with no division by factorials. -/
theorem eval_esymm_indicator (ones : Finset n) (j : ℕ) :
    MvPolynomial.eval (fun i => if i ∈ ones then (1 : S) else 0)
      (MvPolynomial.esymm n S j) = (ones.card.choose j : S) := by
  classical
  simp only [MvPolynomial.esymm, MvPolynomial.eval_sum,
    MvPolynomial.eval_prod, MvPolynomial.eval_X]
  exact sum_powersetCard_prod_indicator Finset.univ ones (Finset.subset_univ ones) j

/-- The elementary symmetric value of a zero-one vector is a binomial
coefficient in the integer number of ones, subsequently cast to the ring. -/
theorem eval_esymm_zero_one [DecidableEq S] (f : n → S) (hf : ∀ i, f i = 0 ∨ f i = 1)
    (j : ℕ) :
    MvPolynomial.eval f (MvPolynomial.esymm n S j) =
      (((Finset.univ.filter (fun i => f i = 1)).card).choose j : S) := by
  classical
  let ones : Finset n := Finset.univ.filter (fun i => f i = 1)
  have hfun : f = fun i => if i ∈ ones then (1 : S) else 0 := by
    funext i
    by_cases h1 : f i = 1
    · simp [ones, h1]
    · have h0 : f i = 0 := (hf i).resolve_right h1
      simp only [ones, Finset.mem_filter, Finset.mem_univ, true_and, h1, ite_false]
      exact h0
  change MvPolynomial.eval f (MvPolynomial.esymm n S j) = (ones.card.choose j : S)
  rw [hfun]
  exact eval_esymm_indicator ones j

end ElementarySymmetric

end

section MatrixEigenvalue

variable {K : Type*} [Field K] {Q : ℕ}

/-- The actual matrix eigenvalue at a sign vector is the binomial-weighted
scalar from the interpolation argument. The weight is the integer number of
negative signs. -/
theorem matrixEigenvalue_signIndicator (h2 : (2 : K) ≠ 0) (t : Fin Q)
    (R : ℕ) (c : ℕ → K) (ones : Finset (Fin Q))
    (hsub : ones ⊆ MatrixSupport.activePositions t) :
    MatrixSupport.matrixEigenvalue t R c
        (fun l => if l ∈ ones then (-1 : K) else 1) =
      (-1 : K) ^ ones.card *
        ∑ j ∈ Finset.range R, c j * (ones.card.choose j : K) := by
  classical
  have hfilter :
      (MatrixSupport.activePositions t).filter (fun l => l ∈ ones) = ones := by
    ext l
    simp only [Finset.mem_filter]
    exact ⟨fun h => h.2, fun h => ⟨hsub h, h⟩⟩
  have hprod :
      (∏ l ∈ MatrixSupport.activePositions t, if l ∈ ones then (-1 : K) else 1) =
        (-1 : K) ^ ones.card := by
    simp only [Finset.prod_ite, Finset.prod_const, one_pow, mul_one, hfilter]
  have hprojector (l : Fin Q) :
      (1 - (if l ∈ ones then (-1 : K) else 1)) / 2 =
        if l ∈ ones then (1 : K) else 0 := by
    by_cases hl : l ∈ ones
    · simp only [ite_eq_left hl, sub_neg_eq_add, one_add_one_eq_two]
      exact div_self h2
    · simp [hl]
  unfold MatrixSupport.matrixEigenvalue
  rw [hprod]
  congr 1
  apply Finset.sum_congr rfl
  intro j _
  congr 1
  simp_rw [hprojector]
  exact sum_powersetCard_prod_indicator (MatrixSupport.activePositions t) ones hsub j

/-- With the parity-interpolation coefficients, the actual matrix eigenvalue
is one throughout the prescribed interval of integer weights. -/
theorem matrixEigenvalue_parity_of_mem (h2 : (2 : K) ≠ 0) (t : Fin Q)
    (A R : ℕ) (ones : Finset (Fin Q))
    (hsub : ones ⊆ MatrixSupport.activePositions t)
    (hA : A ≤ ones.card) (hR : ones.card < A + R) :
    MatrixSupport.matrixEigenvalue t R
        (extendCoefficients (parityCoefficients (K := K) A R))
        (fun l => if l ∈ ones then (-1 : K) else 1) = 1 := by
  rw [matrixEigenvalue_signIndicator h2 t R _ ones hsub,
    sum_range_extend_parity_of_mem A R ones.card hA hR, ← mul_pow]
  simp

end MatrixEigenvalue

end SubexponentialSAT.BinomialInterpolation

end OAI.Algorithms