math / data /lean /OAI /Computability /MinUncut /Encoding /Serialization.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
11.8 kB
import Mathlib
import OAI.Computability.MinUncut.PCP.Folding
import OAI.Computability.MinUncut.Games.Target
namespace OAI
section
namespace MinUncutGames.Foundations.Complexity
def encodeWord (n : Nat) : List Bool := List.replicate n true ++ [false]
def encodeWords : List Nat → List Bool
| [] => []
| n :: ns => encodeWord n ++ encodeWords ns
def decodeWordsAux : List Bool → Nat → Option (List Nat)
| [], 0 => some []
| [], _ + 1 => none
| true :: bs, n => decodeWordsAux bs (n + 1)
| false :: bs, n => (decodeWordsAux bs 0).map (n :: ·)
def decodeWords (bs : List Bool) : Option (List Nat) := decodeWordsAux bs 0
theorem decodeWordsAux_word (n k : Nat) (bs : List Bool) :
decodeWordsAux (encodeWord n ++ bs) k =
(decodeWordsAux bs 0).map ((k + n) :: ·) := by
induction n generalizing k with
| zero => simp [encodeWord, decodeWordsAux]
| succ n ih =>
simp only [encodeWord, List.replicate_succ, List.cons_append, List.append_assoc,
decodeWordsAux]
simpa [encodeWord, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using ih (k + 1)
@[simp] theorem decodeWords_encodeWords (ns : List Nat) :
decodeWords (encodeWords ns) = some ns := by
induction ns with
| nil => rfl
| cons n ns ih =>
simp only [decodeWords, encodeWords, decodeWordsAux_word, Nat.zero_add]
simpa [decodeWords] using congrArg (Option.map (n :: ·)) ih
theorem encodeWords_injective {xs ys : List Nat} (h : encodeWords xs = encodeWords ys) :
xs = ys := by
have decoded := congrArg decodeWords h
simpa only [decodeWords_encodeWords, Option.some.injEq] using decoded
@[simp] theorem encodeWord_length (n : Nat) : (encodeWord n).length = n + 1 := by
simp [encodeWord]
@[simp] theorem encodeWords_append (xs ys : List Nat) :
encodeWords (xs ++ ys) = encodeWords xs ++ encodeWords ys := by
induction xs with
| nil => rfl
| cons x xs ih => simp [encodeWords, ih, List.append_assoc]
@[simp] theorem encodeWords_length (ns : List Nat) :
(encodeWords ns).length = ns.sum + ns.length := by
induction ns with
| nil => rfl
| cons n ns ih => simp [encodeWords, ih]; omega
theorem encodeWords_length_le (ns : List Nat) (bound : Nat)
(bounded : ∀ n ∈ ns, n ≤ bound) :
(encodeWords ns).length ≤ ns.length * (bound + 1) := by
induction ns with
| nil => simp [encodeWords]
| cons n ns ih =>
have hn := bounded n (by simp)
have hns := ih (fun x hx => bounded x (by simp [hx]))
simp only [encodeWords, List.length_append, encodeWord_length, List.length_cons,
Nat.add_mul, Nat.one_mul]
omega
open Target
def literalWords {n : Nat} (literal : Literal n) : List Nat :=
[literal.variableIndex.val, if literal.positive then 1 else 0]
def clauseWords {n : Nat} (clause : Clause n) : List Nat :=
literalWords clause[0] ++ literalWords clause[1] ++ literalWords clause[2]
def formulaWords (formula : Formula) : List Nat :=
[formula.«variables», formula.clauses.length] ++ formula.clauses.flatMap clauseWords
def formulaBits (formula : Formula) : List Bool := encodeWords (formulaWords formula)
@[simp] theorem literalWords_length {n : Nat} (literal : Literal n) :
(literalWords literal).length = 2 := by simp [literalWords]
@[simp] theorem clauseWords_length {n : Nat} (clause : Clause n) :
(clauseWords clause).length = 6 := by simp [clauseWords]
theorem clausesWords_length {n : Nat} (clauses : List (Clause n)) :
(clauses.flatMap clauseWords).length = 6 * clauses.length := by
induction clauses with
| nil => rfl
| cons clause clauses ih =>
simp only [List.flatMap_cons, List.length_append, clauseWords_length,
List.length_cons, ih, Nat.mul_add, Nat.mul_one]
omega
@[simp] theorem formulaWords_length (formula : Formula) :
(formulaWords formula).length = 2 + 6 * formula.clauses.length := by
simp only [formulaWords, List.length_append, List.length_cons, List.length_nil,
clausesWords_length]
theorem literalBits_length_le {n : Nat} (literal : Literal n) :
(encodeWords (literalWords literal)).length ≤ n + 2 := by
have hindex := literal.variableIndex.isLt
cases hp : literal.positive <;> simp [literalWords, hp]
theorem clauseBits_length_le {n : Nat} (clause : Clause n) :
(encodeWords (clauseWords clause)).length ≤ 3 * (n + 2) := by
have h0 := literalBits_length_le clause[0]
have h1 := literalBits_length_le clause[1]
have h2 := literalBits_length_le clause[2]
simp only [clauseWords, encodeWords_append, List.length_append]
omega
theorem clausesBits_length_le {n : Nat} (clauses : List (Clause n)) :
(encodeWords (clauses.flatMap clauseWords)).length ≤ clauses.length * (3 * (n + 2)) := by
induction clauses with
| nil => simp [encodeWords]
| cons clause clauses ih =>
have hc := clauseBits_length_le clause
simp only [List.flatMap_cons, encodeWords_append, List.length_append,
List.length_cons, Nat.add_mul, Nat.one_mul]
omega
theorem formulaBits_length_le (formula : Formula) :
(formulaBits formula).length ≤
formula.«variables» + formula.clauses.length + 2 +
formula.clauses.length * (3 * (formula.«variables» + 2)) := by
have h := clausesBits_length_le formula.clauses
simp only [formulaBits, formulaWords, encodeWords_append, List.length_append,
encodeWords, encodeWord_length, List.length_nil]
omega
end MinUncutGames.Foundations.Complexity
end
section
namespace MinUncutGames.Reduction.SourceEncoding
open MinUncutGames.Foundations.Complexity
structure Input where
«variables» : Nat
equations : List (CloneGap.Equation (Fin «variables»))
nonempty : equations ≠ []
abbrev Table := Input
def equationWords {n : Nat} (e : CloneGap.Equation (Fin n)) : List Nat :=
[e.first.val, e.second.val, e.third.val, if e.rhs then 1 else 0]
def inputWords (input : Input) : List Nat :=
[input.«variables», input.equations.length] ++ input.equations.flatMap equationWords
def inputBits (input : Input) : List Bool := encodeWords (inputWords input)
def parseEquation («variables» : Nat) :
List Nat → Option (CloneGap.Equation (Fin «variables») × List Nat)
| first :: second :: third :: rhs :: rest =>
if hfirst : first < «variables» then
if hsecond : second < «variables» then
if hthird : third < «variables» then
if rhs = 0 then
some (⟨⟨first, hfirst⟩, ⟨second, hsecond⟩, ⟨third, hthird⟩, false⟩, rest)
else if rhs = 1 then
some (⟨⟨first, hfirst⟩, ⟨second, hsecond⟩, ⟨third, hthird⟩, true⟩, rest)
else none
else none
else none
else none
| _ => none
@[simp] theorem parseEquation_encoded {n : Nat} (e : CloneGap.Equation (Fin n))
(rest : List Nat) :
parseEquation n (equationWords e ++ rest) = some (e, rest) := by
cases e with
| mk first second third rhs =>
cases rhs <;> simp [equationWords, parseEquation, first.isLt, second.isLt, third.isLt]
def parseEquations («variables» : Nat) :
Nat → List Nat → Option (List (CloneGap.Equation (Fin «variables»)) × List Nat)
| 0, words => some ([], words)
| count + 1, words => do
let (equation, words) ← parseEquation «variables» words
let (equations, words) ← parseEquations «variables» count words
return (equation :: equations, words)
@[simp] theorem parseEquations_encoded {n : Nat}
(equations : List (CloneGap.Equation (Fin n))) (rest : List Nat) :
parseEquations n equations.length (equations.flatMap equationWords ++ rest) =
some (equations, rest) := by
induction equations with
| nil => rfl
| cons e equations ih =>
simp [List.append_assoc, parseEquations, parseEquation_encoded, ih]
def decodeInputWords : List Nat → Option Input
| «variables» :: count :: words => do
let (equations, trailing) ← parseEquations «variables» count words
if trailing = [] then
if nonempty : 0 < equations.length then
some ⟨«variables», equations, List.length_pos_iff.mp nonempty⟩
else none
else none
| _ => none
@[simp] theorem decodeInputWords_encoded (input : Input) :
decodeInputWords (inputWords input) = some input := by
cases input with
| mk «variables» equations nonempty =>
have parsed := parseEquations_encoded equations []
have positive := List.length_pos_iff.mpr nonempty
simp only [List.append_nil] at parsed
simp [decodeInputWords, inputWords, parsed, positive]
def decodeInputBits (bits : List Bool) : Option Input :=
decodeWords bits >>= decodeInputWords
@[simp] theorem decodeInputBits_encoded (input : Input) :
decodeInputBits (inputBits input) = some input := by
simp [decodeInputBits, inputBits]
theorem inputWords_injective {first second : Input}
(same : inputWords first = inputWords second) : first = second := by
have parsed := congrArg decodeInputWords same
simpa only [decodeInputWords_encoded, Option.some.injEq] using parsed
theorem inputBits_injective {first second : Input}
(same : inputBits first = inputBits second) : first = second := by
have parsed := congrArg decodeInputBits same
simpa only [decodeInputBits_encoded, Option.some.injEq] using parsed
@[simp] theorem equationWords_length {n : Nat} (e : CloneGap.Equation (Fin n)) :
(equationWords e).length = 4 := by simp [equationWords]
theorem equationsWords_length {n : Nat} (equations : List (CloneGap.Equation (Fin n))) :
(equations.flatMap equationWords).length = 4 * equations.length := by
induction equations with
| nil => rfl
| cons e equations ih =>
simp only [List.flatMap_cons, List.length_append, equationWords_length,
List.length_cons, ih, Nat.mul_add, Nat.mul_one]
omega
@[simp] theorem inputWords_length (input : Input) :
(inputWords input).length = 2 + 4 * input.equations.length := by
simp only [inputWords, List.length_append, List.length_cons, List.length_nil,
equationsWords_length]
theorem equationBits_length_le {n : Nat} (e : CloneGap.Equation (Fin n)) :
(encodeWords (equationWords e)).length ≤ 3 * n + 2 := by
have hfirst := e.first.isLt
have hsecond := e.second.isLt
have hthird := e.third.isLt
cases hrhs : e.rhs <;> simp [equationWords, hrhs] <;> omega
theorem equationsBits_length_le {n : Nat} (equations : List (CloneGap.Equation (Fin n))) :
(encodeWords (equations.flatMap equationWords)).length ≤
equations.length * (3 * n + 2) := by
induction equations with
| nil => simp [encodeWords]
| cons e equations ih =>
have he := equationBits_length_le e
simp only [List.flatMap_cons, encodeWords_append, List.length_append,
List.length_cons, Nat.add_mul, Nat.one_mul]
omega
theorem inputBits_length (input : Input) :
(inputBits input).length = input.«variables» + input.equations.length + 2 +
(encodeWords (input.equations.flatMap equationWords)).length := by
simp only [inputBits, inputWords, encodeWords_append, List.length_append,
encodeWords, encodeWord_length, List.length_nil]
omega
theorem inputBits_length_le (input : Input) :
(inputBits input).length ≤ input.«variables» + input.equations.length + 2 +
input.equations.length * (3 * input.«variables» + 2) := by
rw [inputBits_length]
exact Nat.add_le_add_left (equationsBits_length_le input.equations) _
theorem inputBits_length_ge_variables (input : Input) :
input.«variables» ≤ (inputBits input).length := by rw [inputBits_length]; omega
theorem inputBits_length_ge_equations (input : Input) :
input.equations.length ≤ (inputBits input).length := by rw [inputBits_length]; omega
end MinUncutGames.Reduction.SourceEncoding
end
end OAI