openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Machines /CanonicalKeyShapeMachineLemmas.lean
| import Mathlib.Data.List.Basic | |
| import OAI.Computability.PerfectCompleteness.Foundations.CanonicalEdgesLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.CanonicalVertexNames | |
| import OAI.Computability.PerfectCompleteness.Machines.FiniteBlockMachineLemmas | |
| namespace OAI | |
| namespace PerfectCompleteness.CanonicalKeyShapeMachine | |
| open Turing | |
| open UniqueGamesTheorem.Foundations.Complexity | |
| open CanonicalKeyShape CanonicalKeyEncoding CanonicalKeys | |
| noncomputable section | |
| def inputEnum (n k : Nat) : Input n k ≃ Fin (Fintype.card (Input n k)) := | |
| Fintype.equivFin _ | |
| def inputBits {n k : Nat} (data : Input n k) : List Bool := | |
| FiniteBlockMachine.word (inputEnum n k) data | |
| def defaultInput (n : Nat) {k : Nat} (hk : 0 < k) : Input n k := | |
| ⟨fun _ => Shape.bit, fun _ => ⟨0, hk⟩⟩ | |
| def modeEnum : SupportMode ≃ Fin (Fintype.card SupportMode) := Fintype.equivFin _ | |
| def modeWords {n : Nat} (support : Fin n → SupportMode) : List Nat := | |
| List.ofFn (fun i => (modeEnum (support i)).val) | |
| @[simp] theorem modeWords_length {n : Nat} (support : Fin n → SupportMode) : | |
| (modeWords support).length = n := List.length_ofFn | |
| theorem modeWords_injective (n : Nat) : Function.Injective (modeWords (n := n)) := by | |
| intro a b h | |
| have hfun := List.ofFn_injective h | |
| funext i | |
| apply modeEnum.injective | |
| exact Fin.ext (congrFun hfun i) | |
| def outputWords {n k : Nat} (data : Input n k) : List Nat := | |
| modeWords (inputModes data) ++ partitionWords (inputPartition data) | |
| def outputBits {n k : Nat} (data : Input n k) : List Bool := encodeWords (outputWords data) | |
| @[simp] theorem outputWords_length {n k : Nat} (data : Input n k) : | |
| (outputWords data).length = n + partitionWidth n := by | |
| simp only [outputWords, List.length_append, modeWords_length, partitionWords_length] | |
| theorem outputWords_eq_iff {n k : Nat} (a b : Input n k) : | |
| outputWords a = outputWords b ↔ | |
| inputModes a = inputModes b ∧ inputPartition a = inputPartition b := by | |
| constructor | |
| · intro h | |
| have hlen : (modeWords (inputModes a)).length = (modeWords (inputModes b)).length := by | |
| simp only [modeWords_length] | |
| have hp := List.append_inj h hlen | |
| exact ⟨modeWords_injective n hp.1, partitionWords_injective n hp.2⟩ | |
| · rintro ⟨hm, hp⟩ | |
| simp only [outputWords, hm, hp] | |
| theorem outputBits_eq_iff {n k : Nat} (a b : Input n k) : | |
| outputBits a = outputBits b ↔ | |
| inputModes a = inputModes b ∧ inputPartition a = inputPartition b := by | |
| constructor | |
| · intro h | |
| exact (outputWords_eq_iff a b).mp (encodeWords_injective h) | |
| · intro h | |
| exact congrArg encodeWords ((outputWords_eq_iff a b).mpr h) | |
| def computation (n : Nat) {k : Nat} (hk : 0 < k) : | |
| TM2ComputableInPolyTime (inputBits (n := n) (k := k)) id outputBits := | |
| FiniteWordMachine.computation (inputEnum n k) (defaultInput n hk) outputBits | |
| def machine_output {n k : Nat} (hk : 0 < k) (data : Input n k) : | |
| TM2OutputsInTime (computation n hk).tm (inputBits data) (some (outputBits data)) 1 := by | |
| have h := (computation n hk).outputsFun data | |
| change TM2OutputsInTime (computation n hk).tm ((inputBits data).map id) | |
| (some ((outputBits data).map id)) ((1 : Polynomial Nat).eval _) at h | |
| rw [Polynomial.eval_one] at h | |
| exact Eq.mp (congrArg₂ | |
| (fun (i o : List Bool) => TM2OutputsInTime (computation n hk).tm i (some o) 1) | |
| (List.map_id (inputBits data)) (List.map_id (outputBits data))) h | |
| def recoverKey {n k : Nat} (side : Side) (slots : Fin n → MixedSupport.Slot) | |
| (data : Input n k) : Key n := | |
| ⟨side, CanonicalKeyShape.retained slots (inputModes data), inputPartition data⟩ | |
| theorem recoverKey_input {n k : Nat} (side : Side) (slots : Fin n → MixedSupport.Slot) | |
| (f : MixedSupport.Assignment slots → Fin k) : | |
| recoverKey side slots (CanonicalKeyShape.input slots f) = CanonicalKeys.key side slots f := by | |
| simp only [recoverKey, CanonicalKeys.key, inputModes_recover, inputPartition_eq] | |
| theorem recoverKey_of_same_output {n k : Nat} (side : Side) | |
| (slots : Fin n → MixedSupport.Slot) (a b : Input n k) | |
| (same : outputBits a = outputBits b) : recoverKey side slots a = recoverKey side slots b := by | |
| obtain ⟨hm, hp⟩ := (outputBits_eq_iff a b).mp same | |
| simp only [recoverKey, hm, hp] | |
| theorem workAlphabet_finite (n : Nat) {k : Nat} (hk : 0 < k) | |
| (tape : (computation n hk).tm.K) : Finite ((computation n hk).tm.Γ tape) := by | |
| change Finite Bool | |
| infer_instance | |
| end | |
| end PerfectCompleteness.CanonicalKeyShapeMachine | |
| namespace PerfectCompleteness.CanonicalOnlineNames | |
| open CanonicalKeys | |
| section Lists | |
| variable {α : Type*} [BEq α] [LawfulBEq α] | |
| theorem firstIndex_append_current (earlier suffix : List α) (key : α) : | |
| (earlier ++ [key]).idxOf key = (earlier ++ key :: suffix).idxOf key := by | |
| have present : key ∈ earlier ++ [key] := by simp | |
| have found := List.idxOf_append_of_mem (l₂ := suffix) present | |
| simpa only [List.append_assoc, List.singleton_append] using found.symm | |
| theorem firstIndex_le_prefix (earlier : List α) (key : α) : | |
| (earlier ++ [key]).idxOf key ≤ earlier.length := by | |
| have found := List.idxOf_lt_length_of_mem (by simp : key ∈ earlier ++ [key]) | |
| simp only [List.length_append, List.length_singleton] at found | |
| omega | |
| theorem firstIndex_eq_prefix (earlier : List α) (key : α) : | |
| (earlier ++ [key]).idxOf key = earlier.idxOf key := by | |
| classical | |
| by_cases present : key ∈ earlier | |
| · exact List.idxOf_append_of_mem present | |
| · rw [List.idxOf_append_of_notMem present, List.idxOf_of_notMem present] | |
| simp | |
| end Lists | |
| noncomputable section | |
| variable {n : Nat} | |
| def onlineID (earlier : List (Key n)) (key : Key n) : Nat := | |
| (BinaryNameSearch.payloads (CanonicalVertexNames.tokens (earlier ++ [key]))).idxOf | |
| (CanonicalVertexNames.payload key) | |
| theorem tokens_append_current (earlier : List (Key n)) (key : Key n) : | |
| CanonicalVertexNames.tokens (earlier ++ [key]) = | |
| CanonicalVertexNames.tokens earlier ++ [(false, CanonicalVertexNames.payload key)] := by | |
| simp only [CanonicalVertexNames.tokens, List.map_append, List.map_cons, List.map_nil] | |
| theorem current_payload_mem (earlier : List (Key n)) (key : Key n) : | |
| CanonicalVertexNames.payload key ∈ | |
| BinaryNameSearch.payloads (CanonicalVertexNames.tokens (earlier ++ [key])) := | |
| CanonicalVertexNames.payload_mem _ _ (by simp) | |
| theorem dictionary_canonical (earlier : List (Key n)) (key : Key n) : | |
| ∀ token ∈ CanonicalVertexNames.tokens (earlier ++ [key]), | |
| BinaryNameMachine.canonical token.2 = true := | |
| CanonicalVertexNames.tokens_canonical _ | |
| theorem onlineID_le_prefix (earlier : List (Key n)) (key : Key n) : | |
| onlineID earlier key ≤ earlier.length := by | |
| have bound := firstIndex_le_prefix (earlier.map CanonicalVertexNames.payload) | |
| (CanonicalVertexNames.payload key) | |
| simpa only [onlineID, CanonicalVertexNames.tokens_payloads, List.map_append, | |
| List.map_cons, List.map_nil, List.length_map] using bound | |
| theorem onlineID_eq_global (earlier suffix : List (Key n)) (key : Key n) : | |
| onlineID earlier key = | |
| (BinaryNameSearch.payloads | |
| (CanonicalVertexNames.tokens (earlier ++ key :: suffix))).idxOf | |
| (CanonicalVertexNames.payload key) := by | |
| simpa only [onlineID, CanonicalVertexNames.tokens_payloads, List.map_append, | |
| List.map_cons, List.map_nil] using | |
| firstIndex_append_current (earlier.map CanonicalVertexNames.payload) | |
| (suffix.map CanonicalVertexNames.payload) (CanonicalVertexNames.payload key) | |
| theorem onlineID_eq_name_val (earlier suffix : List (Key n)) (key : Key n) : | |
| onlineID earlier key = | |
| (CanonicalVertexNames.name (earlier ++ key :: suffix) key (by simp)).val := | |
| onlineID_eq_global earlier suffix key | |
| theorem onlineID_eq_prefix_index (earlier : List (Key n)) (key : Key n) : | |
| onlineID earlier key = | |
| (BinaryNameSearch.payloads (CanonicalVertexNames.tokens earlier)).idxOf | |
| (CanonicalVertexNames.payload key) := by | |
| simpa only [onlineID, CanonicalVertexNames.tokens_payloads, List.map_append, | |
| List.map_cons, List.map_nil] using | |
| firstIndex_eq_prefix (earlier.map CanonicalVertexNames.payload) | |
| (CanonicalVertexNames.payload key) | |
| theorem onlineID_repeat (earlier middle : List (Key n)) (key : Key n) : | |
| onlineID (earlier ++ key :: middle) key = onlineID earlier key := by | |
| calc | |
| _ = (BinaryNameSearch.payloads | |
| (CanonicalVertexNames.tokens (earlier ++ key :: middle))).idxOf | |
| (CanonicalVertexNames.payload key) := onlineID_eq_prefix_index _ key | |
| _ = _ := (onlineID_eq_global earlier middle key).symm | |
| theorem onlineID_eq_iff_same_final (keys prefixA suffixA prefixB suffixB : List (Key n)) | |
| (a b : Key n) | |
| (first : keys = prefixA ++ a :: suffixA) | |
| (second : keys = prefixB ++ b :: suffixB) : | |
| onlineID prefixA a = onlineID prefixB b ↔ a = b := by | |
| have presentA : a ∈ keys := by rw [first]; simp | |
| rw [onlineID_eq_global prefixA suffixA a, onlineID_eq_global prefixB suffixB b, | |
| ← first, ← second] | |
| constructor | |
| · intro same | |
| apply CanonicalVertexNames.payload_injective n | |
| exact (List.idxOf_inj (CanonicalVertexNames.payload_mem keys a presentA)).mp same | |
| · intro same | |
| subst b | |
| rfl | |
| def onlineName (earlier : List (Key n)) (key : Key n) : Fin (earlier.length + 1) := | |
| ⟨onlineID earlier key, by have := onlineID_le_prefix earlier key; omega⟩ | |
| @[simp] theorem onlineName_val (earlier : List (Key n)) (key : Key n) : | |
| (onlineName earlier key).val = onlineID earlier key := rfl | |
| def paddedName (keys : List (Key n)) (vertices : Nat) (enough : keys.length ≤ vertices) | |
| (key : Key n) (present : key ∈ keys) : Fin vertices := | |
| ⟨(CanonicalVertexNames.name keys key present).val, | |
| lt_of_lt_of_le (CanonicalVertexNames.name keys key present).isLt enough⟩ | |
| @[simp] theorem paddedName_val (keys : List (Key n)) (vertices : Nat) | |
| (enough : keys.length ≤ vertices) (key : Key n) (present : key ∈ keys) : | |
| (paddedName keys vertices enough key present).val = | |
| (CanonicalVertexNames.name keys key present).val := rfl | |
| theorem paddedName_eq_iff (keys : List (Key n)) (vertices : Nat) | |
| (enough : keys.length ≤ vertices) (a b : Key n) (ha : a ∈ keys) (hb : b ∈ keys) : | |
| paddedName keys vertices enough a ha = paddedName keys vertices enough b hb ↔ a = b := by | |
| constructor | |
| · intro same | |
| apply (CanonicalVertexNames.name_eq_iff keys a b ha hb).mp | |
| apply Fin.ext | |
| exact congrArg (fun value : Fin vertices => value.val) same | |
| · intro same | |
| subst b | |
| rfl | |
| def paddedEmbedding (keys : List (Key n)) (vertices : Nat) (enough : keys.length ≤ vertices) : | |
| {key // key ∈ keys} ↪ Fin vertices where | |
| toFun key := paddedName keys vertices enough key.val key.property | |
| inj' := by | |
| intro a b same | |
| exact Subtype.ext ((paddedName_eq_iff keys vertices enough | |
| a.val b.val a.property b.property).mp same) | |
| def onlinePaddedName (earlier : List (Key n)) (key : Key n) (vertices : Nat) | |
| (room : earlier.length < vertices) : Fin vertices := | |
| ⟨onlineID earlier key, lt_of_le_of_lt (onlineID_le_prefix earlier key) room⟩ | |
| theorem onlinePaddedName_eq_final (earlier suffix : List (Key n)) (key : Key n) | |
| (vertices : Nat) (enough : (earlier ++ key :: suffix).length ≤ vertices) : | |
| onlinePaddedName earlier key vertices (by | |
| simp only [List.length_append, List.length_cons] at enough | |
| omega) = | |
| paddedName (earlier ++ key :: suffix) vertices enough key (by simp) := by | |
| apply Fin.ext | |
| exact onlineID_eq_name_val earlier suffix key | |
| end | |
| end PerfectCompleteness.CanonicalOnlineNames | |
| end OAI | |