itp-interface 1.0.0__py3-none-any.whl

itp_interface/agent/simple_proof_agent.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+
+import sys
+root_dir = f"{__file__.split('itp_interface')[0]}"
+if root_dir not in sys.path:
+    sys.path.append(root_dir)
+import logging
+import typing
+from itp_interface.rl.proof_action import ProofAction
+from itp_interface.rl.abstraction import Agent, Policy
+from itp_interface.rl.simple_proof_env import ProofEnv
+
+
+class ProofAgent(Agent):
+    def __init__(self, 
+        name: str, 
+        policy: Policy, 
+        should_checkpoint: bool = False, 
+        proof_dump_file_name: str = None, 
+        logger: logging.Logger = None):
+        self._policy = policy
+        self._name = name
+        self._should_checkpoint = should_checkpoint
+        self._proof_dump_file_name = proof_dump_file_name
+        self.logger = logger or logging.getLogger(__name__)
+        pass
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def checkpoint(self):
+        pass
+
+    def clone(self):
+        pass
+
+    def run_episode(self, env: ProofEnv, max_steps_per_episode: int, render: bool):
+        def _stop_policy(steps: int, info: typing.Dict[str, typing.Any]):
+            return steps >= max_steps_per_episode
+        def _policy_info_message(steps: int, info: typing.Dict[str, typing.Any]):
+            return f"Step {steps}/{max_steps_per_episode}"
+        self._run_episode_as_per_policy(env, _stop_policy, _policy_info_message, render)
+
+    def run(self, env: ProofEnv, episodes: int, max_steps_per_episode: int, render: bool):
+        assert isinstance(env, ProofEnv)
+        while episodes > 0:
+            self.run_episode(env, max_steps_per_episode, render)
+            episodes -= 1
+        pass
+
+    def run_episodes_till_stop(self, env: ProofEnv, episodes: int, render: bool, 
+        stop_policy: typing.Callable[[int, typing.Dict[str, typing.Any]], bool], 
+        policy_info_message: typing.Callable[[int, typing.Dict[str, typing.Any]], str]):
+        assert isinstance(env, ProofEnv)
+        while episodes > 0:
+            self._run_episode_as_per_policy(env, stop_policy, policy_info_message, render)
+            episodes -= 1
+
+    def _run_episode_as_per_policy(self, 
+            env: ProofEnv, 
+            stop_policy: typing.Callable[[int, typing.Dict[str, typing.Any]], bool],
+            policy_info_message: typing.Callable[[int, typing.Dict[str, typing.Any]], str],
+            render: bool):
+        env.reset()
+        done = False
+        steps = 0
+        total_reward = 0
+        next_state = env.state
+        additional_info = self._policy.get_efficiency_info()
+        while not done and not stop_policy(steps, additional_info):
+            self.logger.info(policy_info_message(steps, additional_info))
+            self.logger.info("Asking policy for next action")
+            action = self._policy(next_state)
+            assert isinstance(action, ProofAction)
+            self.logger.info(f"Got Action: {action}")
+            if action.action_type != ProofAction.ActionType.EXIT:
+                state, _, next_state, reward, done, info = env.step(action)
+                if render:
+                    self.logger.info("**"*20)
+                    env.render()
+                    self.logger.info("**"*20)
+                if action.action_type != ProofAction.ActionType.BACKTRACK:
+                    # Don't update policy for backtracking actions, this will create a 
+                    # a very nasty loop in the policy.
+                    self.logger.info("Updating policy")
+                    self._policy.update(state, action, next_state, reward, done, info)
+                    self.logger.info("Policy updated")
+                steps += 1
+                total_reward += reward
+            else:
+                self.logger.warning("Got EXIT action, exiting")
+                break
+            additional_info = self._policy.get_efficiency_info()
+        env.dump_proof(self._proof_dump_file_name, additional_info)
+        if self._should_checkpoint:
+            self.logger.info("Checkpointing policy")
+            self._policy.checkpoint()
+
+

itp_interface/coq_ser_api/__init__.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+##########################################################################
+#
+#    This file is part of Proverbot9001.
+#
+#    Proverbot9001 is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Proverbot9001 is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Proverbot9001.  If not, see <https://www.gnu.org/licenses/>.
+#
+#    Copyright 2019 Alex Sanchez-Stern and Yousef Alhessi
+#
+##########################################################################
+
+import contextlib
+import subprocess
+import re
+
+from typing import Iterator, List, Optional
+
+from .util import eprint, parseSexpOneLevel
+from .contexts import (ScrapedTactic, TacticContext, Obligation,
+                       ProofContext, SexpObligation)
+from .lsp_backend import main as lsp_main
+from .lsp_backend import CoqLSPyInstance
+from .serapi_backend import CoqSeraPyInstance
+from .coq_util import (kill_comments, preprocess_command, get_stem,
+                       split_tactic, parse_hyps, kill_nested,
+                       get_var_term_in_hyp, get_hyp_type,
+                       get_vars_in_hyps, get_indexed_vars_in_hyps,
+                       get_indexed_vars_dict, get_first_var_in_hyp,
+                       tacticTakesHypArgs, tacticTakesBinderArgs,
+                       tacticTakesIdentifierArg,
+                       lemma_name_from_statement, get_words,
+                       get_binder_var, normalizeNumericArgs,
+                       parsePPSubgoal, summarizeContext, summarizeObligation,
+                       isValidCommand, load_commands_preserve,
+                       load_commands, read_commands,
+                       get_module_from_filename, symbol_matches,
+                       subgoalSurjective, contextSurjective,
+                       lemmas_in_file, let_to_hyp, admit_proof_cmds,
+                       set_switch, setup_opam_env,
+                       module_prefix_from_stack, sm_prefix_from_stack,
+                       possibly_starting_proof, ending_proof,
+                       initial_sm_stack, update_sm_stack,
+                       lemmas_defined_by_stmt)
+from .coq_agent import TacticHistory, CoqAgent
+from .coq_backend import (CoqBackend, CoqExn, BadResponse, AckError,
+                          CompletedError, CoqTimeoutError,
+                          UnrecognizedError, CoqAnomaly, CoqException,
+                          ParseError, NoSuchGoalError, LexError, CoqOverflowError)
+
+def set_parseSexpOneLevel_fn(newfn) -> None:
+    global parseSexpOneLevel
+    parseSexpOneLevel = newfn
+
+def GetCoqAgent(prelude: str = ".", verbosity: int = 0, set_env: bool = True, use_human_readable_str: bool = False, env_string: str = None, timeout = 60) -> CoqAgent:
+    if set_env:
+        setup_opam_env(env_string)
+    version_string = subprocess.run(["coqc", "--version"], stdout=subprocess.PIPE,
+                                    text=True, check=True).stdout
+    version_match = re.fullmatch(r"(?:The Coq Proof Assistant, version)? \d+\.(\d+).*", version_string,
+                                 flags=re.DOTALL)
+    assert version_match, version_string
+    minor_version = int(version_match.group(1))
+    assert minor_version >= 10, \
+            "Versions of Coq before 8.10 are not supported! "\
+            f"Currently installed coq is {version_string}"
+
+    backend: CoqBackend
+    try:
+        if minor_version < 16:
+            backend = CoqSeraPyInstance(["sertop", "--implicit"],
+                                        timeout=timeout,
+                                        set_env=set_env)
+            backend.verbosity = verbosity
+        else:
+            backend = CoqLSPyInstance("coq-lsp", root_dir=prelude, set_env=set_env, timeout=timeout)
+        agent = CoqAgent(backend, prelude, verbosity=verbosity, use_human_readable=use_human_readable_str)
+    except CoqAnomaly:
+        eprint("Anomaly during initialization! Something has gone horribly wrong.")
+        raise
+    return agent
+
+@contextlib.contextmanager
+def CoqContext(prelude: str = ".", verbosity: int = 0, set_env: bool = True) \
+        -> Iterator[CoqAgent]:
+    if set_env:
+        setup_opam_env()
+    version_string = subprocess.run(["coqc", "--version"], stdout=subprocess.PIPE,
+                                    text=True, check=True).stdout
+    version_match = re.fullmatch(r"(?:The Coq Proof Assistant, version)? \d+\.(\d+).*", version_string,
+                                 flags=re.DOTALL)
+    assert version_match, version_string
+    minor_version = int(version_match.group(1))
+    assert minor_version >= 10, \
+            "Versions of Coq before 8.10 are not supported! "\
+            f"Currently installed coq is {version_string}"
+
+    backend: CoqBackend
+    try:
+        if minor_version < 16:
+            backend = CoqSeraPyInstance(["sertop", "--implicit"],
+                                        set_env=set_env)
+            backend.verbosity = verbosity
+        else:
+            backend = CoqLSPyInstance("coq-lsp", root_dir=prelude, set_env=set_env)
+        agent = CoqAgent(backend, prelude, verbosity=verbosity)
+    except CoqAnomaly:
+        eprint("Anomaly during initialization! Something has gone horribly wrong.")
+        raise
+
+    try:
+        yield agent
+    finally:
+        agent.backend.close()
+
+# Backwards Compatibility (to some extent)
+def SerapiInstance(coq_command: List[str], module_name: Optional[str],
+                   prelude: str, set_env: bool = True,
+                   timeout: int = 30, use_hammer: bool = False,
+                   log_outgoing_messages: Optional[str] = None,
+                   use_human_readable_str : bool = False) -> CoqAgent:
+    del timeout
+    del use_hammer
+    del log_outgoing_messages
+    backend = CoqSeraPyInstance(coq_command, set_env=set_env)
+    agent = CoqAgent(backend, prelude, use_human_readable=use_human_readable_str)
+    if module_name and module_name not in ["Parameter", "Prop", "Type"]:
+        agent.run_stmt(f"Module {module_name}.")
+    return agent
+@contextlib.contextmanager
+def SerapiContext(coq_commands: List[str], module_name: Optional[str],
+                  prelude: str, set_env: bool = True, use_hammer: bool = False,
+                  log_outgoing_messages: Optional[str] = None) \
+                  -> Iterator[CoqAgent]:
+    del use_hammer
+    del log_outgoing_messages
+    try:
+        backend = CoqSeraPyInstance(coq_commands, set_env=set_env)
+        agent = CoqAgent(backend, prelude)
+        if module_name and module_name not in ["Parameter", "Prop", "Type"]:
+            agent.run_stmt(f"Module {module_name}.")
+    except CoqAnomaly:
+        eprint("Anomaly during initialization! Something has gone horribly wrong.")
+        raise
+    try:
+        yield agent
+    finally:
+        agent.backend.close()
+SerapiException = CoqException
+def admit_proof(coq: CoqAgent, lemma_statement: str,
+                ending_statement: str) -> List[str]:
+    admit_cmds = admit_proof_cmds(lemma_statement, ending_statement)
+    for cmd in admit_cmds:
+        coq.run_stmt(cmd)
+    return admit_cmds

itp_interface/coq_ser_api/contexts.py

@@ -0,0 +1,283 @@
+#!/usr/bin/env python3.7
+##########################################################################
+#
+#    This file is part of Proverbot9001.
+#
+#    Proverbot9001 is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Proverbot9001 is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Proverbot9001.  If not, see <https://www.gnu.org/licenses/>.
+#
+#    Copyright 2019 Alex Sanchez-Stern and Yousef Alhessi
+#
+##########################################################################
+
+import json
+import hashlib
+from typing import (List, TextIO, Optional, NamedTuple, Union, Dict,
+                    Any, Type, TYPE_CHECKING, Sequence)
+
+if TYPE_CHECKING:
+    from sexpdata import Sexp
+
+class SexpObligation(NamedTuple):
+    hypotheses: List['Sexp']
+    goal: 'Sexp'
+
+class Obligation:
+    hypotheses: Sequence[str]
+    goal: str
+
+    def __init__(self, hypotheses: Sequence[str], goal: str) -> None:
+        self.hypotheses = tuple(hypotheses)
+        self.goal = goal
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Obligation):
+            return False
+        if self.goal != other.goal:
+            return False
+        if self.hypotheses != other.hypotheses:
+            return False
+        return True
+
+    def __hash__(self) -> int:
+        return int.from_bytes(hashlib.md5(json.dumps(
+          (self.hypotheses, self.goal),
+           sort_keys=True).encode('utf-8')).digest(), byteorder='big')
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(**data)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"hypotheses": list(self.hypotheses),
+                "goal": self.goal}
+
+    @classmethod
+    def from_structeq(cls, obj: Any) -> 'Obligation':
+        return Obligation(tuple(obj.hypotheses), obj.goal)
+    
+    def __str__(self) -> str:
+        return f"Obligation(goal={self.goal}, hypotheses={self.hypotheses})"
+
+
+class ProofContext(NamedTuple):
+    fg_goals: List[Obligation]
+    bg_goals: List[Obligation]
+    shelved_goals: List[Obligation]
+    given_up_goals: List[Obligation]
+
+    @classmethod
+    def empty(cls: Type['ProofContext']):
+        return ProofContext([], [], [], [])
+
+    @classmethod
+    def from_dict(cls, data):
+        fg_goals = list(map(Obligation.from_dict, data["fg_goals"]))
+        bg_goals = list(map(Obligation.from_dict, data["bg_goals"]))
+        shelved_goals = list(map(Obligation.from_dict, data["shelved_goals"]))
+        given_up_goals = list(map(Obligation.from_dict,
+                                  data["given_up_goals"]))
+        return cls(fg_goals, bg_goals, shelved_goals, given_up_goals)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"fg_goals": list(map(Obligation.to_dict, self.fg_goals)),
+                "bg_goals": list(map(Obligation.to_dict, self.bg_goals)),
+                "shelved_goals": list(map(Obligation.to_dict,
+                                          self.shelved_goals)),
+                "given_up_goals": list(map(Obligation.to_dict,
+                                           self.given_up_goals))}
+
+    @property
+    def all_goals(self) -> List[Obligation]:
+        return self.fg_goals + self.bg_goals + \
+            self.shelved_goals + self.given_up_goals
+
+    @property
+    def focused_goal(self) -> str:
+        if self.fg_goals:
+            return self.fg_goals[0].goal
+        else:
+            return ""
+
+    @property
+    def focused_hyps(self) -> List[str]:
+        if self.fg_goals:
+            return list(self.fg_goals[0].hypotheses)
+        else:
+            return []
+
+    @classmethod
+    def from_structeq(cls, obj: Any) -> 'ProofContext':
+        return ProofContext([Obligation.from_structeq(fg) for fg in obj.fg_goals],
+                            [Obligation.from_structeq(bg) for bg in obj.bg_goals],
+                            [Obligation.from_structeq(sg) for sg in obj.shelved_goals],
+                            [Obligation.from_structeq(gg) for gg in obj.given_up_goals])
+    
+    def __str__(self) -> str:
+        return f"ProofContext(fg_goals={self.fg_goals}, bg_goals={self.bg_goals}, "\
+            f"shelved_goals={self.shelved_goals}, given_up_goals={self.given_up_goals})"
+
+
+def assert_proof_context_matches(context1: ProofContext, context2: ProofContext) -> None:
+    def assert_obligation_matches(label: str, obl1: Obligation, obl2: Obligation) -> None:
+        assert obl1.goal == obl2.goal, f"{label}: Goals {obl1.goal} and {obl2.goal} don't match"
+        for idx, (hyp1, hyp2) in enumerate(zip(obl1.hypotheses, obl2.hypotheses)):
+            assert hyp1 == hyp2, f"{label}: Hypotheses at index {idx} don't match! "\
+                f"{hyp1} vs {hyp2}"
+    assert len(context1.fg_goals) == len(context2.fg_goals), \
+        "Number of foreground goals doesn't match! "\
+        f"First context has {len(context1.fg_goals)} goals, "\
+        f"but second context has {len(context2.fg_goals)} goals."
+    for idx, (fg_goal1, fg_goal2) in enumerate(zip(context1.fg_goals,
+                                                   context2.fg_goals)):
+        assert_obligation_matches(f"Item {idx} of foreground goals", fg_goal1, fg_goal2)
+    assert len(context1.bg_goals) == len(context2.bg_goals), \
+        "Number of background goals doesn't match! "\
+        f"First context has {len(context1.fg_goals)} goals, "\
+        f"but second context has {len(context2.fg_goals)} goals."
+    for idx, (bg_goal1, bg_goal2) in enumerate(zip(context1.bg_goals,
+                                                   context2.bg_goals)):
+        assert_obligation_matches(f"Item {idx} of background goals", bg_goal1, bg_goal2)
+    assert len(context1.shelved_goals) == len(context2.shelved_goals), \
+        "Number of shelved goals doesn't match! "\
+        f"First context has {len(context1.fg_goals)} goals, "\
+        f"but second context has {len(context2.fg_goals)} goals."
+    for idx, (shelved_goal1, shelved_goal2) in enumerate(zip(context1.shelved_goals,
+                                                             context2.shelved_goals)):
+        assert_obligation_matches(f"Item {idx} of shelved goals",
+                                  shelved_goal1, shelved_goal2)
+    assert len(context1.given_up_goals) == len(context2.given_up_goals), \
+        "Number of background goals doesn't match! "\
+        f"First context has {len(context1.fg_goals)} goals, "\
+        f"but second context has {len(context2.fg_goals)} goals."
+    for idx, (given_up_goal1, given_up_goal2) in enumerate(zip(context1.given_up_goals,
+                                                               context2.given_up_goals)):
+        assert_obligation_matches(f"Item {idx} of given up goals",
+                                  shelved_goal1, shelved_goal2)
+
+def ident_in_context(ident: str, context: ProofContext) -> bool:
+    def ident_in_obl(obligation: Obligation) -> bool:
+        if ident in obligation.goal:
+            return True
+        return any(ident in hyp for hyp in obligation.hypotheses)
+    return any(ident_in_obl(obl) for obl in
+               context.all_goals)
+
+
+class ScrapedTactic(NamedTuple):
+    relevant_lemmas: List[str]
+    prev_tactics: List[str]
+    context: ProofContext
+    tactic: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"relevant_lemmas": self.relevant_lemmas,
+                "prev_tactics": self.prev_tactics,
+                "context": self.context.to_dict(),
+                "tactic": self.tactic}
+
+    @classmethod
+    def from_structeq(cls, obj: Any) -> 'ScrapedTactic':
+        return ScrapedTactic(obj.relevant_lemmas, obj.prev_tactics,
+                             ProofContext.from_structeq(obj.context),
+                             obj.tactic)
+
+
+class TacticContext:
+    relevant_lemmas: Sequence[str]
+    prev_tactics: Sequence[str]
+    hypotheses: Sequence[str]
+    goal: str
+
+    def __init__(self, relevant_lemmas: Sequence[str], prev_tactics: Sequence[str],
+                 hypotheses: Sequence[str], goal: str) -> None:
+        self.relevant_lemmas = tuple(relevant_lemmas)
+        self.prev_tactics = tuple(prev_tactics)
+        self.hypotheses = tuple(hypotheses)
+        self.goal = goal
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, TacticContext):
+            return False
+        if self.goal != other.goal:
+            return False
+        if self.hypotheses != other.hypotheses:
+            return False
+        if self.relevant_lemmas != other.relevant_lemmas:
+            return False
+        if self.prev_tactics != other.prev_tactics:
+            return False
+        return True
+    def __hash__(self) -> int:
+        return hash((self.relevant_lemmas, self.prev_tactics, self.hypotheses, self.goal))
+
+
+class FullContext(NamedTuple):
+    relevant_lemmas: List[str]
+    prev_tactics: List[str]
+    obligations: ProofContext
+
+    def as_tcontext(self) -> TacticContext:
+        return TacticContext(self.relevant_lemmas,
+                             self.prev_tactics,
+                             self.obligations.focused_hyps,
+                             self.obligations.focused_goal)
+
+
+def truncate_tactic_context(context: TacticContext,
+                            max_term_length: int):
+    def truncate_hyp(hyp: str) -> str:
+        var_term = hyp.split(":")[0].strip()
+        hyp_type = hyp.split(":", 1)[1].strip()
+        return f"{var_term} : {hyp_type}"
+    return TacticContext(
+        [truncate_hyp(lemma) for lemma
+         in context.relevant_lemmas],
+        context.prev_tactics,
+        [truncate_hyp(hyp) for hyp
+         in context.hypotheses],
+        context.goal[:max_term_length])
+
+
+ScrapedCommand = Union[ScrapedTactic, str]
+
+
+def strip_scraped_output(scraped: ScrapedTactic) -> TacticContext:
+    relevant_lemmas, prev_tactics, context, tactic = scraped
+    if context and context.fg_goals:
+        return TacticContext(relevant_lemmas, prev_tactics,
+                             context.fg_goals[0].hypotheses,
+                             context.fg_goals[0].goal)
+    else:
+        return TacticContext(relevant_lemmas, prev_tactics,
+                             [], "")
+
+
+def read_tuple(f_handle: TextIO) -> Optional[ScrapedCommand]:
+    line = f_handle.readline()
+    if line.strip() == "":
+        return None
+    obj = json.loads(line)
+    if isinstance(obj, str):
+        return obj
+    else:
+        return ScrapedTactic(obj["relevant_lemmas"],
+                             obj["prev_tactics"],
+                             ProofContext.from_dict(obj["context"]),
+                             obj["tactic"])
+
+
+def read_tactic_tuple(f_handle: TextIO) -> Optional[ScrapedTactic]:
+    next_tuple = read_tuple(f_handle)
+    while(isinstance(next_tuple, str)):
+        next_tuple = read_tuple(f_handle)
+    return next_tuple