Delete more LLM-generated comments from the migration

lean/Spa/Analysis/Forward/Adapters.lean

@@ -1,53 +1,32 @@
-/-
-Port of `Analysis/Forward/Adapters.agda` (`ExprToStmtAdapter`).
-
-Correspondence:
-  updateVariablesFromExpression           ↦ updateVariablesFromExpression
-  updateVariablesFromExpression-Mono      ↦ updateVariablesFromExpression_mono
-  (the -k∈ks-≡ / -k∉ks-backward renames   ↦ used directly from FiniteMap)
-  evalᵇ, evalᵇ-Monoʳ                      ↦ evalB, evalB_mono
-  stmtEvaluator (instance)                ↦ instance StmtEvaluator L prog
-  evalᵇ-valid, validStmtEvaluator         ↦ instance ValidStmtEvaluator L prog
-                                            (the Agda `k ≟ˢ k'` case split is
-                                            subsumed by `cases` on `Env.Mem`,
-                                            whose `here` case forces `k' = k`)
--/
 import Spa.Analysis.Forward.Evaluation
 
 namespace Spa
 
 variable {L : Type} [Lattice L] {prog : Program} [E : ExprEvaluator L prog]
 
-/-- Agda: `updateVariablesFromExpression` — set the single key `k` to the
-value of `e` (the `GeneralizedUpdate` with `ks = [k]`). -/
 def updateVariablesFromExpression (k : String) (e : Expr)
     (vs : VariableValues L prog) : VariableValues L prog :=
   FiniteMap.generalizedUpdate id (fun _ vs => E.eval e vs) [k] vs
 
-/-- Agda: `updateVariablesFromExpression-Mono`. -/
 theorem updateVariablesFromExpression_mono (k : String) (e : Expr) :
     Monotone (updateVariablesFromExpression (L := L) (prog := prog) k e) :=
   FiniteMap.generalizedUpdate_monotone monotone_id (fun _ => E.eval_mono e)
 
-/-- Agda: `evalᵇ`. -/
 def evalB (_ : prog.State) (bs : BasicStmt)
     (vs : VariableValues L prog) : VariableValues L prog :=
   match bs with
   | .assign k e => updateVariablesFromExpression k e vs
   | .noop => vs
 
-/-- Agda: `evalᵇ-Monoʳ`. -/
 theorem evalB_mono (s : prog.State) (bs : BasicStmt) :
     Monotone (evalB (L := L) (prog := prog) s bs) := by
   cases bs with
   | assign k e => exact updateVariablesFromExpression_mono k e
   | noop => exact monotone_id
 
-/-- Agda: the `stmtEvaluator` instance of `ExprToStmtAdapter`. -/
 instance ExprEvaluator.toStmtEvaluator : StmtEvaluator L prog :=
   ⟨evalB, evalB_mono⟩
 
-/-- Agda: `evalᵇ-valid` / the `validStmtEvaluator` instance. -/
 instance ExprEvaluator.toStmtEvaluator_valid [LatticeInterpretation L]
     [ValidExprEvaluator L prog] : ValidStmtEvaluator L prog := by
   constructor

lean/Spa/Analysis/Forward/Evaluation.lean

@@ -1,39 +1,22 @@
-/-
-Port of `Analysis/Forward/Evaluation.agda`.
-
-All four records were consumed through Agda instance arguments (`{{evaluator :
-StmtEvaluator}}`, `{{validEvaluator : ValidStmtEvaluator …}}`), so they are
-typeclasses here as well.
-
-Correspondence:
-  StmtEvaluator (eval, eval-Monoʳ)  ↦ StmtEvaluator (eval, eval_mono)
-  ExprEvaluator (eval, eval-Monoʳ)  ↦ ExprEvaluator (eval, eval_mono)
-  ValidExprEvaluator                ↦ ValidExprEvaluator (valid)
-  ValidStmtEvaluator                ↦ ValidStmtEvaluator (valid)
--/
 import Spa.Analysis.Forward.Lattices
 
 namespace Spa
 
 variable (L : Type) [Lattice L] (prog : Program)
 
-/-- Agda: `StmtEvaluator`. -/
 class StmtEvaluator where
   eval : prog.State → BasicStmt → VariableValues L prog → VariableValues L prog
   eval_mono : ∀ s bs, Monotone (eval s bs)
 
-/-- Agda: `ExprEvaluator`. -/
 class ExprEvaluator where
   eval : Expr → VariableValues L prog → L
   eval_mono : ∀ e, Monotone (eval e)
 
-/-- Agda: `ValidExprEvaluator`. -/
 class ValidExprEvaluator [ExprEvaluator L prog] [I : LatticeInterpretation L] :
     Prop where
   valid : ∀ {vs : VariableValues L prog} {ρ : Env} {e : Expr} {v : Value},
     EvalExpr ρ e v → interpV vs ρ → I.interp (ExprEvaluator.eval e vs) v
 
-/-- Agda: `ValidStmtEvaluator`. -/
 class ValidStmtEvaluator [E : StmtEvaluator L prog] [LatticeInterpretation L] :
     Prop where
   valid : ∀ {s : prog.State} {vs : VariableValues L prog} {ρ₁ ρ₂ : Env}

lean/Spa/Analysis/Forward/Lattices.lean

@@ -1,32 +1,3 @@
-/-
-Port of `Analysis/Forward/Lattices.agda`.
-
-The Agda module instantiates `Lattice.FiniteMap` twice (variables ↦ abstract
-values, states ↦ variable maps) and re-exports everything with ᵛ/ᵐ suffixes.
-In Lean the two instantiations are `abbrev`s and the FiniteMap API is used
-directly; the module parameters (the finite-height lattice `L`, the program)
-become section variables, with the finite-height structure and the lattice
-interpretation arriving by instance resolution as in Agda.
-
-Correspondence:
-  VariableValues, StateVariables  ↦ VariableValues, StateVariables
-  isLatticeᵛ/isLatticeᵐ, ⊔ᵛ, ≼ᵛ … ↦ (the FiniteMap Lattice instances)
-  fixedHeightᵛ, fixedHeightᵐ      ↦ (the FiniteMap FiniteHeightLattice instance)
-  ⊥ᵛ, ⊥ᵛ-contains-bottoms         ↦ botV, FiniteMap.bot_contains_bots
-  states-in-Map                   ↦ states_memKey
-  variablesAt                     ↦ variablesAt
-  variablesAt-∈                   ↦ variablesAt_mem
-  variablesAt-≈                   ↦ (congruence, trivial with `=`)
-  joinForKey, joinForKey-Mono     ↦ joinForKey, joinForKey_mono
-  joinAll, joinAll-Mono,
-  joinAll-k∈ks-≡                  ↦ joinAll, joinAll_mono, joinAll_mem_eq
-  variablesAt-joinAll             ↦ variablesAt_joinAll
-  ⟦_⟧ᵛ                            ↦ interpV
-  ⟦⊥ᵛ⟧ᵛ∅                          ↦ interpV_botV_nil
-  ⟦⟧ᵛ-respects-≈ᵛ                 ↦ (trivial with `=`)
-  ⟦⟧ᵛ-⊔ᵛ-∨                        ↦ interpV_sup
-  ⟦⟧ᵛ-foldr                       ↦ interpV_foldr
--/
 import Spa.Language
 import Spa.Lattice.FiniteMap
 
@@ -34,36 +5,29 @@ namespace Spa
 
 variable (L : Type) [Lattice L] (prog : Program)
 
-/-- Agda: `VariableValues`. -/
 abbrev VariableValues : Type := FiniteMap String L prog.vars
 
-/-- Agda: `StateVariables`. -/
 abbrev StateVariables : Type := FiniteMap prog.State (VariableValues L prog) prog.states
 
-/-- Agda: `⊥ᵛ` (the bottom of `fixedHeightᵛ`, now found by instance search). -/
 def botV [FiniteHeightLattice L] : VariableValues L prog :=
   (⊥ : VariableValues L prog)
 
 variable {L prog}
 
 omit [Lattice L] in
-/-- Agda: `states-in-Map`. -/
 theorem states_memKey (s : prog.State) (sv : StateVariables L prog) :
     FiniteMap.MemKey s sv :=
   FiniteMap.memKey_iff.mpr (prog.states_complete s)
 
-/-- Agda: `variablesAt`. -/
 def variablesAt (s : prog.State) (sv : StateVariables L prog) :
     VariableValues L prog :=
   (FiniteMap.locate (states_memKey s sv)).1
 
 omit [Lattice L] in
-/-- Agda: `variablesAt-∈`. -/
 theorem variablesAt_mem (s : prog.State) (sv : StateVariables L prog) :
     (s, variablesAt s sv) ∈ sv :=
   (FiniteMap.locate (states_memKey s sv)).2
 
-/-- Agda: `m₁≼m₂⇒m₁[k]ᵐ≼m₂[k]ᵐ`, specialized the way `Forward.agda` uses it. -/
 theorem variablesAt_le {sv₁ sv₂ : StateVariables L prog} (hle : sv₁ ≤ sv₂)
     (s : prog.State) : variablesAt s sv₁ ≤ variablesAt s sv₂ :=
   FiniteMap.le_of_mem_mem prog.states_nodup hle
@@ -71,12 +35,10 @@ theorem variablesAt_le {sv₁ sv₂ : StateVariables L prog} (hle : sv₁ ≤ sv
 
 variable [FiniteHeightLattice L]
 
-/-- Agda: `joinForKey`. -/
 def joinForKey (k : prog.State) (sv : StateVariables L prog) :
     VariableValues L prog :=
   (sv.valuesAt (prog.incoming k)).foldr (· ⊔ ·) (botV L prog)
 
-/-- Agda: `joinForKey-Mono`. -/
 theorem joinForKey_mono (k : prog.State) :
     Monotone (joinForKey (L := L) k) := by
   intro sv₁ sv₂ hle
@@ -84,21 +46,17 @@ theorem joinForKey_mono (k : prog.State) :
     (fun b _ _ hab => sup_le_sup_right hab b)
     (fun a _ _ hab => sup_le_sup_left hab a)
 
-/-- Agda: `joinAll` (the "Exercise 4.26" generalized update with `f = id`). -/
 def joinAll (sv : StateVariables L prog) : StateVariables L prog :=
   FiniteMap.generalizedUpdate id joinForKey prog.states sv
 
-/-- Agda: `joinAll-Mono`. -/
 theorem joinAll_mono : Monotone (joinAll (L := L) (prog := prog)) :=
   FiniteMap.generalizedUpdate_monotone monotone_id joinForKey_mono
 
-/-- Agda: `joinAll-k∈ks-≡`. -/
 theorem joinAll_mem_eq {s : prog.State} {vs : VariableValues L prog}
     {sv : StateVariables L prog} (h : (s, vs) ∈ joinAll sv) :
     vs = joinForKey s sv :=
   FiniteMap.generalizedUpdate_mem_eq (prog.states_complete s) h
 
-/-- Agda: `variablesAt-joinAll`. -/
 theorem variablesAt_joinAll (s : prog.State) (sv : StateVariables L prog) :
     variablesAt s (joinAll sv) = joinForKey s sv :=
   joinAll_mem_eq (variablesAt_mem s (joinAll sv))
@@ -108,18 +66,15 @@ theorem variablesAt_joinAll (s : prog.State) (sv : StateVariables L prog) :
 variable [I : LatticeInterpretation L]
 
 omit [FiniteHeightLattice L] in
-/-- Agda: `⟦_⟧ᵛ`. -/
 def interpV (vs : VariableValues L prog) (ρ : Env) : Prop :=
   ∀ (k : String) (l : L), (k, l) ∈ vs →
     ∀ (v : Value), Env.Mem (k, v) ρ → I.interp l v
 
-/-- Agda: `⟦⊥ᵛ⟧ᵛ∅`. -/
 theorem interpV_botV_nil : interpV (botV L prog) [] := by
   intro k l _ v hmem
   cases hmem
 
 omit [FiniteHeightLattice L] in
-/-- Agda: `⟦⟧ᵛ-⊔ᵛ-∨`. -/
 theorem interpV_sup {vs₁ vs₂ : VariableValues L prog} {ρ : Env}
     (h : interpV vs₁ ρ ∨ interpV vs₂ ρ) : interpV (vs₁ ⊔ vs₂) ρ := by
   intro k l hmem v hv
@@ -128,7 +83,6 @@ theorem interpV_sup {vs₁ vs₂ : VariableValues L prog} {ρ : Env}
   · exact I.interp_sup v (Or.inl (h _ _ h₁ _ hv))
   · exact I.interp_sup v (Or.inr (h _ _ h₂ _ hv))
 
-/-- Agda: `⟦⟧ᵛ-foldr`. -/
 theorem interpV_foldr {vs : VariableValues L prog}
     {vss : List (VariableValues L prog)} {ρ : Env}
     (hvs : interpV vs ρ) (hmem : vs ∈ vss) :