File size: 3,514 Bytes
e320e82 | 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 | import Mathlib
import OAI.Combinatorics.IndependentSets.Encoding.Target
namespace OAI
namespace IndependentSetsGames.Foundations.Complexity
open Target
def parseLiteral («variables» : Nat) : List Nat → Option (Literal «variables» × List Nat)
| index :: sign :: rest =>
if bounded : index < «variables» then
if sign = 0 then some (⟨⟨index, bounded⟩, false⟩, rest)
else if sign = 1 then some (⟨⟨index, bounded⟩, true⟩, rest)
else none
else none
| _ => none
@[simp] theorem parseLiteral_encoded {n : Nat} (literal : Literal n) (rest : List Nat) :
parseLiteral n (literalWords literal ++ rest) = some (literal, rest) := by
cases literal with
| mk index positive =>
cases positive <;> simp [literalWords, parseLiteral, index.isLt]
def parseClause («variables» : Nat) (words : List Nat) : Option (Clause «variables» × List Nat) := do
let (a, words) ← parseLiteral «variables» words
let (b, words) ← parseLiteral «variables» words
let (c, words) ← parseLiteral «variables» words
return (⟨#[a, b, c], rfl⟩, words)
theorem clause_three_entries {n : Nat} (clause : Clause n) :
(⟨#[clause[0], clause[1], clause[2]], rfl⟩ : Clause n) = clause := by
apply Vector.ext
intro i hi
have cases_i : i = 0 ∨ i = 1 ∨ i = 2 := by omega
rcases cases_i with rfl | rfl | rfl <;> rfl
@[simp] theorem parseClause_encoded {n : Nat} (clause : Clause n) (rest : List Nat) :
parseClause n (clauseWords clause ++ rest) = some (clause, rest) := by
simp [clauseWords, List.append_assoc, parseClause, parseLiteral_encoded,
clause_three_entries]
def parseClauses («variables» : Nat) : Nat → List Nat → Option (List (Clause «variables») × List Nat)
| 0, words => some ([], words)
| count + 1, words => do
let (clause, words) ← parseClause «variables» words
let (clauses, words) ← parseClauses «variables» count words
return (clause :: clauses, words)
@[simp] theorem parseClauses_encoded {n : Nat} (clauses : List (Clause n)) (rest : List Nat) :
parseClauses n clauses.length (clauses.flatMap clauseWords ++ rest) = some (clauses, rest) := by
induction clauses with
| nil => rfl
| cons clause clauses ih =>
simp [List.append_assoc, parseClauses, parseClause_encoded, ih]
def decodeFormulaWords : List Nat → Option Formula
| «variables» :: count :: words => do
let (clauses, trailing) ← parseClauses «variables» count words
if trailing = [] then some ⟨«variables», clauses⟩ else none
| _ => none
@[simp] theorem decodeFormulaWords_encoded (formula : Formula) :
decodeFormulaWords (formulaWords formula) = some formula := by
cases formula with
| mk «variables» clauses =>
have parsed := parseClauses_encoded clauses []
simp only [List.append_nil] at parsed
simp [decodeFormulaWords, formulaWords, parsed]
def decodeFormulaBits (bits : List Bool) : Option Formula :=
decodeWords bits >>= decodeFormulaWords
@[simp] theorem decodeFormulaBits_encoded (formula : Formula) :
decodeFormulaBits (formulaBits formula) = some formula := by
simp [decodeFormulaBits, formulaBits]
theorem formulaBits_injective {first second : Formula}
(same : formulaBits first = formulaBits second) : first = second := by
have parsed := congrArg decodeFormulaBits same
simpa only [decodeFormulaBits_encoded, Option.some.injEq] using parsed
end IndependentSetsGames.Foundations.Complexity
end OAI
|