itp-interface 1.0.0__py3-none-any.whl

itp_interface/pisa/src/main/python/data_extraction/process_data.py

@@ -0,0 +1,129 @@
+import json
+from tqdm import tqdm
+from mpmath import mp, mpf, fmod
+import hashlib
+import os
+
+
+def hash_string_to_int(arg):
+    return int(hashlib.sha256(arg.encode("utf-8")).hexdigest(), 16) % 10**30
+
+def hash_string_to_float(arg):
+    x = mpf(hash_string_to_int(arg))
+    return fmod(x * mp.pi, mpf(1.))
+
+def get_split(arg):
+    float_hash = hash_string_to_float(arg)
+    if float_hash < 0.98:
+        return "train"
+    elif float_hash < 0.99:
+        return "val"
+    else:
+        return "test"
+
+def process_one_extraction_file(file):
+    # Load the file
+    extraction = json.load(open(file))
+    # Get the information
+    theory_file_path = extraction["theory_file_path"]
+    assert os.path.exists(theory_file_path), f"Could not find {theory_file_path}"
+    working_directory = extraction["working_directory"]
+    problem_names = extraction["problem_names"]
+    transitions = extraction["translations"]
+    # Leave in only the actual problem names
+    problem_names = [problem_name.strip() for problem_name in problem_names]
+    problem_names = [problem_name for problem_name in problem_names if (problem_name.startswith("lemma") or problem_name.startswith("theorem")) and not problem_name.startswith("lemmas")]
+    
+    if not problem_names:
+        return {
+            "theory_file_path": theory_file_path,
+            "working_directory": working_directory,
+            "problems": []
+        }
+    # Filter out comments
+    good_transitions = []
+    for transition in transitions:
+        transition_text = transition[1].strip()
+        if transition_text.startswith("(*") and transition_text.endswith("*)"):
+            continue
+        if (transition_text.startswith("text \\<open>") or transition_text.startswith("txt \\<open>")) and transition_text.endswith("\\<close>"):
+            continue
+        good_transitions.append(transition)
+        
+    # Filter out all the transitions that are not in proofs
+    current_problem_name = None
+    problem_name_to_transitions = {}
+    proof_open = False
+    for transition in good_transitions:
+        _, transition_text, proof_level, _ = transition
+        # print(transition_text, proof_level)
+        if transition_text in problem_names:
+            current_problem_name = transition_text
+            assert proof_level == 0, transition
+            problem_name_to_transitions[current_problem_name] = [transition]
+            proof_open = True
+        elif proof_level == 0:
+            proof_open = False
+            continue
+        elif proof_open:
+            problem_name_to_transitions[current_problem_name].append(transition)
+        else:
+            pass
+
+    assert None not in problem_name_to_transitions
+    assert set(problem_name_to_transitions.keys()) == set(problem_names)
+
+    problems = []
+    for problem_name in problem_names:
+        transitions = problem_name_to_transitions[problem_name]
+        full_proof_text = "\n".join([transition[1] for transition in transitions])
+        split = get_split(problem_name)
+        problems.append(
+            {
+                "problem_name": problem_name,
+                "full_proof_text": full_proof_text,
+                "transitions": transitions,
+                "split": split
+            }
+        )
+        
+    return {
+        "theory_file_path": theory_file_path,
+        "working_directory": working_directory,
+        "problems": problems
+    }
+
+def process_extractions(files, saving_directory):
+    """Process the extractions"""
+    for file in tqdm(files):
+        extraction_from_a_file = process_one_extraction_file(file)
+        basename = os.path.basename(file)
+        assert basename.endswith("thy_output.json"), basename
+
+        new_basename = basename.replace("thy_output.json", "thy_problems.json")
+        saving_file_path = os.path.join(saving_directory, new_basename)
+        json.dump(extraction_from_a_file, open(saving_file_path, "w"))
+        
+
+if __name__ == "__main__":
+    import argparse
+    import glob
+    import os
+    import shutil
+    parser = argparse.ArgumentParser(description='Processing and filtering proving data.')
+    parser.add_argument('--extraction-file-directory', '-efd', help='Where the parsed json files are')
+    parser.add_argument('--saving-directory', '-sd', help='Where to save the translation pairs')
+    args = parser.parse_args()
+
+    extraction_file_directory = args.extraction_file_directory
+    saving_directory = args.saving_directory
+    if os.path.isdir(saving_directory):
+        shutil.rmtree(saving_directory)
+    os.makedirs(saving_directory)
+
+    files = glob.glob(f"{extraction_file_directory}/**/*.thy_output.json", recursive=True)
+    process_extractions(files, saving_directory)
+    # json.dump(
+    #     process_one_extraction_file("/home/qj213/afp_extractions/data/_home_qj213_afp-2022-12-06_thys_pGCL_Tutorial_Primitives.thy_output.json"),
+    #     open("test.json", "w"),
+    # )

itp_interface/pisa/src/main/python/legacy/PisaFlexibleClient.py

@@ -0,0 +1,167 @@
+from __future__ import print_function
+
+import os
+import json
+import grpc
+
+from copy import copy
+from func_timeout import func_set_timeout
+
+import server_pb2
+import server_pb2_grpc
+
+MAX_MESSAGE_LENGTH = 10485760
+
+
+def create_stub(port=9000):
+    channel = grpc.insecure_channel('localhost:{}'.format(port),
+                                    options=[('grpc.max_send_message_length', MAX_MESSAGE_LENGTH),
+                                             ('grpc.max_receive_message_length', MAX_MESSAGE_LENGTH)])
+    return server_pb2_grpc.ServerStub(channel)
+
+
+class IsaFlexEnv:
+    def __init__(self, port=9000, isa_path="/Applications/Isabelle2020.app/Isabelle",
+                 starter_string="theory Test imports Complex_Main begin",
+                 working_directory="/Users/qj213/Projects/afp-2021-02-11/thys/Functional-Automata"):
+        self.port = port
+        self.isa_path = isa_path
+        self.starter_string = starter_string
+        self.working_directory = working_directory
+
+        self.stub = None
+        self.obs_string = None
+        self.successful_starting = False
+        self.reset()
+
+    def observation(self):
+        return self.obs_string
+        
+    def is_finished(self, name_of_tls):
+        returned_string = self.stub.IsabelleCommand(server_pb2.IsaCommand(command=f"<is finished> {name_of_tls}")).state.strip()
+        if returned_string.startswith("t"):
+            return True
+        else:
+            return False
+
+    @staticmethod
+    def reward(done):
+        return 1. if done else 0.
+
+    def reset(self):
+        self.stub = create_stub(port=self.port)
+        try:
+            print(self.stub.InitialiseIsabelle(server_pb2.IsaPath(path=self.isa_path)).message)
+            print(self.stub.IsabelleWorkingDirectory(server_pb2.IsaPath(path=self.working_directory)).message)
+            print(self.stub.IsabelleContext(server_pb2.IsaContext(context=self.starter_string)).message)
+            self.successful_starting = True
+        except Exception as e:
+            print("Failure at initialising Isabelle process. "
+                  "Make sure the path your provide is where the Isabelle executable is.")
+            print(e)
+        return self.obs_string
+
+    @func_set_timeout(1800, allowOverride=True)
+    def step_to_top_level_state(self, action, tls_name, new_name):
+        # last_obs_string = self.stub.IsabelleCommand(server_pb2.IsaCommand(command=f"<get state> {tls_name}")).state
+        obs_string = "Step error"
+        done = False
+        try:
+            obs_string = self.stub.IsabelleCommand(
+                server_pb2.IsaCommand(command=f"<apply to top level state> {tls_name} <apply to top level state> {action} <apply to top level state> {new_name}")).state
+        except Exception as e:
+            print("***Something went wrong***")
+            print(e)
+
+        done = self.is_finished(new_name)
+        # done = True if ("subgoal" in last_obs_string and "subgoal" not in obs_string) else False
+        return obs_string, self.reward(done), done, {}
+
+    def proceed_after(self, line_string):
+        return self.post(f"<proceed after> {line_string}", forceTimeout=10000)
+
+    def clone_to_new_name(self, new_name):
+        return self.post(f"<clone> default <clone> {new_name}", forceTimeout=10)
+
+    @func_set_timeout(1800, allowOverride=True)
+    def post(self, action):
+        return self.stub.IsabelleCommand(server_pb2.IsaCommand(command=action)).state
+        # last_obs_string = self.obs_string
+        # try:
+        #     self.obs_string = self.stub.IsabelleCommand(server_pb2.IsaCommand(command=action)).state
+        # except Exception as e:
+        #     print("***Something went wrong***")
+        #     print(e)
+
+        # # done = self.is_finished(self.obs_string)
+        # done = self.is_finished("default")
+
+        # return self.obs_string, self.reward(done), done, {}
+
+    # def human_play(self):
+    #     done = False
+    #     while not done:
+    #         print(self.obs_string)
+    #         human_proof_line = input("Your tactic is my command: ")
+    #         if human_proof_line == "exit":
+    #             break
+    #         else:
+    #             obs, _, done, _ = self.step(human_proof_line)
+    #             print(obs)
+    #             print("=" * 50)
+
+    # def clone_top_level_state(self, tls_name):
+    #     try:
+    #         message = self.stub.IsabelleCommand(server_pb2.IsaCommand(command=f"<clone> {tls_name}")).state
+    #         print(message)
+    #         print(f"Cloned state called {tls_name}")
+    #     except Exception as e:
+    #         print("**Clone unsuccessful**")
+    #         print(e)
+
+    def proceed_to_line(self, line_stirng, before_after):
+        assert before_after in ["before", "after"]
+        try:
+            command = f"<proceed {before_after}> {line_stirng}"
+            print(command)
+            message = self.stub.IsabelleCommand(server_pb2.IsaCommand(command=command)).state
+            print(message)
+        except Exception as e:
+            print("Failure to proceed before line")
+            print(e)
+
+
+def parsed_json_to_env_and_dict(path_to_json, afp_path, port=9000, isa_path="/Applications/Isabelle2020.app/Isabelle"):
+    save_dict = json.load(open(path_to_json))
+    project = save_dict["project"]
+    wd = os.path.join(afp_path, "thys", project)
+    segments = save_dict["segments"]
+    # Find starter string
+    starter_string = None
+    for line in segments:
+        if line.strip().startswith("theory"):
+            starter_string = " ".join(line.strip().split("\n"))
+            break
+    assert starter_string
+    # print(port, isa_path, starter_string, wd, segments)
+    return IsaFlexEnv(port=port, isa_path=isa_path,
+                     starter_string=starter_string,
+                     working_directory=wd), save_dict
+
+
+def initialise_env(port, isa_path, theory_file_path=None, working_directory=None):
+    return IsaFlexEnv(port=port, isa_path=isa_path, starter_string=theory_file_path, working_directory=working_directory)
+
+
+def initialise_problem(env, problem_name):
+    env.proceed_to_line(problem_name, "after")
+    return env
+
+
+if __name__ == '__main__':
+    env = initialise_env(8000, 
+        working_directory="/Applications/Isabelle2021.app/src/HOL/Examples",
+        isa_path="/Applications/Isabelle2021.app", 
+        theory_file_path="/Applications/Isabelle2021.app/src/HOL/Examples/Adhoc_Overloading_Examples.thy"
+    )
+    print(env.post("<get_ancestors>"))

itp_interface/pisa/src/main/python/legacy/autof_test.py

@@ -0,0 +1,74 @@
+from PisaFlexibleClient import initialise_env
+
+
+theorem2 = """theory FunWithFunctions imports Complex_Main begin
+theorem 1: 
+  fixes f:: "real \<Rightarrow> real"
+    and g:: "real \<Rightarrow> real"
+  assumes "\<forall> x. f x = 3 * x - 8"
+    and "\<forall> x. g (f x) = 2 * x powr 2 + 5 * x - 3"
+  shows "g (-5) = 4"
+proof -
+  have "f 1 = -5" 
+    by (simp add: assms(1))
+  then have "g (-5) = g (f 1)" 
+    by auto
+  then show ?thesis 
+    by (simp add: assms(2))
+qed"""
+
+theorem2_sledgehammer = """theory NA imports Main begin
+theorem 1: "1+2=3"
+proof -
+  show ?thesis 
+  sledgehammer
+qed"""
+
+def get_parsed(env, theory, tls_name='default'):
+    # env.reset()
+    env.post('<initialise>')
+    steps = env.post(f"<parse text> ${theory}")
+    return steps.split('<SEP>')
+
+def run_proof_example(env, steps, tls_name='default'):
+    # env.reset()
+    env.post('<initialise>')
+
+    for i, step in enumerate(steps):
+        print("(%d) %s" % (i, step))
+        obs, reward, done, metadata = env.step_to_top_level_state(
+            action=step,
+            tls_name=tls_name,
+            new_name=tls_name
+        )
+        print("\tobs: %s\n\treward: %s\n\tdone: %s" % (obs, reward, done))
+
+
+if __name__ == '__main__':
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--isa-path', default='/private/home/aqj/Isabelle2021')
+    parser.add_argument('--working-dir', default='/private/home/aqj/afp-2021-10-22/thys/FunWithFunctions')
+    parser.add_argument('--theory-file', default='/private/home/aqj/afp-2021-10-22/thys/FunWithFunctions/FunWithFunctions.thy')
+
+    args = parser.parse_args()
+
+    # import ipdb; ipdb.set_trace(context=20)
+    env = initialise_env(9000,
+        working_directory=args.working_dir,
+        isa_path=args.isa_path,
+        theory_file_path=args.theory_file
+    )
+    steps = get_parsed(env, theorem2)
+    
+    steps = [step for step in steps if step!="$"]
+    print(steps)
+    
+    new_env = initialise_env(9000,
+        working_directory=args.working_dir,
+        isa_path=args.isa_path,
+        theory_file_path=args.theory_file
+    )
+    run_proof_example(new_env, steps)
+
+    # print(env.post("<get_ancestors>"))

itp_interface/pisa/src/main/python/legacy/cmd_client.py

@@ -0,0 +1,23 @@
+from PisaFlexibleClient import IsaFlexEnv
+
+import os
+
+
+if __name__ == "__main__":
+    isa_path = input("Path to Isabelle (default /home/qj213/Isabelle2021): ")
+    isa_path = "/home/qj213/Isabelle2021" if not isa_path else isa_path.strip()
+    afp_path = input("Path to the working directory (default /home/qj213/Isabelle2021/src/HOL/Examples): ")
+    afp_path = "/home/qj213/Isabelle2021/src/HOL/Examples" if not afp_path else afp_path.strip()
+    file_path = input("Path to a theory file (default /home/qj213/Isabelle2021/src/HOL/Examples/Drinker.thy): ")
+    file_path = "/home/qj213/Isabelle2021/src/HOL/Examples/Drinker.thy" if not file_path else file_path.strip()
+    env = IsaFlexEnv(
+        port=8000, isa_path=isa_path, starter_string=file_path,
+        working_directory=afp_path,
+    )
+
+    while True:
+        proof_step = input("Your chosen proof step ('<fin>' to exit): ")
+        if proof_step.strip().startswith("<fin>"):
+            break
+        obs, rewards, done, _ = env.step(proof_step)
+        print(obs)

itp_interface/pisa/src/main/python/legacy/convert_scala_dump_to_test_name_jsons.py

@@ -0,0 +1,14 @@
+if __name__ == "__main__":
+    import argparse
+    import os
+    import json
+    parser = argparse.ArgumentParser(description="Convert Scala dump to test name JSONs.")
+    parser.add_argument("--scala-dump-path", required=True, help="Scala dump path.")
+    args = parser.parse_args()
+
+    for file in os.listdir(args.scala_dump_path):
+        if file.startswith("test_name_"):
+            with open(os.path.join(args.scala_dump_path, file), "r") as f:
+                lines = f.read().strip()
+                thy_path, theorem_decl = lines.split("\n")
+                json.dump([[thy_path, theorem_decl]], open(os.path.join(args.scala_dump_path, file+".json"), "w"))

itp_interface/pisa/src/main/python/legacy/create_data_txt.py

@@ -0,0 +1,72 @@
+import os
+import argparse
+import random
+from smart_open import open
+from tqdm import tqdm
+
+
+# Token id: 14457; token: Cambridge
+# We use this token to separate the source and the target
+# It's unlikely to appear in the Isabelle proof corpus as it's the name of a place
+# Token id: 50256; token <|endoftext|>
+
+def process(src_path, tgt_path, output_path, mode):
+    random.seed(0)
+    if not output_path.startswith('gs://'):
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+    with open(src_path) as src_fhand, open(tgt_path) as tgt_fhand, open(
+            output_path, "w") as output_fhand:
+        src_lines = src_fhand.readlines()
+        tgt_lines = tgt_fhand.readlines()
+
+        total_lines = len(src_lines)
+        random_order = list(range(total_lines))
+        random.shuffle(random_order)
+        for index in tqdm(random_order):
+            src_line = src_lines[index]
+            tgt_line = tgt_lines[index]
+
+            if mode == "state_only":
+                output_fhand.write(src_line.strip().replace("State:",
+                                                            "<ISA_OBS>") + " Cambridge " + tgt_line.strip() + " <|endoftext|> ")
+            elif mode == "proof_only":
+                output_fhand.write(src_line.strip().replace("Proof:", "<ISA_PRF>") + " Cambridge " + tgt_line.strip() + " <|endoftext|> ")
+            elif mode == "proof_and_state":
+                output_fhand.write(
+                    src_line.strip().replace("<PS_SEP> State:",
+                                             "<ISA_OBS>").replace("Proof:",
+                                                                  "<ISA_PRF>")
+                    + " Cambridge " + tgt_line.strip() + " <|endoftext|> "
+                )
+            else:
+                output_fhand.write(src_line.strip() + " Cambridge " + tgt_line.strip() + " <|endoftext|> ")
+
+
+def create_data(data_dir, output_dir, name, mode):
+    train_src_path = os.path.join(data_dir, "train.src")
+    train_tgt_path = os.path.join(data_dir, "train.tgt")
+    # assert name in ["state_only", "proof_only", "proof_and_state"]
+    train_output_path = os.path.join(output_dir,
+                                     "train", "{}_train.txt".format(name))
+    val_src_path = os.path.join(data_dir, "val.src")
+    val_tgt_path = os.path.join(data_dir, "val.tgt")
+    val_output_path = os.path.join(output_dir,
+                                   "val", "{}_val.txt".format(name))
+    process(train_src_path, train_tgt_path, train_output_path, mode=mode)
+    process(val_src_path, val_tgt_path, val_output_path, mode=mode)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Create the .txt files for fine-tuning from the raw PISA src-tgt pairs.")
+    parser.add_argument("--data-dir", type=str, default="",
+                        help="Input directory (default: current directory)")
+    parser.add_argument("--output-dir", type=str, default="/home/qj213/data",
+                        help="Output directory (default: home data directory)")
+    parser.add_argument("--name", type=str,
+                        help="Name of the currently processed data.")
+    parser.add_argument("--mode", type=str,
+                        help="mode of the currently processed data (state_only, proof_only, proof_and_state, custom).")
+    args = parser.parse_args()
+    create_data(args.data_dir, args.output_dir, args.name, args.mode)