Add AlphaRenaming.lean

scripts/AlphaRenaming.lean

@@ -0,0 +1,220 @@
+/-
+  Alpha-Renaming using Lean 4 Meta-programming
+
+  This module performs variable renaming at the AST/Syntax level,
+  which is more robust than Python string manipulation:
+    1. Correct handling of variable scopes (shadowing)
+    2. No accidental replacement in string literals
+    3. Guaranteed syntactic correctness
+-/
+
+import Lean
+import Lean.Elab.Command
+import Lean.Parser
+
+open Lean Elab Command Meta
+
+namespace AlphaRenaming
+
+-- Variable renaming map type
+abbrev RenameMap := Std.HashMap Name Name
+
+-- Candidate names for renaming (Greek letters first, then Latin)
+def greekNames : Array Name := #[
+  .mkSimple "α", .mkSimple "β", .mkSimple "γ", .mkSimple "δ",
+  .mkSimple "ε", .mkSimple "ζ", .mkSimple "η", .mkSimple "θ",
+  .mkSimple "ι", .mkSimple "κ", .mkSimple "μ", .mkSimple "ν",
+  .mkSimple "ξ", .mkSimple "ο", .mkSimple "ρ", .mkSimple "σ",
+  .mkSimple "τ", .mkSimple "υ", .mkSimple "φ", .mkSimple "χ",
+  .mkSimple "ψ", .mkSimple "ω"
+]
+
+def latinNames : Array Name := #[
+  .mkSimple "a", .mkSimple "b", .mkSimple "c", .mkSimple "d",
+  .mkSimple "e", .mkSimple "f", .mkSimple "g", .mkSimple "i",
+  .mkSimple "j", .mkSimple "k", .mkSimple "l", .mkSimple "m",
+  .mkSimple "o", .mkSimple "p", .mkSimple "q", .mkSimple "r",
+  .mkSimple "s", .mkSimple "t", .mkSimple "u", .mkSimple "v",
+  .mkSimple "w"
+]
+
+def allCandidates : Array Name := greekNames ++ latinNames
+
+-- Generate an unused variable name
+def generateNewName (original : Name) (used : Std.HashSet Name) (suffix : Nat := 0) : Name :=
+  let rec findUnused (idx : Nat) : Name :=
+    if h : idx < allCandidates.size then
+      let candidate := allCandidates[idx]
+      if used.contains candidate then findUnused (idx + 1)
+      else candidate
+    else
+      -- All candidates exhausted, add suffix
+      .mkSimple s!"{original}_{suffix + idx}"
+  findUnused 0
+
+-- Collect all identifiers from syntax tree
+partial def collectIdents (stx : Syntax) : Array Name :=
+  match stx with
+  | .ident _ _ val _ => #[val]
+  | .node _ _ args => args.foldl (fun acc arg => acc ++ collectIdents arg) #[]
+  | _ => #[]
+
+-- Apply renaming to syntax tree
+partial def applyRenaming (stx : Syntax) (renameMap : RenameMap) : Syntax :=
+  match stx with
+  | .ident info _rawVal val preresolved =>
+    match renameMap[val]? with
+    | some newName =>
+      let newStr := newName.toString
+      let newRawVal : Substring.Raw := ⟨newStr, ⟨0⟩, ⟨newStr.length⟩⟩
+      .ident info newRawVal newName preresolved
+    | none => stx
+  | .node info kind args =>
+    let newArgs := args.map (applyRenaming · renameMap)
+    .node info kind newArgs
+  | _ => stx
+
+-- Extract variable names from binders (skip hypothesis names)
+def extractBinderNames (binder : Syntax) : Array Name :=
+  let idents := binder.getArgs.filter (·.isIdent)
+  idents.foldl (fun acc ident =>
+    match ident with
+    | .ident _ _ val _ =>
+      let nameStr := val.toString
+      -- Skip hypothesis names like h₀, h₁, hn, hx
+      if nameStr.startsWith "h" && nameStr.length > 1 then acc
+      else if nameStr == "h" then acc
+      else acc.push val
+    | _ => acc
+  ) #[]
+
+-- Generate complete rename mapping for all variables
+def generateRenameMap (varNames : Array Name) (_seed : Nat := 0) : RenameMap :=
+  let initUsed : Std.HashSet Name := varNames.foldl (fun acc name => acc.insert name) {}
+  let ((renameMap, _), _) := varNames.foldl (fun ((map, used), idx) name =>
+    let newName := generateNewName name used idx
+    ((map.insert name newName, used.insert newName), idx + 1))
+    (({}, initUsed), 0)
+  renameMap
+
+-- Protected keywords and identifiers that should NOT be renamed
+def keywords : Std.HashSet Name :=
+  let s : Std.HashSet Name := {}
+  -- Lean keywords
+  s.insert (.mkSimple "theorem")
+  |>.insert (.mkSimple "lemma")
+  |>.insert (.mkSimple "def")
+  |>.insert (.mkSimple "by")
+  |>.insert (.mkSimple "sorry")
+  |>.insert (.mkSimple "rfl")
+  -- Type names
+  |>.insert (.mkSimple "ℕ")
+  |>.insert (.mkSimple "ℤ")
+  |>.insert (.mkSimple "ℚ")
+  |>.insert (.mkSimple "ℝ")
+  |>.insert (.mkSimple "ℂ")
+  |>.insert (.mkSimple "Nat")
+  |>.insert (.mkSimple "Int")
+  |>.insert (.mkSimple "Rat")
+  |>.insert (.mkSimple "Real")
+  |>.insert (.mkSimple "Finset")
+  |>.insert (.mkSimple "List")
+  |>.insert (.mkSimple "Set")
+  |>.insert (.mkSimple "Prop")
+  |>.insert (.mkSimple "Type")
+  -- Common library functions
+  |>.insert (.mkSimple "range")
+  |>.insert (.mkSimple "sum")
+  |>.insert (.mkSimple "prod")
+  |>.insert (.mkSimple "card")
+  |>.insert (.mkSimple "gcd")
+  |>.insert (.mkSimple "abs")
+  |>.insert (.mkSimple "min")
+  |>.insert (.mkSimple "max")
+  |>.insert (.mkSimple "log")
+  |>.insert (.mkSimple "exp")
+  |>.insert (.mkSimple "sin")
+  |>.insert (.mkSimple "cos")
+  |>.insert (.mkSimple "tan")
+  |>.insert (.mkSimple "mod")
+  |>.insert (.mkSimple "div")
+  |>.insert (.mkSimple "lcm")
+  |>.insert (.mkSimple "id")
+  |>.insert (.mkSimple "fun")
+  |>.insert (.mkSimple "Even")
+  |>.insert (.mkSimple "Odd")
+  -- Struct field accessors (to avoid x.field issues)
+  |>.insert (.mkSimple "num")
+  |>.insert (.mkSimple "den")
+  |>.insert (.mkSimple "re")
+  |>.insert (.mkSimple "im")
+  |>.insert (.mkSimple "fst")
+  |>.insert (.mkSimple "snd")
+  |>.insert (.mkSimple "val")
+  |>.insert (.mkSimple "toNat")
+  |>.insert (.mkSimple "toInt")
+  |>.insert (.mkSimple "toRat")
+  |>.insert (.mkSimple "floor")
+  |>.insert (.mkSimple "ceil")
+  |>.insert (.mkSimple "natAbs")
+  |>.insert (.mkSimple "succ")
+  |>.insert (.mkSimple "pred")
+  -- Variables commonly used with field access (S.card, z.im, m.num, etc.)
+  |>.insert (.mkSimple "S")
+  |>.insert (.mkSimple "T")
+  |>.insert (.mkSimple "A")
+  |>.insert (.mkSimple "B")
+  |>.insert (.mkSimple "f")
+  |>.insert (.mkSimple "g")
+  |>.insert (.mkSimple "z")
+  |>.insert (.mkSimple "w")
+  |>.insert (.mkSimple "m")
+  |>.insert (.mkSimple "q")
+  |>.insert (.mkSimple "p")
+  |>.insert (.mkSimple "d")
+
+-- Check if name is a hypothesis name (h₀, h₁, hn, hx, etc.)
+def isHypothesisName (n : Name) : Bool :=
+  let s := n.toString
+  if s.length == 1 then false
+  else if s.startsWith "h" then
+    let rest := s.drop 1
+    rest.all (fun c => c.isDigit || c == '_' || (c.isAlpha && c.isLower) ||
+                       "₀₁₂₃₄₅₆₇₈₉".toList.contains c)
+  else false
+
+-- Main alpha-renaming function for theorem propositions
+def alphaRenameTheorem (declStx : Syntax) : MetaM Syntax := do
+  let allIdents := collectIdents declStx
+
+  -- Filter: short names that are likely variables
+  let varCandidates := allIdents.filter (fun n =>
+    !keywords.contains n &&
+    n.toString.length <= 3 &&
+    !isHypothesisName n
+  )
+
+  -- Deduplicate
+  let uniqueVars := varCandidates.foldl (fun acc n =>
+    if acc.contains n then acc else acc.push n) #[]
+
+  let renameMap := generateRenameMap uniqueVars
+  return applyRenaming declStx renameMap
+
+-- Command: alpha-rename and print result
+elab "#alpha_rename " thm:term : command => do
+  let renamedStx ← liftTermElabM <| alphaRenameTheorem thm
+  logInfo m!"Renamed:\n{renamedStx}"
+
+-- Command: alpha-rename with ID markers for Python parsing
+elab "#alpha_rename_id " "[" id:ident "]" thm:term : command => do
+  let renamedStx ← liftTermElabM <| alphaRenameTheorem thm
+  let idStr := id.getId.toString
+  logInfo m!"[RENAMED:{idStr}]\n{renamedStx}\n[/RENAMED:{idStr}]"
+
+end AlphaRenaming
+
+-- Example usage
+section Examples
+#alpha_rename (∀ (n : Nat), n + 0 = n)
+end Examples