itp-interface 1.0.0__py3-none-any.whl

itp_interface/pisa/scripts/test_array_job.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+#! Name of the job:
+#SBATCH -J cpujob
+#! Which project should be charged:
+#SBATCH -A JAMNIK-SL3-CPU
+#! How many whole nodes should be allocated?
+#SBATCH --nodes=1
+#! How many (MPI) tasks will there be in total? (<= nodes*32)
+#! The skylake/skylake-himem nodes have 32 CPUs (cores) each.
+#SBATCH --ntasks=1
+#! How much wallclock time will be required?
+#SBATCH --time=01:00:00
+#! What types of email messages do you wish to receive?
+#SBATCH --mail-type=NONE
+#! Uncomment this to prevent the job from being requeued (e.g. if
+#! interrupted by node failure or system downtime):
+##SBATCH --no-requeue
+#SBATCH -p skylake
+#SBATCH --array=0-9%5
+
+list=(
+    "bash scripts/extract_with_hammer_bashes/script_0.sh"
+    "bash scripts/extract_with_hammer_bashes/script_1.sh"
+    "bash scripts/extract_with_hammer_bashes/script_2.sh"
+    "bash scripts/extract_with_hammer_bashes/script_3.sh"
+    "bash scripts/extract_with_hammer_bashes/script_4.sh"
+    "bash scripts/extract_with_hammer_bashes/script_5.sh"
+    "bash scripts/extract_with_hammer_bashes/script_6.sh"
+    "bash scripts/extract_with_hammer_bashes/script_7.sh"
+    "bash scripts/extract_with_hammer_bashes/script_8.sh"
+    "bash scripts/extract_with_hammer_bashes/script_9.sh"
+)
+
+${list[SLURM_ARRAY_TASK_ID]}

itp_interface/pisa/setup.sh

@@ -0,0 +1,25 @@
+# Update and install zip
+sudo apt-get update
+sudo apt-get install zip
+# Set up sdk
+curl -s "https://get.sdkman.io" | bash
+source "/home/qj213/.sdkman/bin/sdkman-init.sh"
+source .bashrc
+source .zshrc
+# Install java and sbt
+sdk install java 11.0.11-open
+sdk install sbt
+# Decompress and compile
+(cd Portal-to-ISAbelle; tar -zxf universal_test_theorems.tar.gz; sbt compile)
+cd ~
+# Install Isabelle
+wget https://isabelle.in.tum.de/website-Isabelle2021/dist/Isabelle2021_linux.tar.gz
+tar -xzf Isabelle2021_linux.tar.gz
+# Get afp
+wget https://www.isa-afp.org/release/afp-2021-10-22.tar.gz
+tar -xzf afp-2021-10-22.tar.gz
+# Get heaps
+wget https://storage.googleapis.com/n2formal-public-data/isabelle_heaps.tar.gz
+tar -xzf isabelle_heaps.tar.gz
+# Clean up
+rm *.tar.gz

itp_interface/pisa/src/main/protobuf/server.proto

@@ -0,0 +1,60 @@
+// Copyright 2015 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "pisa";
+option java_outer_classname = "ServerProto";
+option objc_class_prefix = "SP";
+
+package server;
+
+service Server {
+  rpc InitialiseIsabelle (IsaPath) returns (IsaMessage) {}
+  rpc IsabelleContext (IsaContext) returns (IsaMessage) {}
+  rpc IsabelleWorkingDirectory (IsaPath) returns (IsaMessage) {}
+  rpc IsabelleCommand (IsaCommand) returns (IsaState) {}
+  rpc IsabelleSetSearchWidth (IsaSearchWidth) returns (IsaMessage) {}
+  rpc IsabelleSearchIndexCommand (IsaSearchIndexCommand) returns (IsaState) {}
+}
+
+message IsaPath {
+  string path = 1;
+}
+
+message IsaContext {
+  string context = 1;
+}
+
+message IsaMessage {
+  string message = 1;
+}
+
+message IsaCommand {
+  string command = 1;
+}
+
+message IsaState {
+  string state = 1;
+}
+
+message IsaSearchWidth {
+  int32 width = 1;
+}
+
+message IsaSearchIndexCommand {
+  int32 index = 1;
+  string command = 2;
+}
+

itp_interface/pisa/src/main/python/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Editor-based HTTP Client requests
+/httpRequests/

itp_interface/pisa/src/main/python/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,18 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="DuplicatedCode" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <Languages>
+        <language minSize="1220" name="Python" />
+      </Languages>
+    </inspection_tool>
+    <inspection_tool class="JupyterPackageInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="N801" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

itp_interface/pisa/src/main/python/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

itp_interface/pisa/src/main/python/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Remote Python 3.8.2 (sftp://ajiang@vremote1.vectorinstitute.ai:22/h/ajiang/.conda/envs/smpl/bin/python)" project-jdk-type="Python SDK" />
+</project>

itp_interface/pisa/src/main/python/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/python.iml" filepath="$PROJECT_DIR$/.idea/python.iml" />
+    </modules>
+  </component>
+</project>

itp_interface/pisa/src/main/python/.idea/python.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+</module>

itp_interface/pisa/src/main/python/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../../.." vcs="Git" />
+  </component>
+</project>

itp_interface/pisa/src/main/python/conjecturing_parsing/conjecturer_postprocessing.py

@@ -0,0 +1,59 @@
+import os
+import json
+import glob
+from tqdm import tqdm
+import random
+
+def process_string(input_string):
+    return " ".join(input_string.replace("\n", " ").split())
+
+problem_names_split = json.load(open("data/fs_with_state/problem_names_split.json"))
+
+train_names = problem_names_split['train']
+val_names = problem_names_split['val']
+test_names = problem_names_split['test']
+
+train_theorem_names = {process_string(element[1]): element[0] for element in train_names}
+val_theorem_names = {process_string(element[1]): element[0] for element in val_names}
+test_theorem_names = {process_string(element[1]): element[0] for element in test_names}
+
+total_theorems = {"train": set(), "val": set(), "test": set()}
+for file_name in tqdm(glob.glob("data/conjecturer_extractions/**/*.src")):
+    tgt_file_name = file_name.replace("src", "tgt")
+    tgt_lines = open(tgt_file_name).readlines()
+
+    for i, line in enumerate(open(file_name).readlines()):
+        theorem_name = line.split("Proof:")[1].split("State:")[0].split("\\n")[0].strip()
+
+        if theorem_name in test_theorem_names:
+            save_file = os.path.join("data/conjecturer_seq2seq", "test.src")
+            total_theorems["test"].add(theorem_name)
+        elif theorem_name in val_theorem_names:
+            save_file = os.path.join("data/conjecturer_seq2seq", "val.src")
+            total_theorems["val"].add(theorem_name)
+        elif theorem_name in train_theorem_names:
+            save_file = os.path.join("data/conjecturer_seq2seq", "train.src")
+            total_theorems["train"].add(theorem_name)
+        else:
+            save_file = False
+        if save_file:
+            with open(save_file, "a") as fhand:
+                fhand.write(line)
+            with open(save_file.replace("src", "tgt"), "a") as f_tgt_hand:
+                f_tgt_hand.write(tgt_lines[i])
+
+print("Total possible train theorems: {}".format(len(train_theorem_names)))
+print("Conjecturing train theorems: {}".format(len(total_theorems["train"])))
+print("Total possible test theorems: {}".format(len(test_theorem_names)))
+print("Conjecturing test theorems: {}".format(len(total_theorems["test"])))
+
+parsed_test_names = list(total_theorems["test"])
+random.shuffle(parsed_test_names)
+for i in range(3000):
+    json_to_save = [
+        [test_theorem_names[parsed_test_names[i]], parsed_test_names[i]]
+    ]
+    json.dump(json_to_save, open("universal_test_theorems/test_name_{}.json".format(i), "w"))
+
+    if i < 300:
+        json.dump(json_to_save, open("universal_test_theorems/quick_test_name_{}.json".format(i), "w"))

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

@@ -0,0 +1,184 @@
+import json
+import multiprocessing as mp
+
+from pisa_client import initialise_env
+from utils.pisa_server_control import start_server, close_server
+
+
+def analyse_file_string(whole_file_string):
+    transitions = whole_file_string.split("<\TRANSEP>")
+    state_action_proof_level_tuples = list()
+    problem_names = list()
+    for transition in transitions:
+        if not transition:
+            continue
+        else:
+            state, action, proof_level = transition.split("<\STATESEP>")
+            hammer_results = "NA"
+        state = state.strip()
+        action = action.strip()
+        proof_level = int(proof_level.strip())
+        if (action.startswith("lemma") or action.startswith("theorem")) and not action.startswith("lemmas"):
+            problem_names.append(action)
+        state_action_proof_level_tuples.append((state, action, proof_level, hammer_results))
+    return {
+        "problem_names": problem_names,
+        "translations": state_action_proof_level_tuples
+    }
+
+
+def extract_a_file_from_params(
+    jar_path, 
+    isabelle_path, 
+    working_directory, 
+    theory_file_path,
+    saving_path, 
+    error_path,
+    sub_saving_path,
+    sub_error_path
+):
+    env = None
+
+    if os.path.isfile(saving_path):
+        return
+    try:
+        # Figure out the parameters to start the server
+        identity = mp.current_process()._identity
+        if identity:
+            rank = identity[0] % 200
+        else:
+            rank = 0
+        port = 8000 + rank
+        server_subprocess_id = start_server(jar_path, port, 
+            outputfile=sub_saving_path, errorfile=sub_error_path)
+        # Getting the environment
+        env = initialise_env(
+            port=port,
+            isa_path=isabelle_path,
+            theory_file_path=theory_file_path,
+            working_directory=working_directory,
+        )
+        whole_file_string = env.post("PISA extract data")
+        # Parse the string and dump
+        analysed_file = analyse_file_string(whole_file_string)
+        analysed_file["theory_file_path"] = theory_file_path
+        analysed_file["working_directory"] = working_directory
+        json.dump(analysed_file, open(saving_path, "w"))
+        
+    except Exception as e:
+        print(e)
+        json.dump({"error": str(e)}, open(error_path, "w"))
+
+    # Clean up
+    del env
+    close_server(server_subprocess_id)
+
+
+def extract_a_file(params_path):
+    """
+    Extracts the data from a single file.
+
+    :param params_path: Path to the JSON file containing the parameters.
+    :param rank: Rank of the process in the subprocess pool.
+    :return: None
+    """
+    # Load the parameters
+    params = json.load(open(params_path))
+    jar_path = params["jar_path"]
+    isabelle_path = params["isabelle_path"]
+    working_directory = params["working_directory"]
+    theory_file_path = params["theory_file_path"]
+    saving_path = params["saving_path"]
+    error_path = params["error_path"]
+    sub_saving_path = params["sub_saving_path"]
+    sub_error_path = params["sub_error_path"]
+
+    extract_a_file_from_params(
+        jar_path, 
+        isabelle_path, 
+        working_directory, 
+        theory_file_path,
+        saving_path, 
+        error_path,
+        sub_saving_path, 
+        sub_error_path,
+    )
+
+
+if __name__ == "__main__":
+    import glob
+    import os
+    import argparse
+    from tqdm import tqdm
+    parser = argparse.ArgumentParser(description='Extracting transition data from theory files.')
+    parser.add_argument('--jar-path', '-jp', help='Path to the jar file', default=None)
+    parser.add_argument('--isabelle-path', '-ip', help='Path to the Isabelle installation', default=None)
+    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()
+
+    jar_path = args.jar_path
+    if jar_path is None:
+        jar_path = "/home/qj213/Portal-to-ISAbelle/target/scala-2.13/PISA-assembly-0.1.jar"
+    isabelle_path = args.isabelle_path
+    if isabelle_path is None:
+        isabelle_path = "/home/qj213/Isabelle2022"
+    extraction_file_directory = args.extraction_file_directory
+    saving_directory = args.saving_directory
+    if not os.path.isdir(saving_directory):
+        os.makedirs(saving_directory)
+
+    output_data_path = os.path.join(saving_directory, "data")
+    output_param_path = os.path.join(saving_directory, "params")
+    if not os.path.isdir(output_data_path):
+        os.makedirs(output_data_path)
+    if not os.path.isdir(output_param_path):
+        os.makedirs(output_param_path)
+
+    # extraction_file_directory = "/home/qj213/afp-2022-12-06/thys"
+    # extraction_file_directory = "/home/qj213/Isabelle2022/src/HOL"
+    # saving_directory = "/home/qj213/afp_extractions"
+    # saving_directory = "/home/qj213/std_extractions"
+
+    files = glob.glob(extraction_file_directory.rstrip("/") + '/**/*.thy', recursive=True)
+    param_paths = list()
+
+    for file_path in tqdm(files):
+        identifier = file_path.replace("/", "_")
+
+        if "thys" in file_path:
+            bits = file_path.split("/")
+            thys_index = bits.index("thys")
+            working_directory = "/".join(bits[:thys_index + 2])
+        elif "src/HOL" in file_path:
+            bits = file_path.split("/")
+            hol_index = bits.index("HOL")
+            bits = bits[:-1]
+            bits = bits[:hol_index + 2]
+            working_directory = "/".join(bits)
+        else:
+            raise AssertionError
+        saving_path = f"{output_data_path}/{identifier}_output.json"
+        error_path = f"{output_data_path}/{identifier}_error.json"
+        sub_saving_path = f"{output_data_path}/{identifier}_subout.json"
+        sub_error_path = f"{output_data_path}/{identifier}_suberr.json"
+        if os.path.exists(saving_path) or os.path.exists(error_path):
+            continue
+        params = {
+            "jar_path": jar_path,
+            "isabelle_path": isabelle_path,
+            "working_directory": working_directory,
+            "theory_file_path": file_path,
+            "saving_path": saving_path,
+            "error_path": error_path,
+            "sub_saving_path": sub_saving_path,
+            "sub_error_path": sub_error_path
+        }
+        param_path = os.path.join(output_param_path, f"{identifier}.json")
+        json.dump(params, open(param_path, "w"))
+
+        param_paths.append(param_path)
+    
+    print(f"Extracting {len(param_paths)} files in total.")
+    with mp.Pool(processes=int(mp.cpu_count()/8)) as pool:
+        pool.map(extract_a_file, param_paths)

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

@@ -0,0 +1,221 @@
+import json
+import multiprocessing as mp
+
+from utils.pisa_server_control import start_server, close_server
+from pisa_client import initialise_env
+
+
+def find_actual_name_indices(decorated_name):
+    # Give the actual name starting and ending indices of a theorem given its decorated name
+    # Example: decorated_name = (in bidirected_digraph) has_dom_arev[simp]
+    #          actual_name = had_dom_arev
+    length = len(decorated_name)
+    if length == 0:
+        return 0, 0
+    si = 0
+    all_actual_indices = []
+    mode = "normal"
+    while si < length:
+        if decorated_name[si] == "(":
+            mode = "("
+        elif decorated_name[si] == ")":
+            assert mode == "("
+            mode = "normal"
+        elif decorated_name[si] == "[":
+            mode = "["
+        elif decorated_name[si] == "]":
+            assert mode == "["
+            mode = "normal"
+        elif mode == "normal":
+            all_actual_indices.append(si)
+        else:
+            pass
+        # print(si, decorated_name[si])
+        si += 1
+    assert all([index+1 == all_actual_indices[i+1] for i, index in enumerate(all_actual_indices[:-1])]), (all_actual_indices, decorated_name)
+    return all_actual_indices[0], all_actual_indices[-1]
+
+
+def find_premises_from_a_file(path_dict):
+    problems_path = path_dict["problems_path"]
+    jar_path = path_dict["jar_path"]
+    saving_directory = path_dict["saving_directory"]
+    server_dump_path = path_dict["server_dump_path"]
+
+    saving_path = os.path.join(
+        saving_directory, 
+        os.path.basename(problems_path).replace("thy_problems.json", "thy_premises.jsonl")
+    )
+    error_path = saving_path.replace("thy_premises.jsonl", "thy_errors.txt")
+
+    if os.path.isfile(saving_path) or os.path.isfile(error_path):
+        return
+
+    if server_dump_path is None:
+        server_output_path, server_error_path = None, None
+    else:
+        server_output_path = os.path.join(
+            server_dump_path,
+            os.path.basename(problems_path).replace("thy_problems.json", "thy_server_output.txt")
+        )
+        server_error_path = os.path.join(
+            server_dump_path,
+            os.path.basename(problems_path).replace("thy_problems.json", "thy_server_error.txt")
+        )
+
+    problems_json = json.load(open(problems_path))
+    theory_file_path = problems_json["theory_file_path"]
+    working_directory = problems_json["working_directory"]
+    problems = problems_json["problems"]
+
+    env = None
+    server_subprocess_id = None
+    try:
+        # Figure out the parameters to start the server
+        identity = mp.current_process()._identity
+        if identity:
+            rank = identity[0] % 200
+        else:
+            rank = 0
+        port = 8000 + rank
+
+        server_subprocess_id = start_server(
+            jar_path, port, outputfile=server_output_path, errorfile=server_error_path
+        )
+        
+        # Getting the environment
+        print(f"Port: {port}")
+        env = initialise_env(
+            port=port,
+            isa_path=isabelle_path,
+            theory_file_path=theory_file_path,
+            working_directory=working_directory,
+        )
+
+        # Find the premises to each problem
+        premises = []
+        # print(len(problems))
+        for problem in problems:
+            try:
+                # As an example
+                # lemma easy [simp]: "1+2=3" 
+                #   by auto
+                # problem_name = 'lemma easy [simp]: "1+2=3"'
+                # only_name = 'easy'
+                # proof_body = '"1+2=3"\n by auto'
+                # full_proof_text = 'lemma easy [simp]: "1+2=3" 
+                #   by auto'
+                # full_name = 'easy [simp]'
+                
+                problem_name = problem["problem_name"].strip()
+                # print(problem_name)
+                assert problem_name.startswith("lemma") or problem_name.startswith("theorem"), problem_name
+                only_name = problem_name.lstrip("lemma").lstrip("theorem").strip()
+                
+                full_proof_text = problem["full_proof_text"]
+                transitions = problem["transitions"]
+                if ":" not in only_name:
+                    proof_body = only_name.strip() + "\n" + "\n".join([element[1].strip() for element in transitions][1:]).strip()
+                    only_name = ""
+                else:
+                    only_name = only_name.split(":")[0].strip()
+                    proof_body = ":".join(full_proof_text.strip().split(":")[1:]).strip()
+
+                # print(proof_body, full_proof_text)
+                
+                actual_name_si, actual_name_ei = find_actual_name_indices(only_name)
+                full_name = only_name
+                only_name = only_name[actual_name_si:actual_name_ei+1]
+                
+                split = problem["split"]
+                # print(f"Problem name: {problem_name}. Only name: {only_name}.")
+                # print(0.0, full_proof_text)
+                env.accumulative_step_before_theorem_starts(problem_name)
+                env.accumulative_step_through_a_theorem()
+                premises_and_their_definitions = env.get_premises_and_their_definitions(full_name, only_name, proof_body)
+                
+                # premises_and_their_definitions = env.get_premises_and_their_definitions(
+                #     problem_name, only_name, full_proof_text
+                # )
+                # env.proceed_until_end_of_theorem_proof(problem_name)
+                # print(premises_and_their_definitions)
+                premises.append(
+                    {   
+                        "theory_file_path": theory_file_path,
+                        "working_directory": working_directory,
+                        "problem_name": problem_name,
+                        "only_name": only_name,
+                        "premises_and_their_definitions": premises_and_their_definitions,
+                        "full_proof_text": full_proof_text,
+                        "split": split,
+                    }
+                )
+            except Exception as excp:
+                print(excp)
+                continue
+        # print(saving_path)
+        with open(saving_path, "w") as fout:
+            for premise in premises:
+                fout.write(json.dumps(premise) + "\n")
+
+    except Exception as e:
+        print(e)
+        with open(error_path, "w") as fout:
+            fout.write(str(e))
+
+    # Clean up
+    del env
+    if server_subprocess_id is not None:
+        close_server(server_subprocess_id)
+
+   
+if __name__ == "__main__":
+    import argparse
+    import glob
+    import os
+    parser = argparse.ArgumentParser(description='Extracting translation pairs.')
+    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')
+    parser.add_argument('--server-dump-path', '-sdp', help="Where to dump the server's output")
+    parser.add_argument('--jar-path', '-jp', help='Path to the jar file', 
+        default="/home/qj213/Portal-to-ISAbelle/target/scala-2.13/PISA-assembly-0.1.jar")
+    parser.add_argument('--isabelle-path', '-ip', help='Path to the Isabelle installation', 
+        default="/home/qj213/Isabelle2022")
+    args = parser.parse_args()
+
+    extraction_file_directory = args.extraction_file_directory
+    saving_directory = args.saving_directory
+    jar_path = args.jar_path
+    isabelle_path = args.isabelle_path
+    server_dump_path = args.server_dump_path
+
+    if not os.path.exists(saving_directory):
+        os.makedirs(saving_directory)
+
+    files = glob.glob(f"{extraction_file_directory}/**/*.thy_problems.json", recursive=True)
+    list_of_path_dicts = [
+        {
+            "problems_path": file, 
+            "saving_directory": saving_directory, 
+            "jar_path": jar_path, 
+            "isabelle_path": isabelle_path,
+            "server_dump_path": server_dump_path,
+        }
+        for file in files
+    ]
+    
+    with mp.Pool(processes=int(mp.cpu_count()/8)) as pool:
+    # with mp.Pool(processes=1) as pool:
+        pool.map(find_premises_from_a_file, list_of_path_dicts)
+
+    # print(list_of_path_dicts[1])
+    # find_premises_from_a_file(list_of_path_dicts[1])
+    # find_premises_from_a_file(
+    #     {
+    #         "problems_path": "/home/qj213/problems/afp/_home_qj213_afp-2022-12-06_thys_Formal_SSA_Construct_SSA.thy_problems.json", 
+    #         "saving_directory": saving_directory, 
+    #         "jar_path": jar_path, 
+    #         "isabelle_path": isabelle_path,
+    #         "server_dump_path": server_dump_path,
+    #     }
+    # )