Delete more LLM-generated comments from the migration

lean/Spa/Analysis/Constant.lean

@@ -1,29 +1,3 @@
-/-
-Port of `Analysis/Constant.agda`.
-
-Correspondence:
-  showable, ≡-equiv, ≡-Decidable-ℤ ↦ (mathlib/derived instances)
-  ConstLattice (AboveBelow ℤ)      ↦ ConstLattice
-  AB.Plain (+ 0)                   ↦ the AboveBelow FiniteHeightLattice instance,
-                                     seeded by `Inhabited ℤ` (default `0`)
-  plus, minus                      ↦ plus, minus
-  plus-Monoˡ/ʳ, minus-Monoˡ/ʳ (postulates in Agda!)
-                                   ↦ plus_mono_left/right, minus_mono_left/right
-                                     — now actually proved, via
-                                     AboveBelow.monotone₂_of_strict
-  plus-Mono₂, minus-Mono₂          ↦ plus_mono₂, minus_mono₂
-  ⟦_⟧ᶜ                             ↦ interpConst
-  ⟦⟧ᶜ-respects-≈ᶜ                  ↦ (trivial with `=`)
-  ⟦⟧ᶜ-⊔ᶜ-∨, ⟦⟧ᶜ-⊓ᶜ-∧               ↦ interpConst_sup, interpConst_inf
-  s₁≢s₂⇒¬s₁∧s₂                     ↦ interpConst_mk_disjoint
-  latticeInterpretationᶜ           ↦ constInterpretation
-  WithProg.eval, eval-Monoʳ        ↦ ConstAnalysis.eval, eval_mono
-  ConstEval                        ↦ ConstAnalysis.exprEvaluator
-  plus-valid, minus-valid          ↦ plus_valid, minus_valid
-  eval-valid, ConstEvalValid       ↦ eval_valid
-  output                           ↦ ConstAnalysis.output
-  analyze-correct                  ↦ ConstAnalysis.analyze_correct
--/
 import Spa.Analysis.Forward
 import Spa.Analysis.Utils
 import Spa.Interp
@@ -36,7 +10,6 @@ abbrev ConstLattice : Type := AboveBelow ℤ
 namespace ConstAnalysis
 
 open AboveBelow in
-/-- Agda: `plus`. -/
 def plus : ConstLattice → ConstLattice → ConstLattice
   | bot, _ => bot
   | _, bot => bot
@@ -45,7 +18,6 @@ def plus : ConstLattice → ConstLattice → ConstLattice
   | mk z₁, mk z₂ => mk (z₁ + z₂)
 
 open AboveBelow in
-/-- Agda: `minus`. -/
 def minus : ConstLattice → ConstLattice → ConstLattice
   | bot, _ => bot
   | _, bot => bot
@@ -53,44 +25,33 @@ def minus : ConstLattice → ConstLattice → ConstLattice
   | _, top => top
   | mk z₁, mk z₂ => mk (z₁ - z₂)
 
-/-- Agda: `plus-Mono₂` (its components were postulates in Agda; `plus` is a
-strict operation on the flat lattice, so monotonicity holds regardless of the
-constant table). -/
 theorem plus_mono₂ : Monotone₂ plus :=
   AboveBelow.monotone₂_of_strict plus
     (fun y => by cases y <;> rfl) (fun x => by cases x <;> rfl)
     (fun y hy => by cases y <;> first | exact absurd rfl hy | rfl)
     (fun x hx => by cases x <;> first | exact absurd rfl hx | rfl)
 
-/-- Agda: `plus-Monoˡ` — a postulate there, a theorem here. -/
 theorem plus_mono_left (s₂ : ConstLattice) : Monotone (plus · s₂) := plus_mono₂.1 s₂
 
-/-- Agda: `plus-Monoʳ` — a postulate there, a theorem here. -/
 theorem plus_mono_right (s₁ : ConstLattice) : Monotone (plus s₁) := plus_mono₂.2 s₁
 
-/-- Agda: `minus-Mono₂` (likewise from strictness of `minus`). -/
 theorem minus_mono₂ : Monotone₂ minus :=
   AboveBelow.monotone₂_of_strict minus
     (fun y => by cases y <;> rfl) (fun x => by cases x <;> rfl)
     (fun y hy => by cases y <;> first | exact absurd rfl hy | rfl)
     (fun x hx => by cases x <;> first | exact absurd rfl hx | rfl)
 
-/-- Agda: `minus-Monoˡ` — a postulate there, a theorem here. -/
 theorem minus_mono_left (s₂ : ConstLattice) : Monotone (minus · s₂) := minus_mono₂.1 s₂
 
-/-- Agda: `minus-Monoʳ` — a postulate there, a theorem here. -/
 theorem minus_mono_right (s₁ : ConstLattice) : Monotone (minus s₁) := minus_mono₂.2 s₁
 
-/-- Agda: `⟦_⟧ᶜ`. -/
 def interpConst : ConstLattice → Value → Prop
   | .bot, _ => False
   | .top, _ => True
   | .mk z, v => v = .int z
 
-/-- Agda: `⟦_⟧ᶜ` is registered for the `⟦_⟧` interpretation notation. -/
 instance : Interp ConstLattice (Value → Prop) := ⟨interpConst⟩
 
-/-- Agda: `s₁≢s₂⇒¬s₁∧s₂`. -/
 theorem interpConst_mk_disjoint {z₁ z₂ : ℤ} (hne : z₁ ≠ z₂) {v : Value} :
     ¬(⟦(.mk z₁ : ConstLattice)⟧ v ∧ ⟦(.mk z₂ : ConstLattice)⟧ v) := by
   rintro ⟨h₁, h₂⟩
@@ -98,17 +59,14 @@ theorem interpConst_mk_disjoint {z₁ z₂ : ℤ} (hne : z₁ ≠ z₂) {v : Val
   injection h₂ with hz
   exact hne hz
 
-/-- Agda: `⟦⟧ᶜ-⊔ᶜ-∨` (via the factored flat-lattice lemma). -/
 theorem interpConst_sup {s₁ s₂ : ConstLattice} (v : Value)
     (h : ⟦s₁⟧ v ∨ ⟦s₂⟧ v) : ⟦s₁ ⊔ s₂⟧ v :=
   AboveBelow.interp_sup_of (fun _ h => h) (fun _ => trivial) v h
 
-/-- Agda: `⟦⟧ᶜ-⊓ᶜ-∧` (via the factored flat-lattice lemma). -/
 theorem interpConst_inf {s₁ s₂ : ConstLattice} (v : Value)
     (h : ⟦s₁⟧ v ∧ ⟦s₂⟧ v) : ⟦s₁ ⊓ s₂⟧ v :=
   AboveBelow.interp_inf_of (fun hne _ => interpConst_mk_disjoint hne) v h
 
-/-- Agda: `latticeInterpretationᶜ` (an instance there too). -/
 instance constInterpretation : LatticeInterpretation ConstLattice where
   interp := interpConst
   interp_sup := fun {l₁ l₂} v h => interpConst_sup (s₁ := l₁) (s₂ := l₂) v h
@@ -116,7 +74,6 @@ instance constInterpretation : LatticeInterpretation ConstLattice where
 
 variable (prog : Program)
 
-/-- Agda: `WithProg.eval`. -/
 def eval : Expr → VariableValues ConstLattice prog → ConstLattice
   | .add e₁ e₂, vs => plus (eval e₁ vs) (eval e₂ vs)
   | .sub e₁ e₂, vs => minus (eval e₁ vs) (eval e₂ vs)
@@ -124,7 +81,6 @@ def eval : Expr → VariableValues ConstLattice prog → ConstLattice
     if h : FiniteMap.MemKey k vs then (FiniteMap.locate h).1 else .top
   | .num n, _ => .mk n
 
-/-- Agda: `WithProg.eval-Monoʳ`. -/
 theorem eval_mono (e : Expr) : Monotone (eval prog e) := by
   induction e with
   | add e₁ e₂ ih₁ ih₂ =>
@@ -147,15 +103,12 @@ theorem eval_mono (e : Expr) : Monotone (eval prog e) := by
     intro vs₁ vs₂ _
     exact le_refl _
 
-/-- Agda: the `ConstEval` instance. -/
 instance exprEvaluator : ExprEvaluator ConstLattice prog :=
   ⟨eval prog, eval_mono prog⟩
 
-/-- Agda: `WithProg.result`/`output`. -/
 def output : String :=
   show' (result ConstLattice prog)
 
-/-- Agda: `plus-valid`. -/
 theorem plus_valid {g₁ g₂ : ConstLattice} {z₁ z₂ : ℤ}
     (h₁ : ⟦g₁⟧ (.int z₁)) (h₂ : ⟦g₂⟧ (.int z₂)) :
     ⟦plus g₁ g₂⟧ (.int (z₁ + z₂)) := by
@@ -173,7 +126,6 @@ theorem plus_valid {g₁ g₂ : ConstLattice} {z₁ z₂ : ℤ}
       show Value.int (z₁ + z₂) = Value.int (c₁ + c₂)
       rw [hz₁, hz₂]
 
-/-- Agda: `minus-valid`. -/
 theorem minus_valid {g₁ g₂ : ConstLattice} {z₁ z₂ : ℤ}
     (h₁ : ⟦g₁⟧ (.int z₁)) (h₂ : ⟦g₂⟧ (.int z₂)) :
     ⟦minus g₁ g₂⟧ (.int (z₁ - z₂)) := by
@@ -191,7 +143,6 @@ theorem minus_valid {g₁ g₂ : ConstLattice} {z₁ z₂ : ℤ}
       show Value.int (z₁ - z₂) = Value.int (c₁ - c₂)
       rw [hz₁, hz₂]
 
-/-- Agda: `eval-valid` / the `ConstEvalValid` instance. -/
 instance eval_valid : ValidExprEvaluator ConstLattice prog := by
   constructor
   intro vs ρ e v hev
@@ -222,7 +173,6 @@ instance eval_valid : ValidExprEvaluator ConstLattice prog := by
     show ⟦eval prog (.sub e₁ e₂) vs⟧ (.int (z₁ - z₂))
     exact minus_valid h₁ h₂
 
-/-- Agda: `WithProg.analyze-correct`. -/
 theorem analyze_correct {ρ : Env} (hrun : EvalStmt [] prog.rootStmt ρ) :
     interpV (variablesAt prog.finalState (result ConstLattice prog)) ρ :=
   Spa.analyze_correct ConstLattice prog hrun