Proof step and variable lemmas

1. no writes = save value
2. embedding commutation with steps
3. all variables in code end up in the set of vars

lean/Spa/Analysis/Reaching.lean

@@ -85,36 +85,34 @@ instance stateInterp : StateInterpretation (DefSet prog) prog where
     simpa only [runOfPath, Trace.addEdge, Path.steps_append, Path.single,
       Path.steps, Step.steps, List.append_nil] using hvs
 
-private lemma valid_step (s : prog.State) {ρ₁ ρ₂ : Env}
-    {obs : Option BasicStmt} (hcode : prog.code s = obs)
-    (hbs : EvalBasicStmtOpt ρ₁ obs ρ₂)
+private lemma valid_step (s : prog.State)
     {vs : VariableValues (DefSet prog) prog} {run : Run prog}
     (hvs : ⟦vs⟧ run) :
-    ⟦eval prog s vs⟧ ((hbs.steps s).reverse ++ run) := by
-  cases hbs with
-  | none => simpa [eval, hcode, EvalBasicStmtOpt.steps] using hvs
-  | some hbs =>
-  cases hbs with
-  | noop =>
-    simp [eval, hcode, EvalBasicStmtOpt.steps]
-    intro x assigners hmem n hla; aesop (add simp hcode)
-  | assign x e v hev =>
-    simp [eval, hcode, EvalBasicStmtOpt.steps]; intro k assigners hmem n hla
-    by_cases hx : k = x
-    · subst hx
-      have hd := FiniteMap.generalizedUpdate_mem_eq (List.mem_singleton.mpr rfl) hmem
-      rcases hla <;> simp [hd] <;> aesop (add simp hcode)
-    · have hmem' := FiniteMap.generalizedUpdate_not_mem_backward
-        (fun hc => hx (List.mem_singleton.mp hc)) hmem
-      aesop (add simp hcode)
+    ⟦eval prog s vs⟧ ((match prog.code s with | none => [] | some _ => [s]) ++ run) := by
+  cases hcode : prog.code s with
+  | none => simpa [eval, hcode] using hvs
+  | some bs =>
+    cases bs with
+    | noop =>
+      simp [eval, hcode]
+      intro x assigners hmem n hla; aesop (add simp hcode)
+    | assign x e =>
+      simp [eval, hcode]; intro k assigners hmem n hla
+      by_cases hx : k = x
+      · subst hx
+        have hd := FiniteMap.generalizedUpdate_mem_eq (List.mem_singleton.mpr rfl) hmem
+        rcases hla <;> simp [hd] <;> aesop (add simp hcode)
+      · have hmem' := FiniteMap.generalizedUpdate_not_mem_backward
+          (fun hc => hx (List.mem_singleton.mp hc)) hmem
+        aesop (add simp hcode)
 
 instance validStateEvaluator : ValidStateEvaluator (DefSet prog) prog where
   valid := by
     intro s₁ s₂ ρ₁ ρ₂ ρ₃ vs tr hbs hvs
     change ⟦vs⟧ (runOfPath prog tr) at hvs
     change ⟦eval prog s₂ vs⟧ (runOfPath prog (Path.append tr (.single (.execute hbs))))
-    simpa only [runOfPath, Path.steps_append, Path.single, Path.steps, Step.steps,
-      List.append_nil, List.reverse_append] using valid_step prog s₂ rfl hbs hvs
+    cases hcode : prog.code s₂ <;>
+      simpa [runOfPath, Path.single, Path.steps, Step.steps, hcode] using valid_step prog s₂ hvs
   botV_init := by intro x assigners _ n hla; cases hla
 
 theorem analyze_correct {ρ : Env} (hrun : EvalStmt [] prog.rootStmt ρ) :