| 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 |
|
|
