File size: 2,440 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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.Subexp.MatrixWordEncoding
import OAI.Algorithms.SubexponentialSAT.Subexp.MatrixProgramSupport
import OAI.Algorithms.SubexponentialSAT.Subexp.BlockSearchLoop

namespace OAI.Algorithms

/-! Concrete encoded inputs and a fixed polynomial budget for the coefficient checker. -/

namespace SubexponentialSAT.Subexp.BlockCoefficientProgram

def vectorWords (p : β„•) {N : β„•} (x : Fin N β†’ ZMod p) : List (List Bool) :=
  List.ofFn fun i => MatrixWordEncoding.word p (x i)

def matrixRows (p : β„•) {m N : β„•} (M : Fin m β†’ Fin N β†’ ZMod p) : List (List (List Bool)) :=
  List.ofFn fun j => vectorWords p (M j)

def matrixBits (p : β„•) {m N : β„•} (M : Fin m β†’ Fin N β†’ ZMod p) : List Bool :=
  MatrixProgramSupport.words (matrixRows p M).flatten

def tableBits (p : β„•) {N : β„•} (C : Fin N β†’ Fin N β†’ ZMod p) : List Bool := matrixBits p C

def context (p : β„•) [Fact p.Prime] {m N : β„•} (M : Fin m β†’ Fin N β†’ ZMod p) : BlockSearchLoop.Context where
  modulus := MatrixWordEncoding.modulus p
  zeroWord := MatrixWordEncoding.zero p
  matrix := matrixBits p M
  rowCount := List.replicate m true
  dimension := List.replicate N true

def coefficientCost (p m N : β„•) : β„• :=
  200000 * (m + 1) * (N + 1) ^ 2 * (MatrixWordEncoding.width p + 1) ^ 2

def validCoefficient (p N : β„•) (bits : List Bool) : Prop :=
  βˆƒ x : Fin N β†’ ZMod p, bits = MatrixProgramSupport.words (vectorWords p x)

@[simp] theorem vectorWords_length (p : β„•) {N : β„•} (x : Fin N β†’ ZMod p) :
    (vectorWords p x).length = N := by simp [vectorWords]

theorem vectorWords_width (p : β„•) {N : β„•} (x : Fin N β†’ ZMod p) :
    βˆ€ w ∈ vectorWords p x, w.length = MatrixWordEncoding.width p := by
  intro w hw
  obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hw
  exact MatrixWordEncoding.word_length p (x i)

@[simp] theorem matrixRows_length (p : β„•) {m N : β„•} (M : Fin m β†’ Fin N β†’ ZMod p) :
    (matrixRows p M).length = m := by simp [matrixRows]

theorem matrixRows_shape (p : β„•) {m N : β„•} (M : Fin m β†’ Fin N β†’ ZMod p) :
    βˆ€ ys ∈ matrixRows p M, N = ys.length ∧
      βˆ€ y ∈ ys, y.length = MatrixWordEncoding.width p := by
  intro ys hys
  obtain ⟨j, rfl⟩ := List.mem_ofFn.mp hys
  exact ⟨(vectorWords_length p (M j)).symm, vectorWords_width p (M j)⟩

end SubexponentialSAT.Subexp.BlockCoefficientProgram

end OAI.Algorithms