File size: 6,172 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 | import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.ExecLiteralDedupProgram
import OAI.Algorithms.SubexponentialSAT.Subexp.PackingBucketExecution
import OAI.Algorithms.SubexponentialSAT.Subexp.PackingBucketBounds
namespace OAI.Algorithms
/-! Concrete byte-string deduplication and all-key bucket scans. This file
starts at the explicit labelled-record table, not at an uncharged signature
oracle. Producing that table is the separate dot-product stage. -/
namespace SubexponentialSAT.SqrtLog.BucketProgram
open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls
abbrev Record := SubexponentialSAT.Subexp.BucketProgram.Record
def attainedKeys (records : List Record) : List (List Bool) :=
SubexponentialSAT.ExecCNF.dedupLiterals (records.map Prod.fst)
def bucketAssignments (records : List Record) (key : List Bool) : List (List Bool) :=
SubexponentialSAT.Subexp.BucketProgram.selected records key
@[simp] theorem mem_attainedKeys (records : List Record) (key : List Bool) :
key ∈ attainedKeys records ↔ ∃ payload, (key,payload) ∈ records := by
simp only [attainedKeys, SubexponentialSAT.ExecCNF.mem_dedupLiterals, List.mem_map]
constructor
· rintro ⟨⟨k,p⟩, hm, he⟩; simp only at he; subst k; exact ⟨p, hm⟩
· rintro ⟨p, hp⟩; exact ⟨(key,p), hp, rfl⟩
theorem attainedKeys_nodup (records : List Record) : (attainedKeys records).Nodup :=
SubexponentialSAT.ExecCNF.dedupLiterals_nodup _
theorem attainedKeys_length_le (records : List Record) :
(attainedKeys records).length ≤ records.length := by
simpa [attainedKeys] using SubexponentialSAT.ExecCNF.dedupLiterals_length_le (records.map Prod.fst)
@[simp] theorem mem_bucketAssignments (records : List Record) (key payload : List Bool) :
payload ∈ bucketAssignments records key ↔ (key,payload) ∈ records := by
induction records with
| nil => simp [bucketAssignments, SubexponentialSAT.Subexp.BucketProgram.selected]
| cons rec records ih =>
rcases rec with ⟨k,p⟩
by_cases hk : k=key
· subst k
simp [bucketAssignments, SubexponentialSAT.Subexp.BucketProgram.selected] at ih ⊢
exact or_congr Iff.rfl ih
· simp [bucketAssignments, SubexponentialSAT.Subexp.BucketProgram.selected, hk] at ih ⊢
simpa [Prod.mk.injEq, hk, Ne.symm hk] using ih
theorem attained_bucket_nonempty (records : List Record) (key : List Bool)
(hk : key ∈ attainedKeys records) : bucketAssignments records key ≠ [] := by
obtain ⟨p,hp⟩ := (mem_attainedKeys records key).mp hk
intro he
have hm := (mem_bucketAssignments records key p).mpr hp
simp [he] at hm
/-- A representative can always be read as the first stored assignment.
The machine output stores every assignment, so this needs no choice oracle. -/
theorem attained_bucket_representative (records : List Record) (key : List Bool)
(hk : key ∈ attainedKeys records) :
∃ rep rest, bucketAssignments records key = rep::rest ∧ (key,rep) ∈ records := by
cases he : bucketAssignments records key with
| nil => exact (attained_bucket_nonempty records key hk he).elim
| cons rep rest =>
refine ⟨rep,rest,rfl,?_⟩
exact (mem_bucketAssignments records key rep).mp (by simp [he])
abbrev keyDedupProgram := SubexponentialSAT.ExecLiteralDedupProgram.dedupProgram
/-- Actual key deduplication, with quadratic measured encoded-input cost. -/
theorem keyDedup_runsIn (records : List Record) (d : SubexponentialSAT.ExecLiteralDedupProgram.Data)
(hs : d.stacks 0 = ProgramEncoding.encodeRecords (records.map Prod.fst))
(hr : SubexponentialSAT.ExecLiteralDedupProgram.Ready d) :
∃ e, SubexponentialSAT.ExecLiteralDedupProgram.Ready e ∧
e.stacks 0 = ProgramEncoding.encodeRecords (attainedKeys records) ∧
RunsIn keyDedupProgram
(120*((ProgramEncoding.encodeRecords (records.map Prod.fst)).length+1)^2)
(d.withPC (some keyDedupProgram.entry)) (e.withPC none) := by
exact SubexponentialSAT.ExecLiteralDedupProgram.dedup_runsIn (records.map Prod.fst) d hs hr
abbrev groupProgram := SubexponentialSAT.Subexp.PackingBucketTable.program
def groupedTable (records : List Record) : List (List Bool) :=
SubexponentialSAT.Subexp.PackingBucketTable.table records (attainedKeys records)
/-- One fixed all-key controller executes actual byte comparisons and emits
all attained buckets. The initial unary minimum is zero and remains zero;
its otherwise-unused legacy accumulator costs are included in the budget. -/
theorem groupProgram_trace (records : List Record) (regs : Fin 8 → Bool) :
∃ t ≤ SubexponentialSAT.Subexp.PackingBucketTable.budget records (attainedKeys records), ∃ rf,
Trace groupProgram t
((SubexponentialSAT.Subexp.PackingBucketTable.inputState records (attainedKeys records) 0 [] regs).withPC
(some groupProgram.entry))
((SubexponentialSAT.Subexp.PackingBucketTable.outputState records (attainedKeys records) 0 [] rf).withPC none) :=
SubexponentialSAT.Subexp.PackingBucketTable.program_trace records (attainedKeys records) 0 (Nat.zero_le _) [] regs
/-- Each record and query is scanned; all resulting costs are polynomial
in the explicit table length and the number of attained keys. -/
theorem groupProgram_budget (records : List Record) (K : ℕ)
(hk : ∀ rec ∈ records, rec.1.length ≤ K) :
SubexponentialSAT.Subexp.PackingBucketTable.budget records (attainedKeys records) ≤
9 + records.length *
(6*K+100*((SubexponentialSAT.Subexp.BucketProgram.encodeRecords records).length+1)*(K+1)+7) +
3*(1+(2*(2*K+1+(SubexponentialSAT.Subexp.BucketProgram.encodeRecords records).length)+2)*records.length) := by
have hkeys : ∀ key ∈ attainedKeys records, key.length ≤ K := by
intro key hkey
obtain ⟨p,hp⟩ := (mem_attainedKeys records key).mp hkey
exact hk (key,p) hp
have hb := SubexponentialSAT.Subexp.PackingBucketTable.budget_bound records (attainedKeys records) K hkeys
have hl := attainedKeys_length_le records
exact hb.trans (by gcongr)
end SubexponentialSAT.SqrtLog.BucketProgram
end OAI.Algorithms
|