openAI-math-dataset / lean /OAI /Probability /CriticalPercolation /Exploration /CompileEmptyReads.lean
| import Mathlib | |
| import OAI.Probability.CriticalPercolation.Exploration.TargetSearch | |
| namespace OAI | |
| section | |
| section | |
| open Set MeasureTheory ProbabilityTheory | |
| open Set | |
| open scoped BigOperators | |
| open scoped Classical | |
| namespace CriticalPercolation.LazyDFS | |
| open scoped Classical | |
| open FiniteProduct SearchTree BondGraph | |
| variable {V E : Type*} [DecidableEq V] [DecidableEq E] | |
| lemma compile_empty_reads (G : BondGraph V E) (order : List (Dart V E)) (B : Set V) | |
| (fuel : ℕ) (st : State V E) (ω : E → Bool) : | |
| (compile G order B fuel st []).reads ω = [] := by | |
| cases fuel with | |
| | zero => rfl | |
| | succ n => | |
| rw [compile.eq_def] | |
| dsimp only | |
| split_ifs <;> rfl | |
| variable [Fintype V] | |
| theorem compile_reads_rank_independent (G : BondGraph V E) (order : List (Dart V E)) (B : Set V) | |
| (fuel fuel' : ℕ) (st : State V E) (stack : List (Dart V E)) (ω : E → Bool) | |
| (hr : rank order st stack ≤ fuel) (hr' : rank order st stack ≤ fuel') : | |
| (compile G order B fuel st stack).reads ω = (compile G order B fuel' st stack).reads ω := by | |
| induction fuel generalizing fuel' st stack with | |
| | zero => | |
| have hnil : stack = [] := by | |
| have : stack.length = 0 := by unfold rank at hr; omega | |
| exact List.length_eq_zero_iff.mp this | |
| subst stack | |
| rw [compile_empty_reads,compile_empty_reads] | |
| | succ n ih => | |
| cases fuel' with | |
| | zero => | |
| have hnil : stack = [] := by | |
| have : stack.length = 0 := by unfold rank at hr'; omega | |
| exact List.length_eq_zero_iff.mp this | |
| subst stack | |
| rw [compile_empty_reads,compile_empty_reads] | |
| | succ m => | |
| rw [compile.eq_def,compile.eq_def] | |
| dsimp only | |
| split_ifs with hh | |
| · rfl | |
| · cases stack with | |
| | nil => rfl | |
| | cons d rest => | |
| dsimp only | |
| split_ifs with hd | |
| · have hpop := rank_pop order st d rest | |
| exact ih m st rest (by omega) (by omega) | |
| · rw [reads,reads] | |
| congr 1 | |
| split_ifs with hω | |
| · have hopen := rank_opened G order st d rest (fun h => hd (Or.inl h)) | |
| exact ih m _ _ (by omega) (by omega) | |
| · have hclosed := rank_closed order st d rest | |
| exact ih m _ _ (by omega) (by omega) | |
| omit [Fintype V] [DecidableEq E] in | |
| lemma push_goodDarts (G : BondGraph V E) (order : List (Dart V E)) (v : V) : | |
| GoodDarts G (push G order v) := by | |
| intro d hd | |
| have hh := (List.mem_filter.mp hd).2 | |
| exact (of_decide_eq_true hh).2 | |
| omit [Fintype V] [DecidableEq V] [DecidableEq E] in | |
| lemma goodDarts_append (G : BondGraph V E) (l r : List (Dart V E)) | |
| (hl : GoodDarts G l) (hr : GoodDarts G r) : GoodDarts G (l++r) := by | |
| intro d hd | |
| exact (List.mem_append.mp hd).elim (hl d) (hr d) | |
| omit [Fintype V] in | |
| theorem compile_reads_targetWiring (G : BondGraph V E) (B : Set V) | |
| (order : List (Dart V E)) (horder : GoodDarts G order) (fuel : ℕ) | |
| (st : State V E) (stack : List (Dart V E)) (hs : GoodDarts G stack) | |
| (ω : E → Bool) : | |
| (compile G order B fuel st stack).reads ω = | |
| (compile (G.wireTargets B) (order.map (mapDart B)) {none} fuel (mapState B st) | |
| (stack.map (mapDart B))).reads ω := by | |
| induction fuel generalizing st stack with | |
| | zero => rfl | |
| | succ n ih => | |
| rw [compile.eq_def,compile.eq_def] | |
| dsimp only | |
| simp only [target_hit_map] | |
| split_ifs with hh | |
| · rfl | |
| · cases stack with | |
| | nil => rfl | |
| | cons d rest => | |
| have hd := hs d (List.mem_cons_self ..) | |
| have hd' := mapDart_ends G B d hd | |
| have hr : GoodDarts G rest := fun d h => hs d (List.mem_cons_of_mem _ h) | |
| simp only [List.map_cons] | |
| have hmem := mapState_mem B st hh | |
| have hRead : (mapState B st).read = st.read := rfl | |
| have hEnds : (G.wireTargets B).ends d.2.1 = | |
| s(collapseTarget B d.1, collapseTarget B d.2.2) := hd' | |
| simp only [mapDart, hRead, hEnds, hd, ne_eq, not_true_eq_false, or_false, hmem] | |
| split_ifs with hbad | |
| · exact ih st rest hr | |
| · rw [reads,reads] | |
| congr 1 | |
| split_ifs with hbit | |
| · by_cases hzB : d.2.2 ∈ B | |
| · have hstop := compile_stop G order B n (st.opened d.2.1 d.2.2) | |
| (push G order d.2.2++rest) ⟨d.2.2,Finset.mem_insert_self _ _,hzB⟩ | |
| have hzNone := (collapseTarget_eq_none B d.2.2).mpr hzB | |
| have hstop' := compile_stop (G.wireTargets B) (order.map (mapDart B)) {none} n | |
| ((mapState B st).opened d.2.1 (collapseTarget B d.2.2)) | |
| (push (G.wireTargets B) (order.map (mapDart B)) (collapseTarget B d.2.2) ++ | |
| rest.map (mapDart B)) | |
| ⟨none,by simp [State.opened,hzNone],Set.mem_singleton none⟩ | |
| rw [hstop,hstop']; rfl | |
| · have hnew := ih (st.opened d.2.1 d.2.2) (push G order d.2.2++rest) | |
| (goodDarts_append G _ _ (push_goodDarts G order d.2.2) hr) | |
| rw [mapState_opened,List.map_append,push_mapTarget G B order horder d.2.2 hzB] at hnew | |
| exact hnew | |
| · exact ih (st.closed d.2.1) rest hr | |
| end CriticalPercolation.LazyDFS | |
| end | |
| end | |
| end OAI | |