File size: 3,803 Bytes
ae00908 | 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 | import OAI.Algebra.FormulaHitting.Generator
import OAI.Algebra.FormulaHitting.BitModel
namespace OAI
namespace NCHitting
open BitModel
def dimensionExpr (nRegister sRegister : ℕ) : Expr :=
.mul (.mul (.literal 2) (.read nRegister)) (.power (.read sRegister) (.literal 2))
def entryProgram : Program :=
.branch (.less (.read 0) (.read 1))
(.emit (.odd (.sub (.sub (.read 1) (.read 0)) (.literal 1)))
(.literal 1)
(.mul (.read 1) (.power (.add (.read 2) (.literal 1))
(.sub (.read 1) (.read 0)))))
(.emit (.literal 0) (.literal 0) (.literal 1))
def rowProgram : Program := .loop (dimensionExpr 2 3) entryProgram
def variableProgram : Program := .loop (dimensionExpr 1 2) rowProgram
def generatorProgram : Program :=
.branch (.mul (.equal (.read 0) (.literal 1)) (.equal (.read 1) (.literal 1)))
(.emit (.literal 0) (.literal 1) (.literal 1))
(.loop (.read 0) variableProgram)
def encodedEntry (i r q : ℕ) : BitModel.RationalCode :=
if q < r then ⟨decide ((r-q-1) % 2 = 1), 1, r * (i+1)^(r-q)⟩
else ⟨false, 0, 1⟩
def encodedOutput (n s : ℕ) : List BitModel.RationalCode :=
if n = 1 ∧ s = 1 then [⟨false, 1, 1⟩]
else (List.range n).flatMap fun i =>
(List.range (2*n*s^2)).flatMap fun r =>
(List.range (2*n*s^2)).map fun q => encodedEntry i r q
def generate (n s : ℕ) : ProgramResult := BitModel.execute generatorProgram [n, s]
theorem entryProgram_output (n s i r q : ℕ) :
(entryProgram.run [q,r,i,n,s]).output = [encodedEntry i r q] := by
by_cases h : q < r <;>
simp [entryProgram, Program.run, Expr.run, encodedEntry, h]
theorem rowProgram_output (n s i r : ℕ) :
(rowProgram.run [r,i,n,s]).output =
(List.range (2*n*s^2)).map (encodedEntry i r) := by
simp [rowProgram, Program.run, dimensionExpr, Expr.run, List.flatMap_map,
entryProgram_output, ← List.map_eq_flatMap]
theorem variableProgram_output (n s i : ℕ) :
(variableProgram.run [i,n,s]).output =
(List.range (2*n*s^2)).flatMap fun r =>
(List.range (2*n*s^2)).map (encodedEntry i r) := by
simp [variableProgram, Program.run, dimensionExpr, Expr.run, List.flatMap_map,
rowProgram_output]
theorem generate_output (n s : ℕ) : (generate n s).output = encodedOutput n s := by
by_cases hn : n = 1 <;> by_cases hs : s = 1 <;>
simp [generate, BitModel.execute, generatorProgram, Program.run, Expr.run,
hn, hs, List.flatMap_map, variableProgram_output, encodedOutput]
theorem encodedEntry_denominator_pos (i r q : ℕ) :
0 < (encodedEntry i r q).denominator := by
unfold encodedEntry
split_ifs with h
· simp only
apply Nat.mul_pos (by omega)
exact pow_pos (by omega) _
· decide
def decode (entry : BitModel.RationalCode) : ℚ :=
(if entry.negative then -(entry.numerator : ℚ) else entry.numerator) / entry.denominator
theorem decode_encodedEntry (i r q : ℕ) :
decode (encodedEntry i r q) = matrixEntry (i+1) r q := by
by_cases h : q < r
· simp only [encodedEntry, ite_eq_left h, decode, matrixEntry]
rw [neg_one_pow_eq_pow_mod_two]
by_cases hm : (r-q-1) % 2 = 1
· simp [hm, Nat.cast_mul, Nat.cast_pow]
· have hz : (r-q-1) % 2 = 0 := by omega
simp [hz, Nat.cast_mul, Nat.cast_pow]
· simp [encodedEntry, decode, matrixEntry, h]
theorem encodedEntry_bits_le {n d i r q : ℕ} (hi : i < n) (hr : r < d) :
(encodedEntry i r q).bits ≤ 4 + entryBitBound n d := by
unfold encodedEntry
split_ifs with h
· have hb := denominator_size_le (i := i+1) (q := q) (show i+1 ≤ n by omega) hr
simp only [BitModel.RationalCode.bits, BitModel.width, Nat.size_one]
omega
· simp only [BitModel.RationalCode.bits, BitModel.width, Nat.size_one, Nat.size_zero]
unfold entryBitBound
omega
end NCHitting
end OAI
|