math / data /lean /OAI /Probability /SATComputability /HierarchyBounds.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
2.33 kB
import OAI.Probability.SATComputability.HierarchyEncoding
import OAI.Probability.SATComputability.FiniteEnumeration
namespace OAI
namespace FixedClauseThreshold.Computability
open Encodable Denumerable Nat.Partrec
theorem branchEntry_code_le (c : Code) : encode (branchEntry c).2 ≤ encode c := by
cases c with
| comp w c => exact (Code.encode_lt_comp w c).2.le
| zero => rfl
| succ => exact Nat.zero_le _
| left => exact Nat.zero_le _
| right => exact Nat.zero_le _
| pair c d => exact Nat.zero_le _
| prec c d => exact Nat.zero_le _
| rfind' c => exact Nat.zero_le _
theorem rawBranches_code_le (c : Code) :
∀ b ∈ rawBranches c, encode b.2 ≤ encode c := by
induction c with
| pair c d _ ih =>
intro b hb
rcases List.mem_cons.mp hb with h | h
· subst b
exact (branchEntry_code_le c).trans (Code.encode_lt_pair c d).1.le
· exact (ih b h).trans (Code.encode_lt_pair c d).2.le
| zero | succ | left | right | comp _ _ _ _ | prec _ _ _ _ | rfind' _ _ =>
simp only [rawBranches, List.not_mem_nil, false_implies, implies_true]
theorem normalizedBranches_code_le (c : Code) :
∀ b ∈ normalizedBranches c, encode b.2 ≤ encode c := by
dsimp only [normalizedBranches]
split_ifs
· intro b hb
have h : b = (1, Code.zero) := by simpa only [List.mem_singleton] using hb
subst b
exact Nat.zero_le _
· intro b hb
obtain ⟨x, hx, rfl⟩ := List.mem_map.mp hb
exact rawBranches_code_le c x hx
def codeAlphabet (bound : ℕ) : List Code :=
(List.range (bound+1)).map (ofNat Code)
theorem mem_codeAlphabet (bound : ℕ) (c : Code) :
c ∈ codeAlphabet bound ↔ encode c ≤ bound := by
constructor
· intro h
obtain ⟨n, hn, rfl⟩ := List.mem_map.mp h
simpa only [List.mem_range, encode_ofNat, Nat.lt_succ_iff] using hn
· intro h
exact List.mem_map.mpr ⟨encode c, List.mem_range.mpr (Nat.lt_succ_iff.mpr h), ofNat_encode c⟩
def hierarchyStates (bound labels : ℕ) : List (List Code) := words (codeAlphabet bound) labels
theorem mem_hierarchyStates (bound labels : ℕ) (cs : List Code) :
cs ∈ hierarchyStates bound labels ↔
cs.length = labels ∧ ∀ c ∈ cs, encode c ≤ bound := by
simp only [hierarchyStates, mem_words, mem_codeAlphabet]
end FixedClauseThreshold.Computability
end OAI