openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Machines /FiniteEncodedHistory.lean
| import OAI.Combinatorics.ContingencyTables.Transport.FiniteAdaptiveObservable | |
| namespace OAI | |
| /-! # Complete histories under an encoded transition law -/ | |
| namespace ContingencyTables.FiniteObservableTransport | |
| open CommonBasesFPRAS | |
| open scoped Classical | |
| def traceAfter {C U : Type*} (step : C → U → C) (c : C) : List U → List C | |
| | [] => [] | |
| | u::us => let d := step c u; d::traceAfter step d us | |
| def traceStates {C U : Type*} (step : C → U → C) (c : C) (us : List U) : List C := | |
| c::traceAfter step c us | |
| lemma traceAfter_map {C U V : Type*} (F : C → U → C) (f : V → U) | |
| (vs : List V) (c : C) : | |
| traceAfter F c (vs.map f)=traceAfter (fun c v => F c (f v)) c vs := by | |
| induction vs generalizing c with | |
| | nil => rfl | |
| | cons v vs ih => simp only [List.map_cons,traceAfter,ih] | |
| lemma traceStates_map {C U V : Type*} (F : C → U → C) (f : V → U) | |
| (vs : List V) (c : C) : | |
| traceStates F c (vs.map f)=traceStates (fun c v => F c (f v)) c vs := by | |
| unfold traceStates | |
| rw [traceAfter_map] | |
| noncomputable section | |
| variable {C Z U V : Type*} [Fintype U] [Fintype V] | |
| /-- Equality of the encoded row laws transfers the whole finite history, | |
| including observables depending on every visited state. -/ | |
| theorem traceStates_sameLaw (F : C → U → C) (G : Z → V → Z) (e : Z → C) | |
| (h : ∀ z,SameLaw (F (e z)) (fun v => e (G z v))) (z : Z) (N : ℕ) : | |
| SameLaw (fun us : Fin N → U => traceStates F (e z) (List.ofFn us)) | |
| (fun vs : Fin N → V => (traceStates G z (List.ofFn vs)).map e) := by | |
| intro phi | |
| induction N generalizing z phi with | |
| | zero => simp only [List.ofFn_zero,traceStates,traceAfter,List.map_cons,List.map_nil, | |
| uniformAverage_const] | |
| | succ N ih => | |
| rw [uniformAverage_fin_succ,uniformAverage_fin_succ] | |
| simp only [List.ofFn_cons,traceStates,traceAfter,List.map_cons] | |
| have he := h z (fun c => uniformAverage (fun us : Fin N → U => | |
| phi (e z::traceStates F c (List.ofFn us)))) | |
| refine he.trans ?_ | |
| apply congrArg uniformAverage | |
| funext v | |
| exact ih (G z v) (fun cs => phi (e z::cs)) | |
| /-- The same encoding argument also transports a terminal state without | |
| requiring a decoder or finiteness of the encoded state space. -/ | |
| theorem foldl_sameLaw (F : C → U → C) (G : Z → V → Z) (e : Z → C) | |
| (h : ∀ z,SameLaw (F (e z)) (fun v => e (G z v))) (z : Z) (N : ℕ) : | |
| SameLaw (fun us : Fin N → U => (List.ofFn us).foldl F (e z)) | |
| (fun vs : Fin N → V => e ((List.ofFn vs).foldl G z)) := by | |
| intro phi | |
| induction N generalizing z phi with | |
| | zero => simp only [List.ofFn_zero,List.foldl_nil,uniformAverage_const] | |
| | succ N ih => | |
| rw [uniformAverage_fin_succ,uniformAverage_fin_succ] | |
| simp only [List.ofFn_cons,List.foldl_cons] | |
| have he := h z (fun c => uniformAverage (fun us : Fin N → U => | |
| phi ((List.ofFn us).foldl F c))) | |
| refine he.trans ?_ | |
| apply congrArg uniformAverage | |
| funext v | |
| exact ih (G z v) phi | |
| omit [Fintype U] in | |
| /-- The reverse accumulator used by a bounded fold has precisely the | |
| chronological history after reversing its stored list. -/ | |
| lemma traceAfter_fold (F : C → U → C) (us : List U) (c : C) (history : List C) : | |
| (us.foldl (fun s u => let d := F s.1 u; (d,d::s.2)) (c,history)).2.reverse= | |
| history.reverse++traceAfter F c us := by | |
| induction us generalizing c history with | |
| | nil => simp only [List.foldl_nil,traceAfter,List.append_nil] | |
| | cons u us ih => | |
| simp only [List.foldl_cons,traceAfter] | |
| rw [ih,List.reverse_cons,List.append_assoc] | |
| rfl | |
| omit [Fintype U] in | |
| lemma traceStates_fold (F : C → U → C) (us : List U) (c : C) : | |
| (us.foldl (fun s u => let d := F s.1 u; (d,d::s.2)) (c,[c])).2.reverse= | |
| traceStates F c us := by | |
| rw [traceAfter_fold] | |
| rfl | |
| end | |
| end ContingencyTables.FiniteObservableTransport | |
| end OAI | |