File size: 9,112 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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.BooleanPacking
import OAI.Algorithms.SubexponentialSAT.SubexpLiftRing

namespace OAI.Algorithms

/-!
# Little-endian Boolean chunks

The actual materializer writes the first label bit at the first variable
offset. This module supplies the matching numeric embedding, its inverse and
range, and the exact relation to the older most-significant-first encoding.
All reversals use the actual chunk size, including a shorter final chunk.
-/

namespace SubexponentialSAT.BooleanPackingLE

open BinaryArithmetic
open BooleanPacking (Chunk)

/-- The indexed bit of an actual little-endian word is its numeric test bit. -/
theorem testBit_toNat (word : List Bool) (i : ℕ) (hi : i < word.length) :
    (BinaryArithmetic.toNat word).testBit i = word[i] := by
  induction word generalizing i with
  | nil => simp at hi
  | cons bit word ih =>
    cases i with
    | zero =>
      cases bit <;> simp [bitVal, Nat.testBit_zero, Nat.add_mod]
    | succ i =>
      have hdiv : (bitVal bit + 2 * BinaryArithmetic.toNat word) / 2 = BinaryArithmetic.toNat word := by
        cases bit <;> simp [bitVal] ; omega
      rw [Nat.testBit_succ]
      simpa only [toNat_cons, hdiv, List.getElem_cons_succ] using
        ih i (by simpa using hi)

theorem getElem_eq_testBit (word : List Bool) (i : ℕ) (hi : i < word.length) :
    word[i] = (BinaryArithmetic.toNat word).testBit i := (testBit_toNat word i hi).symm

/-- Fixed-width little-endian words are determined by their numeric value.
Leading zeroes are allowed because the two widths agree. -/
theorem word_eq_of_length_value (xs ys : List Bool)
    (hlen : xs.length = ys.length) (hval : BinaryArithmetic.toNat xs = BinaryArithmetic.toNat ys) : xs = ys := by
  apply List.ext_getElem
  · exact hlen
  · intro i hix hiy
    rw [getElem_eq_testBit xs i hix, getElem_eq_testBit ys i hiy, hval]

/-- Missing high bits have their usual value false. -/
theorem testBit_toNat_getD (word : List Bool) (i : ℕ) :
    (BinaryArithmetic.toNat word).testBit i = word[i]?.getD false := by
  by_cases hi : i < word.length
  · rw [List.getElem?_eq_getElem hi]
    exact testBit_toNat word i hi
  · rw [List.getElem?_eq_none (by omega)]
    apply Nat.testBit_lt_two_pow
    exact (ModularArithmetic.toNat_lt_pow_length word).trans_le
      (Nat.pow_le_pow_right (by decide : 0 < (2 : ℕ)) (by omega))

def chunkValue {b : ℕ} (x : Chunk b) : ℕ := BinaryArithmetic.toNat (List.ofFn x)

theorem chunkValue_lt {b : ℕ} (x : Chunk b) : chunkValue x < 2 ^ b := by
  simpa [chunkValue] using ModularArithmetic.toNat_lt_pow_length (List.ofFn x)

@[simp] theorem testBit_chunkValue {b : ℕ} (x : Chunk b) (i : Fin b) :
    (chunkValue x).testBit i.val = x i := by
  simpa [chunkValue] using testBit_toNat (List.ofFn x) i.val (by simp)

theorem chunkValue_injective (b : ℕ) : Function.Injective (@chunkValue b) := by
  intro x y h
  funext i
  calc
    x i = (chunkValue x).testBit i.val := (testBit_chunkValue x i).symm
    _ = (chunkValue y).testBit i.val := by rw [h]
    _ = y i := testBit_chunkValue y i

/-- A total low-bit decoder; validity is needed only to re-encode exactly. -/
def decodeChunk (b n : ℕ) : Chunk b := fun i => n.testBit i.val

@[simp] theorem decodeChunk_chunkValue {b : ℕ} (x : Chunk b) :
    decodeChunk b (chunkValue x) = x := by
  funext i
  exact testBit_chunkValue x i

theorem chunkValue_decodeChunk (b n : ℕ) (hn : n < 2 ^ b) :
    chunkValue (decodeChunk b n) = n := by
  apply Nat.eq_of_testBit_eq
  intro i
  by_cases hi : i < b
  · exact testBit_chunkValue (decodeChunk b n) ⟨i, hi⟩
  · have hpow : 2 ^ b ≤ 2 ^ i :=
      Nat.pow_le_pow_right (by decide : 0 < (2 : ℕ)) (by omega)
    rw [Nat.testBit_lt_two_pow ((chunkValue_lt (decodeChunk b n)).trans_le hpow),
      Nat.testBit_lt_two_pow (hn.trans_le hpow)]

def chunkEquiv (b : ℕ) : Chunk b ≃ Fin (2 ^ b) where
  toFun x := ⟨chunkValue x, chunkValue_lt x⟩
  invFun n := decodeChunk b n.val
  left_inv := decodeChunk_chunkValue
  right_inv n := Fin.ext (chunkValue_decodeChunk b n.val n.isLt)

def chunkEmbedding {b p : ℕ} (h : 2 ^ b ≤ p) : Chunk b ↪ Fin p where
  toFun x := ⟨chunkValue x, (chunkValue_lt x).trans_le h⟩
  inj' _x _y he := chunkValue_injective b (congrArg Fin.val he)

@[simp] theorem chunkEmbedding_val {b p : ℕ} (h : 2 ^ b ≤ p) (x : Chunk b) :
    (chunkEmbedding h x).val = chunkValue x := rfl

theorem mem_range_chunkEmbedding {b p : ℕ} (h : 2 ^ b ≤ p) (a : Fin p) :
    a ∈ Set.range (chunkEmbedding h) ↔ a.val < 2 ^ b := by
  constructor
  · rintro ⟨x, rfl⟩
    exact chunkValue_lt x
  · intro ha
    exact ⟨decodeChunk b a.val, Fin.ext (chunkValue_decodeChunk b a.val ha)⟩

def chunkZModEmbedding {b p : ℕ} [NeZero p] (h : 2 ^ b ≤ p) : Chunk b ↪ ZMod p where
  toFun x := ZMod.finEquiv p (chunkEmbedding h x)
  inj' _x _y he := (chunkEmbedding h).injective ((ZMod.finEquiv p).injective he)

@[simp] theorem chunkZModEmbedding_val {b p : ℕ} [NeZero p]
    (h : 2 ^ b ≤ p) (x : Chunk b) :
    (chunkZModEmbedding h x).val = chunkValue x :=
  BooleanPacking.finEquiv_val _

theorem mem_range_chunkZModEmbedding {b p : ℕ} [NeZero p]
    (h : 2 ^ b ≤ p) (a : ZMod p) :
    a ∈ Set.range (chunkZModEmbedding h) ↔ a.val < 2 ^ b := by
  constructor
  · rintro ⟨x, rfl⟩
    simpa using chunkValue_lt x
  · intro ha
    refine ⟨decodeChunk b a.val, (ZMod.val_injective p) ?_⟩
    rw [chunkZModEmbedding_val, chunkValue_decodeChunk b a.val ha]

def decodeZMod (b : ℕ) {p : ℕ} (a : ZMod p) : Chunk b := decodeChunk b a.val

@[simp] theorem decodeZMod_encode {b p : ℕ} [NeZero p]
    (h : 2 ^ b ≤ p) (x : Chunk b) : decodeZMod b (chunkZModEmbedding h x) = x := by
  simp [decodeZMod]

theorem encode_decodeZMod {b p : ℕ} [NeZero p]
    (h : 2 ^ b ≤ p) (a : ZMod p) (ha : a.val < 2 ^ b) :
    chunkZModEmbedding h (decodeZMod b a) = a := by
  apply ZMod.val_injective p
  rw [chunkZModEmbedding_val]
  exact chunkValue_decodeChunk b a.val ha

/-- The materializer's actual word lookup equals the matching semantic
chunk decoder, for every available bit. No validity premise is hidden here. -/
theorem word_getElem_eq_decodeZMod {b p : ℕ} (a : ZMod p) (word : List Bool)
    (hword : BinaryArithmetic.toNat word = a.val) (hwidth : b ≤ word.length) (i : Fin b) :
    word[i.val]'(i.isLt.trans_le hwidth) = decodeZMod b a i := by
  rw [getElem_eq_testBit, hword]
  rfl

theorem fixedBits_getElem (b n : ℕ) (i : Fin b) :
    (SubexpLiftRing.fixedBits b n)[i.val]'(by simp) = n.testBit i.val := by
  rw [getElem_eq_testBit, SubexpLiftRing.toNat_fixedBits, Nat.testBit_mod_two_pow]
  simp [i.isLt]

theorem ofFn_decodeChunk (b n : ℕ) :
    List.ofFn (decodeChunk b n) = SubexpLiftRing.fixedBits b n := by
  apply List.ext_getElem
  · simp
  · intro i hi hj
    have hib : i < b := by simpa using hi
    simpa [decodeChunk] using (fixedBits_getElem b n ⟨i, hib⟩).symm

private theorem value_append (low high : List Bool) :
    BinaryArithmetic.toNat (low ++ high) = BinaryArithmetic.toNat low + 2 ^ low.length * BinaryArithmetic.toNat high := by
  induction low with
  | nil => simp
  | cons bit low ih =>
    simp only [List.cons_append, toNat_cons, List.length_cons, ih, pow_succ]
    ring

/-- The old recursive equivalence reads its first coordinate as the most
significant bit. This exact formula makes the convention difference explicit. -/
theorem msb_value (b : ℕ) : ∀ x : Chunk b,
    (BooleanPacking.chunkEquiv b x).val = BinaryArithmetic.toNat (List.ofFn (fun i => x i.rev)) := by
  induction b with
  | zero =>
    intro x
    have h := (BooleanPacking.chunkEquiv 0 x).isLt
    simp only [pow_zero] at h
    simp
  | succ b ih =>
    intro x
    have hb : (finTwoEquiv.symm (x 0)).val = bitVal (x 0) := by
      cases x 0 <;> rfl
    have hlist : List.ofFn (fun i : Fin (b + 1) => x i.rev) =
        List.ofFn (fun i : Fin b => x i.rev.succ) ++ [x 0] := by
      simpa only [Fin.rev_castSucc, Fin.rev_last, List.concat_eq_append] using
        List.ofFn_succ' (fun i : Fin (b + 1) => x i.rev)
    change (BooleanPacking.chunkEquiv b (fun i => x i.succ)).val +
      2 ^ b * (finTwoEquiv.symm (x 0)).val = _
    rw [ih, hb, hlist, value_append, List.length_ofFn]
    simp

/-- Reversal is at the actual b-bit chunk, including a short final chunk. -/
theorem chunkEmbedding_eq_msb_rev {b p : ℕ} (h : 2 ^ b ≤ p) (x : Chunk b) :
    chunkEmbedding h x = BooleanPacking.chunkEmbedding h (fun i => x i.rev) := by
  apply Fin.ext
  change chunkValue x = (BooleanPacking.chunkEquiv b (fun i => x i.rev)).val
  rw [msb_value]
  simp [chunkValue]

theorem chunkZModEmbedding_eq_msb_rev {b p : ℕ} [NeZero p]
    (h : 2 ^ b ≤ p) (x : Chunk b) :
    chunkZModEmbedding h x = BooleanPacking.chunkZModEmbedding h (fun i => x i.rev) := by
  change ZMod.finEquiv p (chunkEmbedding h x) =
    ZMod.finEquiv p (BooleanPacking.chunkEmbedding h (fun i => x i.rev))
  exact congrArg (ZMod.finEquiv p) (chunkEmbedding_eq_msb_rev h x)

end SubexponentialSAT.BooleanPackingLE

end OAI.Algorithms