add lean4/src/SovereignCorpus/Bridge/Granite4Parser.lean

lean4/src/SovereignCorpus/Bridge/Granite4Parser.lean

@@ -0,0 +1,87 @@
+import Lean.Data.Json
+import SovereignCorpus.Bridge.Granite4Schema
+
+namespace SovereignCorpus.Bridge.Granite4Parser
+
+open Lean
+open SovereignCorpus.Bridge
+
+inductive ParseError where
+  | jsonDecode (msg : String) (line : Nat)
+  | schemaViolation (field : String) (reason : String)
+  | lean3SyntaxDetected (pattern : String) (line : Nat)
+  | tacticForbidden (tactic : String) (line : Nat)
+deriving Repr, Inhabited
+
+def forbiddenPatterns : List String :=
+  [
+    "meta def",
+    "tactic.block",
+    "refine_struct",
+    "classical.by_contradiction",
+    "by_contra!",
+    "have! := by",
+    "sorryAx",
+    "prop_decidable",
+    "Classical.propDecidable"
+  ]
+
+def defaultAllowedTactics : List String :=
+  ["rw", "simp_all", "norm_num", "linarith", "nlinarith", "aesop", "apply", "exact", "intro", "obtain", "cases", "induction", "constructor", "split_ifs", "field_simp", "ring_nf", "norm_cast", "omega"]
+
+def containsText (haystack needle : String) : Bool :=
+  if needle.isEmpty then
+    true
+  else
+    (haystack.splitOn needle).length > 1
+
+def containsForbiddenPattern (text : String) : Option String :=
+  forbiddenPatterns.find? (fun pattern => containsText text pattern)
+
+def guardLean4Syntax (p : GraniteProblem) (line : Nat) : Except ParseError Unit := do
+  let haystack := p.statement ++ "\n" ++ String.intercalate "\n" p.context ++ "\n" ++ p.tacticHint.getD ""
+  match containsForbiddenPattern haystack with
+  | some pattern => throw <| ParseError.lean3SyntaxDetected pattern line
+  | none => pure ()
+
+def guardTactics (p : GraniteProblem) (line : Nat) : Except ParseError Unit := do
+  match p.tacticHint with
+  | some hint =>
+      if p.meta.allowedTactics.contains hint || defaultAllowedTactics.contains hint then
+        pure ()
+      else
+        throw <| ParseError.tacticForbidden hint line
+  | none => pure ()
+
+def guardStatement (p : GraniteProblem) : Except ParseError Unit := do
+  if containsText p.statement "sorry" then
+    throw <| ParseError.schemaViolation "statement" "target theorem statement must not contain sorry"
+  else
+    pure ()
+
+def parseLine (line : String) (lineNum : Nat) : Except ParseError GraniteProblem := do
+  if line.trim.isEmpty then
+    throw <| ParseError.jsonDecode "empty line" lineNum
+  let json <- Json.parse line |>.mapError (fun err => ParseError.jsonDecode err lineNum)
+  let problem <- fromJson? json |>.mapError (fun err => ParseError.jsonDecode err lineNum)
+  guardLean4Syntax problem lineNum
+  guardTactics problem lineNum
+  guardStatement problem
+  pure problem
+
+def loadProblems (path : String) : IO (Except String (List GraniteProblem)) := do
+  let content ← IO.FS.readFile path
+  let lines := content.splitOn "\n"
+  let parsed := lines.enum.filterMap (fun ⟨idx, line⟩ =>
+    if line.trim.isEmpty then
+      none
+    else
+      some <| parseLine line (idx + 1)
+  )
+  let errors := parsed.filterMap (fun r => match r with | .error e => some e | .ok _ => none)
+  if !errors.isEmpty then
+    pure <| Except.error s!"parse failures: {repr errors}"
+  else
+    pure <| Except.ok <| parsed.filterMap (fun r => match r with | .ok p => some p | .error _ => none)
+
+end SovereignCorpus.Bridge.Granite4Parser