itp-interface 1.0.0__py3-none-any.whl

itp_interface/pisa/src/main/python/test_client2.py

@@ -0,0 +1,79 @@
+from .pisa_client import initialise_env
+
+
+if __name__ == '__main__':
+    env = initialise_env()
+    default_st = env.initialise()
+    
+    # Default state
+    print(default_st)
+
+    # Returns error string!
+    # obs_string = env.step('default', 'theory Drinker', 'state0')
+    # print(obs_string)
+
+    # Initialization of theory
+    obs_string = env.step('default', 'theory Drinker imports Main begin', 'state0')
+    print(obs_string)
+
+    # Declare a lemma
+    obs_string = env.step('state0', 
+                          'lemma de_Morgan: assumes "\\<not> (\\<forall>x. P x)" shows "\\<exists>x. \\<not> P x"',
+                          'state1')
+    print(env.get_state('state1'))
+
+    # all_lemmas = env.get_total_lemmas('state1')
+    # print("Num lemmas: " + str(len(all_lemmas)))
+    # for lemma in all_lemmas: # Sanity check with less complicated/weird lemmas
+    #     if "ln_gt_zero" in lemma.name:
+    #         print(lemma.dfn)
+
+    # Attempt to use Sledgehammer
+    obs_string = env.apply_hammer('state1', 'hammered')
+    print(obs_string)
+    print("Finished? " + str(env.is_finished('hammered')))
+
+    # Prove the lemma
+    obs_string = env.step('state1', 
+                          "proof (rule classical)",
+                          'state2')
+    print(obs_string)
+    obs_string = env.step('state2', 
+                          "assume \"\\<nexists>x. \\<not> P x\"",
+                          'state3')
+    print(obs_string)
+    obs_string = env.step('state3', 
+                          """
+have "\\<forall>x. P x"
+proof
+fix x show "P x"
+proof (rule classical)
+    assume "\\<not> P x"
+    then have "\\<exists>x. \\<not> P x" ..
+    with \\<open>\\<nexists>x. \\<not> P x\\<close> show ?thesis by contradiction
+qed
+qed
+                          """,
+                          'state4')
+    print(obs_string)
+    obs_string = env.step('state4', 
+                          "with \\<open>\\<not> (\\<forall>x. P x)\\<close> show ?thesis by contradiction",
+                          'state5')
+    print(obs_string)
+
+    # Proof is not done until qed
+    print("Finished? " + str(env.is_finished('state5')))
+    # Re-using the same state is ok too
+    obs_string = env.step('state5', 
+                          'qed',
+                          'state5')
+    print("Finished? " + str(env.is_finished('state5')))
+
+    # # Test some non-sledgehammerable theorems
+    # obs_string = env.step('state0', 
+    #                       'lemma conc_empty: "conc xs Empty = xs"',
+    #                       'state1')
+    # print(env.get_state('state1'))
+
+    # obs_string = env.apply_hammer('state1', 'hammered2')
+    # print(obs_string)

itp_interface/pisa/src/main/python/utils/filters.py

@@ -0,0 +1,59 @@
+import re
+
+
+def filter_comments(input_text, opening_marks, closing_marks):
+    output_text = re.sub(re.compile("{}.*?{}".format(opening_marks, closing_marks), re.DOTALL), "", input_text)
+    return output_text
+
+
+def filter_isar_comments(input_text):
+    text = filter_comments(input_text, "\(\*", "\*\)")
+    text = filter_comments(text, "text\\\<open\>", "\\\<close\>")
+    return text
+
+
+def spit_out_first_parsable_segment(input_text: str):
+    find_first_line_separator = input_text.find("\n")
+    if find_first_line_separator == -1:
+        return input_text.strip(), ""
+
+    first_line = input_text[:find_first_line_separator]
+
+    # Theorem definitions must be read until the proof starts
+    if "theorem" in first_line or "lemma" in first_line:
+        find_first_proof = input_text.find("proof")
+        find_first_apply = input_text.find("apply")
+        find_first_by = input_text.find("by")
+
+        if find_first_proof != -1 and find_first_proof < find_first_apply and find_first_proof < find_first_by:
+            truncation_index = find_first_proof
+        elif find_first_apply != -1 and find_first_apply < find_first_proof and find_first_apply < find_first_by:
+            truncation_index = find_first_apply
+        elif find_first_by != -1 and find_first_by < find_first_proof and find_first_by < find_first_apply:
+            truncation_index = find_first_by
+        else:
+            raise NotImplementedError("We haven't thought of this situation. The Isar proof is as follows:\n" + input_text)
+
+        first_bit = input_text[:truncation_index].strip()
+        first_bit = first_bit.replace("\n", " ")
+
+        return first_bit, input_text[truncation_index:].strip()
+
+    # Inner syntax must not be read in two segments
+    if first_line.count('"') % 2 == 0:
+        return first_line.strip(), input_text[find_first_line_separator:].strip()
+    # Find the next first double quotation mark as the end
+    find_first_double_quotation = input_text[find_first_line_separator:].find('"')
+    if find_first_double_quotation == -1:
+        raise AssertionError
+    return first_line.strip() + " " + input_text[find_first_line_separator:][:find_first_double_quotation+1].strip(), \
+        input_text[find_first_line_separator:][find_first_double_quotation + 1:]
+
+
+def spit_out_all_parsable_segments(input_text: str):
+    segments = list()
+    rest_of_the_text = input_text.strip()
+    while rest_of_the_text:
+        first_segment, rest_of_the_text = spit_out_first_parsable_segment(rest_of_the_text)
+        segments.append(first_segment)
+    return segments

itp_interface/pisa/src/main/python/utils/pisa_server_control.py

@@ -0,0 +1,29 @@
+import subprocess
+import time
+import psutil
+import signal
+
+
+def start_server(jar_path, port, outputfile=None, errorfile=None):
+    command = ["java", "-cp", jar_path, f"pisa.server.PisaOneStageServer{port}"]
+    outputfile = subprocess.PIPE if outputfile is None else outputfile
+    errorfile = subprocess.PIPE if errorfile is None else errorfile
+    server_subprocess_id = subprocess.Popen(
+        command,
+        stdout=open(outputfile, "w"),
+        stderr=open(errorfile, "w"),
+    ).pid
+    time.sleep(5)
+    return server_subprocess_id
+
+
+def close_server(server_subprocess_id):
+    # Kill the server and its subprocesses
+    try:
+        p_process = psutil.Process(server_subprocess_id)
+        children = p_process.children(recursive=True)
+        for process in children:
+            process.send_signal(signal.SIGTERM)
+        p_process.send_signal(signal.SIGTERM)
+    except psutil.NoSuchProcess:
+        pass

itp_interface/pisa/src/main/scala/pisa/agent/CheckSyntax.scala

@@ -0,0 +1,257 @@
+package pisa.agent
+
+import de.unruh.isabelle.control.{Isabelle, IsabelleMLException}
+import de.unruh.isabelle.mlvalue.MLFunction2
+import de.unruh.isabelle.pure.{Theory, ToplevelState}
+import de.unruh.isabelle.mlvalue.Implicits._
+import de.unruh.isabelle.pure.Implicits._
+import pisa.server.{PisaOS, Transition}
+
+import _root_.java.nio.file.{Files, Path}
+import java.io.PrintWriter
+import scala.collection.mutable.ListBuffer
+import scala.concurrent.ExecutionContext
+import scala.concurrent._
+import scala.concurrent.duration._
+
+class CheckSyntax(path_to_isa_bin: String, path_to_file: String, working_directory: String) {
+  def divide_by_theorem(total_string: String): (String, List[String]) = {
+    val keyword = "theorem"
+    val split_theorems = total_string.split(keyword)
+    split_theorems.foreach(println)
+    val header = split_theorems.head
+    (header, split_theorems.drop(1).map(x => keyword + x).toList)
+  }
+
+  def try_to_parse_theorem(theorem_string: String): Boolean = {
+    var trial_state = pisaos.copy_tls.retrieveNow
+    try {
+      for ((transition, text) <- parse_text(thy, theorem_string).force.retrieveNow) {
+        if (text.trim.isEmpty) {}
+        else {
+          println(text)
+          trial_state = step(text, trial_state)
+        }
+      }
+      true
+    } catch {
+      case e: Throwable =>
+        println(e); false
+    }
+  }
+
+  // def try_to_parse_theorem_with_hammer(theorem_string: String): (Boolean, String) = {
+  //   var trial_state = pisaos.copy_tls.retrieveNow
+  //   var stateActionTotal: String = ""
+  //   var current_state_string: String = pisaos.getStateString(trial_state)
+  //   var current_proof_level: Int = pisaos.getProofLevel(trial_state)
+  //   try {
+  //     for ((_, text) <- parse_text(thy, theorem_string).force.retrieveNow) {
+  //       if (text.trim.isEmpty) {}
+  //       else if (text.trim == "sledgehammer") {
+  //         val hammer_results = pisaos.normal_with_hammer(trial_state, List[String](), List[String](), 60000)
+  //         val hammered_string = {
+  //           if (hammer_results._1) {
+  //             val hammer_strings = hammer_results._2
+  //             var found = false
+  //             var real_string = ""
+  //             for (attempt_string <- hammer_strings) {
+  //               if (!found && (attempt_string contains "Try this:")) {
+  //                 found = true
+  //                 real_string = attempt_string.trim.stripPrefix("Try this:").trim.split('(').dropRight(1).mkString("(")
+  //               }
+  //             }
+  //             if (found) real_string
+  //             else throw new IsabelleMLException
+  //           } else {
+  //             throw IsabelleMLException
+  //           }
+  //         }.trim
+  //         trial_state = step(hammered_string, trial_state, 20000)
+  //         stateActionTotal = stateActionTotal + (current_state_string + "<\\STATESEP>" + hammered_string.trim + "<\\STATESEP>" + s"$current_proof_level" + "<\\TRANSEP>")
+  //         current_state_string = pisaos.getStateString(trial_state)
+  //         current_proof_level = pisaos.getProofLevel(trial_state)
+  //       } else {
+  //         trial_state = step(text, trial_state)
+  //         stateActionTotal = stateActionTotal + (current_state_string + "<\\STATESEP>" + text.trim + "<\\STATESEP>" + s"$current_proof_level" + "<\\TRANSEP>")
+  //         current_state_string = pisaos.getStateString(trial_state)
+  //         current_proof_level = pisaos.getProofLevel(trial_state)
+  //       }
+  //     }
+  //     (true, stateActionTotal)
+  //   } catch {
+  //     case e: Throwable => (false, "")
+  //   }
+  // }
+
+  def try_to_drive_contradictions_from_theorem(theorem_string: String): Boolean = {
+    val theorem_lines = theorem_string.split("\n")
+    val theorem_decl = theorem_lines.head
+    //  Find where the keyword "shows" starts in theorem_decl
+    val show_start = theorem_decl.indexOf("shows")
+    if (show_start == -1) false
+    else if (theorem_string.contains("sos")) false
+    else {
+      val modified_theorem_decl = theorem_decl.substring(0, show_start) + """shows "False""""
+      val modified_theorem_string = modified_theorem_decl + "\n" + theorem_lines.drop(1).mkString("\n")
+      try_to_parse_theorem(modified_theorem_string)
+    }
+  }
+
+  def get_all_parsable_theorems(list_of_theorem_strings: List[String]): List[String] = {
+    list_of_theorem_strings.filter(x => try_to_parse_theorem(x))
+  }
+
+  def get_all_parsable_theorems : List[String] = get_all_parsable_theorems(individual_theorem_strings)
+
+  // def get_all_parsable_hammer_theorems(list_of_theorem_strings: List[String]): String = {
+  //   val list_of_theorem_strings_parsed: List[(Boolean, String)] = list_of_theorem_strings.map(try_to_parse_theorem_with_hammer)
+  //   val parsable_strings: List[String] = list_of_theorem_strings_parsed.filter(x => x._1).map(x => x._2)
+  //   parsable_strings.mkString
+  // }
+
+  // def get_all_parsable_hammer_theorems: String = get_all_parsable_hammer_theorems(individual_theorem_strings)
+
+  def get_all_contradictions(list_of_theorem_strings: List[String]): List[String] = {
+    list_of_theorem_strings.filter(x => try_to_drive_contradictions_from_theorem(x))
+  }
+
+  def get_all_contradictions: List[String] = get_all_contradictions(individual_theorem_strings)
+
+  def step(isar_string: String, top_level_state: ToplevelState, timeout_in_millis: Int = 10000): ToplevelState = {
+    pisaos.step(isar_string, top_level_state, timeout_in_millis)
+  }
+
+  // Load PisaOS and useful methods and attributes
+  val pisaos = new PisaOS(path_to_isa_bin = path_to_isa_bin, path_to_file = path_to_file, working_directory = working_directory)
+  implicit val isabelle: Isabelle = pisaos.isabelle
+  implicit val ec: ExecutionContext = pisaos.ec
+  val thy: Theory = pisaos.thy1
+  val parse_text: MLFunction2[Theory, String, List[(Transition.T, String)]] = pisaos.parse_text
+  val top_level_state: ToplevelState = pisaos.toplevel
+  // Names of all the parsable theorems
+  var parsable_theorem_names: ListBuffer[String] = ListBuffer[String]()
+  // String of the entire file
+  val file_string: String = Files.readString(Path.of(path_to_file))
+  val (header: String, individual_theorem_strings: List[String]) = divide_by_theorem(file_string)
+  pisaos.step(header)
+
+
+  // Some constants
+  val header_script: String = """(*
+                        |  Authors: Codex from Lean
+                        |*)
+                        |
+                        |theory miniF2F_correct
+                        |  imports
+                        |  HOL.HOL
+                        |  Complex_Main
+                        |  "HOL-Library.Code_Target_Numeral"
+                        |  "HOL-Library.Sum_of_Squares"
+                        |  "Symmetric_Polynomials.Vieta"
+                        |  "HOL-Computational_Algebra.Computational_Algebra"
+                        |  "HOL-Number_Theory.Number_Theory"
+                        |begin
+                        |""".stripMargin
+  val ending_script: String = """
+                                |end
+                                |""".stripMargin
+}
+
+object CheckSyntax {
+  def main(args: Array[String]): Unit = {
+    val theory_path: String = args(0).trim
+    val dump_path: String = args(1).trim
+    val syntax_checker: CheckSyntax = new CheckSyntax(
+      path_to_isa_bin = "/home/qj213/Isabelle2021",
+      path_to_file = theory_path,
+      working_directory = "/home/qj213/afp-2021-10-22/thys/Symmetric_Polynomials"
+    )
+
+    new PrintWriter("syntax_correct_theorem_names") {
+      for (str <- syntax_checker.get_all_parsable_theorems) {
+        write(str.replaceAll("\n", " ").replaceAll(" +", " ").trim)
+        write("\n")
+      }
+      close()
+    }
+
+    for ((theorem_full, i) <- syntax_checker.get_all_parsable_theorems.zipWithIndex) {
+      val theorem_name: String = theorem_full.split(":").head.split(" ")(1)
+      val theorem_decl: String = theorem_full.trim.split("\n").dropRight(1).mkString.replaceAll(" +", " ")
+      val theory_path = dump_path + s"/$theorem_name.thy"
+      new PrintWriter(theory_path) {
+        write(s"""(*
+                |  Authors: Codex from Lean
+                |*)
+                |
+                |theory $theorem_name
+                |  imports
+                |  HOL.HOL
+                |  Complex_Main
+                |  "HOL-Library.Code_Target_Numeral"
+                |  "HOL-Library.Sum_of_Squares"
+                |  "Symmetric_Polynomials.Vieta"
+                |  "HOL-Computational_Algebra.Computational_Algebra"
+                |  "HOL-Number_Theory.Number_Theory"
+                |begin
+                |""".stripMargin)
+        write(theorem_full)
+        write("""
+              |end
+              |""".stripMargin)
+        close()
+      }
+
+      new PrintWriter(dump_path + s"/test_name_$i") {
+        write(theory_path)
+        write("\n")
+        write(theorem_decl)
+        close()
+      }
+    }
+
+
+//    new PrintWriter(dump_path) {
+//      write(syntax_checker.header_script)
+//      for (theorem_decl <- syntax_checker.get_all_parsable_theorems) {
+//        write(theorem_decl)
+//      }
+//      write(syntax_checker.ending_script)
+//      close()
+//    }
+  }
+}
+
+// object ParseWithHammer {
+//   def main(args: Array[String]): Unit = {
+//     val theory_path: String = args(0).trim
+//     val dump_path: String = args(1).trim
+//     val syntax_checker: CheckSyntax = new CheckSyntax(
+//       path_to_isa_bin = "/home/qj213/Isabelle2021",
+//       path_to_file = theory_path,
+//       working_directory = "/home/qj213/afp-2021-10-22/thys/Symmetric_Polynomials"
+//     )
+//     new PrintWriter(dump_path) {
+//       write(syntax_checker.get_all_parsable_hammer_theorems)
+//       close()
+//     }
+//   }
+// }
+
+
+object DriveContradictions {
+  def main(args: Array[String]) : Unit = {
+    val theory_path: String = args(0).trim
+    val dump_path: String = args(1).trim
+    val syntax_checker: CheckSyntax = new CheckSyntax(
+      path_to_isa_bin = "/home/qj213/Isabelle2021",
+      path_to_file = theory_path,
+      working_directory = "/home/qj213/afp-2021-10-22/thys/Symmetric_Polynomials"
+    )
+    new PrintWriter(dump_path) {
+      write(syntax_checker.get_all_contradictions.mkString("\n"))
+      close()
+    }
+  }
+}

itp_interface/pisa/src/main/scala/pisa/agent/DepThms.scala

@@ -0,0 +1,29 @@
+package pisa.agent
+
+import pisa.server.PisaOS
+import de.unruh.isabelle.control.Isabelle
+import scala.concurrent.ExecutionContext
+
+object DepThms {
+  val path_to_isa_bin: String = "/home/qj213/Isabelle2022"
+  val working_directory: String = "/home/qj213/Isabelle2022/src/HOL/Computational_Algebra"
+  val path_to_file: String = "/home/qj213/Isabelle2022/src/HOL/Computational_Algebra/Primes.thy"
+  val theorem_string = "by (auto simp add: prime_int_iff')"
+
+  def main(args: Array[String]): Unit = {
+    val pisaos = new PisaOS(
+      path_to_isa_bin=path_to_isa_bin,
+      path_to_file=path_to_file,
+      working_directory=working_directory
+    )
+    implicit val isabelle: Isabelle = pisaos.isabelle
+    implicit val ec: ExecutionContext = pisaos.ec
+
+    pisaos.step_to_transition_text(theorem_string, after = false)
+    println(pisaos.getStateString(pisaos.toplevel))
+    
+    pisaos.top_level_state_map += ("default" -> pisaos.copy_tls)
+    println("~"*50)
+    println(pisaos.fact_definition("default", "prime_dvd_fact_iff"))
+  }
+}

itp_interface/pisa/src/main/scala/pisa/agent/PisaStat.scala

@@ -0,0 +1,46 @@
+package pisa.agent
+
+import net.liftweb.json.{DefaultFormats, parse}
+import pisa.server.PisaOS
+
+import java.io.PrintWriter
+import scala.io.Source
+
+object PisaStat {
+  implicit val formats: DefaultFormats = DefaultFormats
+
+  def main(args: Array[String]): Unit = {
+    val test_theorem_number: String = args(0).split('/').last.split('.').head.split('_').last
+    val dump_path: String = "results/pisa_stat"
+    val json_element = parse(
+      {
+        val textSource = Source.fromFile(args(0))
+        val str = textSource.mkString
+        textSource.close()
+        str
+      }
+    ).children.head
+    val theory_path = json_element(0).extract[String].replaceAll("/home/ywu/afp-2021-02-11", "/home/qj213/afp-2021-10-22")
+    val thys_index = theory_path.split("/").indexOf("thys")
+    val working_directory = {
+      if (theory_path.contains("miniF2F")) "/home/qj213/afp-2021-10-22/thys/Symmetric_Polynomials"
+      else theory_path.split("/").take(thys_index + 2).mkString("/")
+    }
+    val theorem_name = json_element(1).extract[String].replaceAll("\n", " ").replaceAll(" +", " ").trim
+    val starting_point = System.nanoTime
+    val pisaos = new PisaOS(
+      path_to_isa_bin = "/home/qj213/Isabelle2021",
+      path_to_file = theory_path,
+      working_directory = working_directory
+    )
+    val load_timestamp = System.nanoTime
+    val load_library_time = (load_timestamp - starting_point) / 1e9d
+    pisaos.step_to_transition_text(theorem_name)
+    val proceed_to_line_time = (System.nanoTime - load_timestamp) / 1e9d
+
+    new PrintWriter(s"$dump_path/$test_theorem_number" + "_time.info") {
+      write(s"load_library_time: $load_library_time\nproceed_to_line_time: $proceed_to_line_time")
+      close()
+    }
+  }
+}

itp_interface/pisa/src/main/scala/pisa/agent/RefactorTest.scala

@@ -0,0 +1,40 @@
+package pisa.agent
+
+
+import de.unruh.isabelle.control.Isabelle
+import de.unruh.isabelle.mlvalue.Implicits._
+import de.unruh.isabelle.pure.Implicits._
+import de.unruh.isabelle.pure.ToplevelState
+import pisa.server.PisaOS
+
+import scala.concurrent._
+import scala.concurrent.ExecutionContext
+import scala.concurrent.blocking
+import scala.concurrent.ExecutionContext.Implicits._
+import scala.util.control.Breaks
+import java.util.concurrent.CancellationException
+import java.io._
+import java.util.Base64
+import java.nio.charset.StandardCharsets.UTF_8
+
+object RefactorTest {
+  val path_to_isa_bin: String = "/home/qj213/Isabelle2022"
+  val working_directory: String = "/home/qj213/afp-2022-12-06/thys/Formal_SSA"
+  val path_to_file: String = "/home/qj213/afp-2022-12-06/thys/Formal_SSA/Construct_SSA.thy"
+  val problem1: String = "lemma phiDefNodes_aux_cases:\n    obtains (nonrec) \"phiDefNodes_aux g v unvisited n = {}\" \"(n \\<notin> set unvisited \\<or> v \\<in> defs g n)\"\n    | (rec) \"phiDefNodes_aux g v unvisited n = fold union (map (phiDefNodes_aux g v (removeAll n unvisited)) (predecessors g n))\n          (if length (predecessors g n) = 1 then {} else {n})\"\n       \"n \\<in> set unvisited\" \"v \\<notin> defs g n\""
+  val problem2: String = "lemma phiDefNode_aux_is_join_node:\n    assumes \"n \\<in> phiDefNodes_aux g v un m\"\n    shows \"length (predecessors g n) \\<noteq> 1\""
+
+  def main(args: Array[String]): Unit = {
+    val pisaos = new PisaOS(
+      path_to_isa_bin=path_to_isa_bin,
+      path_to_file=path_to_file,
+      working_directory=working_directory
+    )
+    pisaos.accumulative_step_to_theorem_end(problem1)
+    pisaos.top_level_state_map += ("default" -> pisaos.copy_tls)
+    println(pisaos.get_dependent_theorems("default", "phiDefNodes_aux_cases"))
+    pisaos.accumulative_step_to_theorem_end(problem2)
+    pisaos.top_level_state_map += ("default" -> pisaos.copy_tls)
+    println(pisaos.get_dependent_theorems("default", "phiDefNode_aux_is_join_node"))
+  }
+}

itp_interface/pisa/src/main/scala/pisa/agent/RepHammer.scala

@@ -0,0 +1,95 @@
+package pisa.agent
+
+import pisa.utils.TheoryManager
+
+import de.unruh.isabelle.control.Isabelle
+import de.unruh.isabelle.control.Isabelle.Setup
+import de.unruh.isabelle.mlvalue.MLFunction4
+import de.unruh.isabelle.mlvalue.MLValue.{compileFunction, compileFunction0}
+import de.unruh.isabelle.mlvalue.AdHocConverter
+import de.unruh.isabelle.pure.{Theory, TheoryHeader, ToplevelState}
+import de.unruh.isabelle.control.{Isabelle, OperationCollection}
+import de.unruh.isabelle.mlvalue.MLValue.compileFunction
+import de.unruh.isabelle.pure.{Position, Theory, TheoryHeader}
+
+import java.nio.file.{Path, Paths}
+
+import de.unruh.isabelle.mlvalue.Implicits._
+import de.unruh.isabelle.pure.Implicits._
+import scala.concurrent.ExecutionContext.Implicits.global
+
+object Transition extends AdHocConverter("Toplevel.transition")
+
+
+object RepHammer {
+  val isabelleHome: Path = Paths.get("/Applications/Isabelle2022.app")
+  val setup: Setup = Setup(isabelleHome = isabelleHome)
+  val theoryManager: TheoryManager = new TheoryManager(
+    path_to_isa_bin="/Applications/Isabelle2022.app",
+    wd="/Applications/Isabelle2022.app/src/HOL"
+  )
+  def main(args: Array[String]): Unit = {
+    implicit val isabelle: Isabelle = new Isabelle(setup)
+
+    val theorySource = TheoryManager.Text(
+      """ theory Test imports Main begin lemma test: "1+1=(2::nat)" """,
+      Paths.get("Test.thy").toAbsolutePath)
+
+    val thy0 = theoryManager.beginTheory(theorySource)
+    val init_toplevel = compileFunction0[ToplevelState]("Toplevel.init_toplevel")
+    var toplevel = init_toplevel().force.retrieveNow
+
+    val parse_text = compileFunction[Theory, String, List[(Transition.T, String)]](
+      """fn (thy, text) => let
+        |  val transitions = Outer_Syntax.parse_text thy (K thy) Position.start text
+        |  fun addtext symbols [tr] =
+        |        [(tr, implode symbols)]
+        |    | addtext _ [] = []
+        |    | addtext symbols (tr::nextTr::trs) = let
+        |        val (this,rest) = Library.chop (Position.distance_of (Toplevel.pos_of tr, Toplevel.pos_of nextTr) |> Option.valOf) symbols
+        |        in (tr, implode this) :: addtext rest (nextTr::trs) end
+        |  in addtext (Symbol.explode text) transitions end""".stripMargin)
+
+    val command_exception = compileFunction[Boolean, Transition.T, ToplevelState, ToplevelState](
+      "fn (int, tr, st) => Toplevel.command_exception int tr st")
+
+    for ((transition, text) <- parse_text(thy0, theorySource.text).force.retrieveNow) {
+      println(s"""Transition: "${text.strip}"""")
+      toplevel = command_exception(true, transition, toplevel).retrieveNow.force
+    }
+
+    //    val finalThy = toplevel_end_theory(toplevel).retrieveNow.force
+
+    val thy_for_sledgehammer = thy0
+    val Sledgehammer: String = thy_for_sledgehammer.importMLStructureNow("Sledgehammer")
+    val Sledgehammer_Commands: String = thy_for_sledgehammer.importMLStructureNow("Sledgehammer_Commands")
+    val Sledgehammer_Prover: String = thy_for_sledgehammer.importMLStructureNow("Sledgehammer_Prover")
+
+    val normal_with_Sledgehammer: MLFunction4[ToplevelState, Theory, List[String], List[String], (Boolean, (String, List[String]))] =
+      compileFunction[ToplevelState, Theory, List[String], List[String], (Boolean, (String, List[String]))](
+        s""" fn (state, thy, adds, dels) =>
+           |    let
+           |       val override = {add=[],del=[],only=false};
+           |       fun go_run (state, thy) =
+           |          let
+           |             val p_state = Toplevel.proof_of state;
+           |             val ctxt = Proof.context_of p_state;
+           |             val params = ${Sledgehammer_Commands}.default_params thy
+           |                [("provers", "e"),("timeout","30"),("verbose","true")];
+           |             val results = ${Sledgehammer}.run_sledgehammer params ${Sledgehammer_Prover}.Normal NONE 1 override p_state;
+           |             val (result, (outcome, step)) = results;
+           |           in
+           |             (result, (${Sledgehammer}.short_string_of_sledgehammer_outcome outcome, [YXML.content_of step]))
+           |           end;
+           |    in
+           |      Timeout.apply (Time.fromSeconds 35) go_run (state, thy) end
+           |""".stripMargin
+      )
+
+    // Apply transitions to toplevel such that it is at a "hammerable" place
+    // Then
+    val result = normal_with_Sledgehammer(toplevel, thy0, List[String](), List[String]()).force.retrieveNow
+    println(result)
+
+  }
+}