openAI-math-dataset / lean /OAI /Combinatorics /EditApproximation /Probability /FiniteQueryRestriction.lean
| import OAI.Combinatorics.EditApproximation.Probability.FiniteQueryWork | |
| import OAI.Combinatorics.EditApproximation.Definitions | |
| namespace OAI | |
| /-! Restriction of adaptive read programs to a proved finite request domain. | |
| The restriction visits the same reads whenever the original execution stays | |
| in that domain. It does not enumerate the domain. -/ | |
| namespace EditApproximation.FiniteQuery | |
| theorem mapKeys_id {ι : Type*} (program : FiniteQuery ι) : mapKeys id program = program := by | |
| induction program with | |
| | done result => rfl | |
| | read key next ih => | |
| simp only [mapKeys, id_eq] | |
| congr | |
| funext answer | |
| exact ih answer | |
| theorem mapKeys_value {ι κ : Type*} (f : ι → κ) (oracle : κ → ℚ) (program : FiniteQuery ι) : | |
| (mapKeys f program).value oracle = program.value (oracle ∘ f) := by | |
| induction program with | |
| | done result => rfl | |
| | read key next ih => exact ih (oracle (f key)) | |
| theorem mapKeys_cost {ι κ : Type*} (f : ι → κ) (oracle : κ → ℚ) (weight : κ → ℕ) | |
| (program : FiniteQuery ι) : | |
| (mapKeys f program).cost oracle weight = program.cost (oracle ∘ f) (weight ∘ f) := by | |
| induction program with | |
| | done result => rfl | |
| | read key next ih => exact congrArg (fun rest => weight (f key) + rest) (ih (oracle (f key))) | |
| theorem mapKeys_keys {ι κ : Type*} (f : ι → κ) (oracle : κ → ℚ) (program : FiniteQuery ι) : | |
| (mapKeys f program).keys oracle = (program.keys (oracle ∘ f)).map f := by | |
| induction program with | |
| | done result => rfl | |
| | read key next ih => exact congrArg (List.cons (f key)) (ih (oracle (f key))) | |
| theorem restrict_value {ι : Type*} (P : ι → Prop) [DecidablePred P] | |
| (oracle : ι → ℚ) (program : FiniteQuery ι) | |
| (hvalid : ∀ key ∈ program.keys oracle, P key) : | |
| (restrict P program).value (fun key => oracle key.val) = program.value oracle := by | |
| induction program with | |
| | done result => rfl | |
| | read key next ih => | |
| have hk : P key := hvalid key (by simp only [keys, List.mem_cons, true_or]) | |
| have hnext : ∀ other ∈ (next (oracle key)).keys oracle, P other := by | |
| intro other hother | |
| exact hvalid other (List.mem_cons_of_mem key hother) | |
| simpa only [restrict, dite_eq_left hk, value] using ih (oracle key) hnext | |
| theorem restrict_cost {ι : Type*} (P : ι → Prop) [DecidablePred P] | |
| (oracle : ι → ℚ) (weight : ι → ℕ) (program : FiniteQuery ι) | |
| (hvalid : ∀ key ∈ program.keys oracle, P key) : | |
| (restrict P program).cost (fun key => oracle key.val) (fun key => weight key.val) = | |
| program.cost oracle weight := by | |
| induction program with | |
| | done result => rfl | |
| | read key next ih => | |
| have hk : P key := hvalid key (by simp only [keys, List.mem_cons, true_or]) | |
| have hnext : ∀ other ∈ (next (oracle key)).keys oracle, P other := by | |
| intro other hother | |
| exact hvalid other (List.mem_cons_of_mem key hother) | |
| simpa only [restrict, dite_eq_left hk, cost] using | |
| congrArg (fun rest => weight key + rest) (ih (oracle key) hnext) | |
| theorem restrict_keys {ι : Type*} (P : ι → Prop) [DecidablePred P] | |
| (oracle : ι → ℚ) (program : FiniteQuery ι) | |
| (hvalid : ∀ key ∈ program.keys oracle, P key) : | |
| ((restrict P program).keys (fun key => oracle key.val)).map Subtype.val = program.keys oracle := by | |
| induction program with | |
| | done result => rfl | |
| | read key next ih => | |
| have hk : P key := hvalid key (by simp only [keys, List.mem_cons, true_or]) | |
| have hnext : ∀ other ∈ (next (oracle key)).keys oracle, P other := by | |
| intro other hother | |
| exact hvalid other (List.mem_cons_of_mem key hother) | |
| simpa only [restrict, dite_eq_left hk, keys, List.map_cons] using | |
| congrArg (List.cons key) (ih (oracle key) hnext) | |
| end EditApproximation.FiniteQuery | |
| end OAI | |