Migrate most of the codebase (sans Reaching.lean / LICM left) to projections

lean/Spa/Language/Program.lean

@@ -50,6 +50,7 @@ lemma states_nodup : p.states.Nodup := p.cfg.nodup_indices
     At this time, for convenience of proofs, the CFGs have at most
     one basic statement, and multi-statement basic blocks are encoded
     as chains of blocks. Thus, this returns at most one `Spa.BasicStmt`. -/
+@[reducible]
 def code (st : p.State) : Option BasicStmt := p.cfg.nodes st
 
 /-- Get the predecessors of a particular CFG node / program state. -/

lean/Spa/Language/Traces.lean

@@ -93,12 +93,17 @@ def Trace.addEdge {g : Graph} {idx₁ idx₂ idx₃ : g.Index} {ρ₁ ρ₂ : En
   | .single hnode, hedge => .cons hnode hedge .nil
   | .edge hnode hedge' rest, hedge => .cons hnode hedge' (rest.addEdge hedge)
 
+@[aesop simp]
 def Traceₗ.append {g : Graph} {idx₁ idx₂ idx₃ : g.Index} {ρ₁ ρ₂ ρ₃ : Env} :
     Traceₗ g idx₁ idx₂ ρ₁ ρ₂ → Traceₗ g idx₂ idx₃ ρ₂ ρ₃ →
     Traceₗ g idx₁ idx₃ ρ₁ ρ₃
   | .nil, rhs => rhs
   | .cons hnode hedge rest, rhs => .cons hnode hedge (rest.append rhs)
 
+@[simp] def traceₗ_append_nil {g : Graph} {idx₁ idx₂ : g.Index} {ρ₁ ρ₂ : Env}
+    {trₗ : Traceₗ g idx₁ idx₂ ρ₁ ρ₂} : trₗ.append Traceₗ.nil = trₗ := by
+  induction trₗ <;> aesop
+
 def Traceₗ.appendTrace {g : Graph} {idx₁ idx₂ idx₃ : g.Index} {ρ₁ ρ₂ ρ₃ : Env} :
     Traceₗ g idx₁ idx₂ ρ₁ ρ₂ → Trace g idx₂ idx₃ ρ₂ ρ₃ →
     Trace g idx₁ idx₃ ρ₁ ρ₃
@@ -107,9 +112,7 @@ def Traceₗ.appendTrace {g : Graph} {idx₁ idx₂ idx₃ : g.Index} {ρ₁ ρ
 
 def Traceₗ.appendStep {g : Graph} {idx₁ idx₂ : g.Index} {ρ₁ ρ₂ ρ₃ : Env} :
     Traceₗ g idx₁ idx₂ ρ₁ ρ₂ → EvalBasicStmtOpt ρ₂ (g.nodes idx₂) ρ₃ →
-    Trace g idx₁ idx₂ ρ₁ ρ₃
-  | .nil, rhs => .single rhs
-  | .cons hnode hedge rest, rhs => .edge hnode hedge (rest.appendStep rhs)
+    Trace g idx₁ idx₂ ρ₁ ρ₃ := fun trₗ hbs => trₗ.appendTrace (Trace.single hbs)
 
 def Trace.appendRight {g : Graph} {idx₁ idx₂ idx₃ : g.Index} {ρ₁ ρ₂ ρ₃ : Env} :
     Trace g idx₁ idx₂ ρ₁ ρ₂ → Traceᵣ g idx₂ idx₃ ρ₂ ρ₃ →
@@ -133,53 +136,73 @@ instance instHAppendTraceTraceR {g : Graph} {idx₁ idx₂ idx₃ : g.Index} {ρ
     HAppend (Trace g idx₁ idx₂ ρ₁ ρ₂) (Traceᵣ g idx₂ idx₃ ρ₂ ρ₃) (Trace g idx₁ idx₃ ρ₁ ρ₃) where
   hAppend := Trace.appendRight
 
+@[simp] lemma Traceₗ.append_addEdge {g : Graph}
+    {idx₁ idx₂ idx₃ idx₄ : g.Index} {ρ₁ ρ₂ ρ₃ ρ₄ : Env}
+    (trₗ : Traceₗ g idx₁ idx₂ ρ₁ ρ₂)
+    (hnode : EvalBasicStmtOpt ρ₂ (g.nodes idx₂) ρ₃)
+    (hedge : (idx₂, idx₃) ∈ g.edges)
+    (rest : Traceₗ g idx₃ idx₄ ρ₃ ρ₄) :
+    trₗ.append (Traceₗ.cons hnode hedge rest) =
+      (Trace.addEdge (trₗ.appendStep hnode) hedge).append rest := by
+  induction trₗ <;> simp [Traceₗ.append, Traceₗ.appendStep, Traceₗ.appendTrace, Trace.addEdge, *]
+
+@[simp] lemma Traceₗ.appendTrace_addEdge {g : Graph}
+    {idx₁ idx₂ idx₃ idx₄ : g.Index} {ρ₁ ρ₂ ρ₃ ρ₄ : Env}
+    (trₗ : Traceₗ g idx₁ idx₂ ρ₁ ρ₂)
+    (hnode : EvalBasicStmtOpt ρ₂ (g.nodes idx₂) ρ₃)
+    (hedge : (idx₂, idx₃) ∈ g.edges)
+    (rest : Trace g idx₃ idx₄ ρ₃ ρ₄) :
+    trₗ.appendTrace (Trace.edge hnode hedge rest) =
+      (Trace.addEdge (trₗ.appendStep hnode) hedge).appendTrace rest := by
+  induction trₗ <;> simp [Traceₗ.appendTrace, Traceₗ.appendStep, Trace.addEdge, *]
+
 /-- A beginning-to-end trace corresponding to the CFG `g`. -/
 inductive EndToEndTrace (g : Graph) (ρ₁ ρ₂ : Env) : Type
   | intro (idx₁ : g.Index) (idx₁_mem : idx₁ ∈ g.inputs)
       (idx₂ : g.Index) (idx₂_mem : idx₂ ∈ g.outputs)
       (trace : Trace g idx₁ idx₂ ρ₁ ρ₂) : EndToEndTrace g ρ₁ ρ₂
 
-inductive MyReaches {prog : Program} : {s₁ s₂ : prog.State} → {ρ₁ ρ₂ : Env} →
+inductive Reaches {prog : Program} : {s₁ s₂ : prog.State} → {ρ₁ ρ₂ : Env} →
     Trace prog.cfg s₁ s₂ ρ₁ ρ₂ →
     (s : prog.State) → (ρin ρout : Env) → Type
   | single_here {s₁ : prog.State} {ρ₁ ρ₂ : Env}
       (hnode : EvalBasicStmtOpt ρ₁ (prog.code s₁) ρ₂) :
-      MyReaches (.single hnode) s₁ ρ₁ ρ₂
+      Reaches (.single hnode) s₁ ρ₁ ρ₂
   | edge_here {s₁ s₂ s₃ : prog.State} {ρ₁ ρ₂ ρ₃ : Env}
       (hnode : EvalBasicStmtOpt ρ₁ (prog.code s₁) ρ₂)
       (hedge : (s₁, s₂) ∈ prog.cfg.edges) (rest : Trace prog.cfg s₂ s₃ ρ₂ ρ₃) :
-      MyReaches (.edge hnode hedge rest) s₁ ρ₁ ρ₂
+      Reaches (.edge hnode hedge rest) s₁ ρ₁ ρ₂
   | edge_there {s₁ s₂ s₃ : prog.State} {ρ₁ ρ₂ ρ₃ : Env}
       (hnode : EvalBasicStmtOpt ρ₁ (prog.code s₁) ρ₂)
       (hedge : (s₁, s₂) ∈ prog.cfg.edges) (rest : Trace prog.cfg s₂ s₃ ρ₂ ρ₃)
       {s : prog.State} {ρin ρout : Env} :
-      MyReaches rest s ρin ρout →
-      MyReaches (.edge hnode hedge rest) s ρin ρout
+      Reaches rest s ρin ρout →
+      Reaches (.edge hnode hedge rest) s ρin ρout
 
-def MyReaches.pre {prog : Program} {s₁ s₂ s: prog.State}
+def Reaches.pre {prog : Program} {s₁ s₂ s: prog.State}
     {ρ₁ ρ₂ ρin ρout : Env} {tr : Trace prog.cfg s₁ s₂ ρ₁ ρ₂} :
-    (r : MyReaches tr s ρin ρout) → Traceₗ prog.cfg s₁ s ρ₁ ρin
+    (r : Reaches tr s ρin ρout) → Traceₗ prog.cfg s₁ s ρ₁ ρin
   | .single_here _ => .nil
   | .edge_here _ _ _ => .nil
   | .edge_there hnode hedge _ r => .cons hnode hedge r.pre
 
-def MyReaches.post {prog : Program} {s₁ s₂ s: prog.State}
+def Reaches.post {prog : Program} {s₁ s₂ s: prog.State}
     {ρ₁ ρ₂ ρin ρout : Env} {tr : Trace prog.cfg s₁ s₂ ρ₁ ρ₂} :
-    (r : MyReaches tr s ρin ρout) → Trace prog.cfg s₁ s ρ₁ ρout
+    (r : Reaches tr s ρin ρout) → Trace prog.cfg s₁ s ρ₁ ρout
   | .single_here hnode => .single hnode
   | .edge_here hnode _ _ => .single hnode
   | .edge_there hnode hedge _ r => .edge hnode hedge r.post
 
-def MyReaches.first {prog : Program} {s₁ s₂ s: prog.State}
+def Reaches.first {prog : Program} {s₁ s₂ s: prog.State}
     {ρ₁ ρ₂ ρin ρout : Env} {tr : Trace prog.cfg s₁ s₂ ρ₁ ρ₂} :
-    (r : MyReaches tr s ρin ρout) → Σ ρ₁', MyReaches tr s₁ ρ₁ ρ₁'
+    (r : Reaches tr s ρin ρout) → Σ ρ₁', Reaches tr s₁ ρ₁ ρ₁'
   | .single_here hnode => ⟨_, .single_here hnode⟩
   | .edge_here hnode hedge hrest => ⟨_, .edge_here hnode hedge hrest⟩
   | .edge_there hnode hedge hrest tmp' => ⟨_, .edge_here hnode hedge hrest⟩
 
-def MyReaches.step {prog : Program} {s₁ s₂ s: prog.State}
+def Reaches.step {prog : Program} {s₁ s₂ s: prog.State}
     {ρ₁ ρ₂ ρin ρout : Env} {tr : Trace prog.cfg s₁ s₂ ρ₁ ρ₂} :
-    (r : MyReaches tr s ρin ρout) → EvalBasicStmtOpt ρin (prog.code s) ρout
+    (r : Reaches tr s ρin ρout) → EvalBasicStmtOpt ρin (prog.code s) ρout
   | .single_here hnode => hnode
   | .edge_here hnode hedge hrest => hnode
   | .edge_there hnode hedge hrest tmp' => tmp'.step