File size: 3,847 Bytes
92416a2 | 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 | import Mathlib
import OAI.Computability.VertexCover.Encoding.Serialization
namespace OAI
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
namespace UniqueGames.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 UniqueGames.Foundations.Complexity
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end OAI
|