| import Mathlib |
| import OAI.Combinatorics.IndependentSets.Model |
|
|
| namespace OAI |
|
|
| namespace LargeIndependentSets |
| namespace BinaryParser |
|
|
| def bitsValue : List Bool → ℕ |
| | [] => 0 |
| | b::bs => Nat.bit b (bitsValue bs) |
|
|
| @[simp] lemma bitsValue_bits (n : ℕ) : bitsValue n.bits = n := by |
| induction n using Nat.binaryRec' with |
| | zero => simp [bitsValue] |
| | bit b n hn ih => rw [Nat.bits_append_bit n b hn]; simp only [bitsValue,ih] |
|
|
| def parseFrame : List Bool → Option (List Bool × List Bool) |
| | false::rest => some ([],rest) |
| | true::b::rest => do |
| let (bs,tail) ← parseFrame rest |
| return (b::bs,tail) |
| | _ => none |
|
|
| @[simp] lemma parseFrame_encoded (bs tail : List Bool) : |
| parseFrame (frame bs ++ tail) = some (bs,tail) := by |
| induction bs with |
| | nil => rfl |
| | cons b bs ih => simp [frame,parseFrame,ih] |
|
|
| def parseName (b : List Bool) : Option (ℕ × List Bool) := do |
| let (digits,tail) ← parseFrame b |
| let n := bitsValue digits |
| if digits = n.bits then some (n,tail) else none |
|
|
| @[simp] lemma parseName_encoded (n : ℕ) (tail : List Bool) : |
| parseName (nameBits n ++ tail) = some (n,tail) := by |
| simp [parseName,nameBits] |
|
|
| def parseLiteral : List Bool → Option (Literal × List Bool) |
| | sign::b => do |
| let (name,tail) ← parseName b |
| return (⟨name,sign⟩,tail) |
| | [] => none |
|
|
| @[simp] lemma parseLiteral_encoded (l : Literal) (tail : List Bool) : |
| parseLiteral (literalBits l ++ tail) = some (l,tail) := by |
| cases l |
| simp [parseLiteral,literalBits] |
|
|
| def parseMany {α : Type} (parse : List Bool → Option (α × List Bool)) : |
| ℕ → List Bool → Option (List α × List Bool) |
| | 0,b => some ([],b) |
| | n+1,b => do |
| let (a,b) ← parse b |
| let (as,tail) ← parseMany parse n b |
| return (a::as,tail) |
|
|
| lemma parseMany_encoded {α : Type} (parse : List Bool → Option (α × List Bool)) |
| (encode : α → List Bool) (P : α → Prop) |
| (h : ∀ a, P a → ∀ tail, parse (encode a ++ tail) = some (a,tail)) |
| (as : List α) (has : ∀ a ∈ as, P a) (tail : List Bool) : |
| parseMany parse as.length (as.flatMap encode ++ tail) = some (as,tail) := by |
| induction as with |
| | nil => rfl |
| | cons a as ih => |
| simp only [List.length_cons,List.flatMap_cons,List.append_assoc,parseMany, |
| h a (has a (by simp)),bind,Option.bind] |
| rw [ih (fun x hx => has x (by simp [hx]))] |
| rfl |
|
|
| def parseClause (b : List Bool) : Option (List Literal × List Bool) := do |
| let (n,b) ← parseName b |
| if n ≤ 3 then parseMany parseLiteral n b else none |
|
|
| lemma parseClause_encoded (C : List Literal) (hC : C.length ≤ 3) (tail : List Bool) : |
| parseClause (clauseBits C ++ tail) = some (C,tail) := by |
| simp only [clauseBits,List.append_assoc,parseClause,parseName_encoded,bind,Option.bind,hC,ite_true] |
| exact parseMany_encoded parseLiteral literalBits (fun _ => True) |
| (fun l _ => parseLiteral_encoded l) C (by simp) tail |
|
|
| lemma clauses_length_le_bits (Cs : List (List Literal)) : |
| Cs.length ≤ (Cs.flatMap clauseBits).length := by |
| have hp (C : List Literal) : 1 ≤ (clauseBits C).length := by |
| unfold clauseBits nameBits |
| have h : ∀ b : List Bool, 1 ≤ (frame b).length := by |
| intro b |
| cases b <;> simp [frame] |
| simpa only [List.length_append] using (h C.length.bits).trans (Nat.le_add_right _ _) |
| induction Cs with |
| | nil => simp |
| | cons C Cs ih => simp only [List.length_cons,List.flatMap_cons,List.length_append]; have := hp C; omega |
|
|
| def core (input : List Bool) : Option Formula := do |
| let (n,b) ← parseName input |
| if n ≤ b.length then |
| let (Cs,tail) ← parseMany parseClause n b |
| if tail = [] then |
| if h : ∀ C ∈ Cs, C.length ≤ 3 then some ⟨Cs,h⟩ else none |
| else none |
| else none |
|
|
| lemma core_encoded (F : Formula) : core (formulaBits F) = some F := by |
| unfold core formulaBits |
| rw [parseName_encoded] |
| simp only [bind,Option.bind,clauses_length_le_bits,ite_true] |
| have hm := parseMany_encoded parseClause clauseBits (fun C => C.length ≤ 3) |
| parseClause_encoded F.clauses F.width [] |
| simp only [List.append_nil] at hm |
| rw [hm] |
| simp |
| exact F.width |
|
|
| def decode (input : List Bool) : Formula := |
| match core input with |
| | none => ⟨[],by simp⟩ |
| | some F => if formulaBits F = input then F else ⟨[],by simp⟩ |
|
|
| @[simp] theorem decode_encoded (F : Formula) : decode (formulaBits F) = F := by |
| simp [decode,core_encoded] |
|
|
| theorem decode_bits_bound (input : List Bool) : |
| (formulaBits (decode input)).length ≤ input.length+1 := by |
| unfold decode |
| cases h : core input with |
| | none => simp [formulaBits,nameBits,frame] |
| | some F => |
| dsimp only |
| split_ifs with he |
| · simp only [he]; omega |
| · simp [formulaBits,nameBits,frame] |
|
|
| end BinaryParser |
| end LargeIndependentSets |
|
|
| end OAI |
|
|
