Use a unified representation for all trace types

lean/Spa/Analysis/Forward.lean

@@ -99,15 +99,18 @@ lemma walkPrefix : ∀ {s₂ s : prog.State} {ρ₂ ρin : Env}
     ⟦ joinForKey s₂ (result L prog) ⟧ (S.Pre trₗ) →
     ⟦ joinForKey s (result L prog) ⟧ (S.Pre (trₗ ++ mid)) := by
   intro s₂ s ρ₂ ρin mid
-  induction mid with
-  | nil => intro s₁ ρ₁ trₗ hjoin; simpa [HAppend.hAppend, Traceₗ.append] using hjoin
-  | cons hnode hedge rest ih =>
+  match mid with
+  | Traceₗ.nil =>
+      intro s₁ ρ₁ trₗ hjoin
+      simpa only [HAppend.hAppend, Path.append_nil] using hjoin
+  | Traceₗ.cons hnode hedge rest =>
       intro s₁ ρ₁ trₗ hjoin
       have hstep := stepTrace trₗ hjoin hnode
       have hmem := FiniteMap.mem_valuesAt prog.states_nodup
         (prog.mem_incoming_of_edge hedge) (variablesAt_mem _ (result L prog))
-      simpa [HAppend.hAppend, Traceₗ.append] using
-        ih ((trₗ ++ hnode).addEdge hedge)
+      simpa only [HAppend.hAppend, Traceₗ.appendStep, Trace.addEdge,
+        Path.append_assoc, Path.single, Path.append] using
+        walkPrefix rest ((trₗ ++ hnode).addEdge hedge)
           (interp_foldr (S.post_pre (trₗ ++ hnode) hedge hstep) hmem)
 
 omit [DecidableEq L] in

lean/Spa/Analysis/Reaching.lean

@@ -42,7 +42,7 @@ def output : String :=
 
 /-- The statements a trace executed, paired with the state each executed at,
     most recent first (matching `LastAssign`, which scans for the most recent
-    assignment). This is `Trace.steps` (chronological) reversed, so facts about
+    assignment). This is `Path.steps` (chronological) reversed, so facts about
     concatenating traces reduce to mathlib's `List.append`/`List.reverse` lemmas. -/
 abbrev Run (prog : Program) : Type := List (prog.State × BasicStmt)
 
@@ -55,18 +55,19 @@ inductive LastAssign (prog : Program) (x : String) : Run prog → prog.State →
       (∀ e, bs ≠ .assign x e) → LastAssign prog x rest n →
       LastAssign prog x ((s, bs) :: rest) n
 
-def runOfTraceₗ {s₁ s₂ : prog.State} {ρ₁ ρ₂ : Env}
-    (tr : Traceₗ prog.cfg s₁ s₂ ρ₁ ρ₂) : Run prog :=
-  tr.steps.reverse
+def runOfPath {a b : Configuration prog.cfg} (p : Path prog.cfg a b) : Run prog :=
+  p.steps.reverse
 
-def runOfTrace {s₁ s₂ : prog.State} {ρ₁ ρ₂ : Env}
-    (tr : Trace prog.cfg s₁ s₂ ρ₁ ρ₂) : Run prog :=
-  tr.steps.reverse
+abbrev runOfTraceₗ {s₁ s₂ : prog.State} {ρ₁ ρ₂ : Env}
+    (tr : Traceₗ prog.cfg s₁ s₂ ρ₁ ρ₂) : Run prog := runOfPath prog tr
+
+abbrev runOfTrace {s₁ s₂ : prog.State} {ρ₁ ρ₂ : Env}
+    (tr : Trace prog.cfg s₁ s₂ ρ₁ ρ₂) : Run prog := runOfPath prog tr
 
 instance stateInterp : StateInterpretation (DefSet prog) prog where
   Proj := Run prog
-  Pre := @runOfTraceₗ prog
-  Post := @runOfTrace prog
+  Pre := fun tr => runOfPath prog tr
+  Post := fun tr => runOfPath prog tr
 
   interp vs run := ∀ (x : String) (assigners : DefSet prog), (x, assigners) ∈ vs →
     ∀ (n : prog.State), LastAssign prog x run n → n ∈ assigners
@@ -81,7 +82,8 @@ instance stateInterp : StateInterpretation (DefSet prog) prog where
 
   post_pre := by
     intro vs s₁ s₂ s₃ ρ₁ ρ₂ tr hedge hvs
-    simpa [runOfTrace, runOfTraceₗ] using hvs
+    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)
@@ -109,8 +111,10 @@ private lemma valid_step (s : prog.State) {ρ₁ ρ₂ : Env}
 instance validStateEvaluator : ValidStateEvaluator (DefSet prog) prog where
   valid := by
     intro s₁ s₂ ρ₁ ρ₂ ρ₃ vs tr hbs hvs
-    show ⟦eval prog s₂ vs⟧ (runOfTrace prog (tr ++ hbs))
-    simpa [runOfTrace, runOfTraceₗ] using valid_step prog s₂ rfl 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
   botV_init := by intro x assigners _ n hla; cases hla
 
 theorem analyze_correct {ρ : Env} (hrun : EvalStmt [] prog.rootStmt ρ) :