ó
ù`]c           @  sš  d  Z  d d l m Z d d l Z d d l Z d d l Z d d l m Z m Z m	 Z	 m
 Z
 m Z m Z m Z m Z m Z d d l m Z m Z i	 e d 6d d 6e d	 6d
 d 6d d 6d d 6d d 6d d 6d d 6Z d e f d „  ƒ  YZ d e e f d „  ƒ  YZ d e f d „  ƒ  YZ d „  Z d „  Z d e e f d „  ƒ  YZ d  e f d! „  ƒ  YZ d" e f d# „  ƒ  YZ d$ e f d% „  ƒ  YZ  d& „  Z! d' „  Z" d( „  Z# d) g  f d* g  f d+ g  f d, g  f d- g  f d* g  f d+ g  f d- g  f d. g  f d/ g  f d0 d1 d2 g f d3 g  f d4 g  f d5 g  f d6 d7 g f d8 d7 g f g Z$ d9 d: d; d< d= d> d? d@ dA dB dC g Z% dD dE „ Z& dF „  Z' e( dG k r–e' ƒ  n  d S(H   sD   
A theorem prover that makes use of the external 'Prover9' package.
iÿÿÿÿ(   t   print_functionN(	   t
   Expressiont   ExistsExpressiont   AllExpressiont   NegatedExpressiont   AndExpressiont   IffExpressiont   OrExpressiont   EqualityExpressiont   ImpExpression(   t   BaseProverCommandt   Proveri    s   (FATAL)i   i   s
   (MAX_MEGS)i   s   (MAX_SECONDS)i   s   (MAX_GIVEN)i   s
   (MAX_KEPT)i   s   (ACTION)i   s	   (SIGSEGV)ie   t   Prover9CommandParentc           B  s   e  Z d  Z d d „ Z RS(   sÔ   
    A common base class used by both ``Prover9Command`` and ``MaceCommand``,
    which is responsible for maintaining a goal and a set of assumptions,
    and generating prover9-style input files from them.
    t   nltkc         C  s†   | j  ƒ  d k r6 xm |  j ƒ  D] } t | ƒ q WnL | j  ƒ  d k rr x7 t |  j ƒ  ƒ D] } t | ƒ q[ Wn t d | ƒ ‚ d S(   s<   
        Print the list of the current assumptions.
        R   t   prover9s*   Unrecognized value for 'output_format': %sN(   t   lowert   assumptionst   printt   convert_to_prover9t	   NameError(   t   selft   output_formatt   a(    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   print_assumptions7   s    (   t   __name__t
   __module__t   __doc__R   (    (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyR   0   s   t   Prover9Commandc           B  s/   e  Z d  Z d d d d d „ Z e d „ Z RS(   sº   
    A ``ProverCommand`` specific to the ``Prover9`` prover.  It contains
    the a print_assumptions() method that is used to print the list
    of assumptions in multiple formats.
    i<   c         C  sY   | s g  } n  | d k	 r3 t | t ƒ s? t ‚ n t | ƒ } t j |  | | | ƒ d S(   sÄ  
        :param goal: Input expression to prove
        :type goal: sem.Expression
        :param assumptions: Input expressions to use as assumptions in
            the proof.
        :type assumptions: list(sem.Expression)
        :param timeout: number of seconds before timeout; set to 0 for
            no timeout.
        :type timeout: int
        :param prover: a prover.  If not set, one will be created.
        :type prover: Prover9
        N(   t   Nonet
   isinstancet   Prover9t   AssertionErrorR
   t   __init__(   R   t   goalR   t   timeoutt   prover(    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyR    N   s    	c         C  s4   | r& |  j  j | d g ƒ d j ƒ  S| j ƒ  Sd S(   s9   
        :see BaseProverCommand.decorate_proof()
        t   striplabelsi    N(   t   _provert   _call_prooftranst   rstrip(   R   t   proof_stringt   simplify(    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   decorate_proofe   s    N(   R   R   R   R   R    t   TrueR*   (    (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyR   G   s   t   Prover9Parentc           B  sM   e  Z d  Z d Z e d „ Z d „  Z d „  Z e d „ Z	 g  e d „ Z
 RS(   sÀ   
    A common class extended by both ``Prover9`` and ``Mace <mace.Mace>``.
    It contains the functionality required to convert NLTK-style
    expressions into Prover9-style expressions.
    c         C  s‰   | d  k r! d  |  _ d  |  _ nd d } t j j | d | d d g d d d | | d g d	 | ƒ|  _ |  j j t j j	 d
 ƒ |  _ d  S(   NR   t   path_to_bint   env_varst   PROVER9t   urls&   http://www.cs.unm.edu/~mccune/prover9/t   binary_namess   .exet   verbosei   (
   R   t   _binary_locationt   _prover9_binR   t	   internalst   find_binaryt   rsplitt   ost   patht   sep(   R   t   binary_locationR2   t   name(    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   config_prover9z   s    			c         C  s}   d } | rH | d 7} x" t  | ƒ D] } | d | 7} q# W| d 7} n  | ry | d 7} | d t  | ƒ 7} | d 7} n  | S(   sÃ   
        :return: The input string that should be provided to the
        prover9 binary.  This string is formed based on the goal,
        assumptions, and timeout value of this object.
        t    s   formulas(assumptions).
s       %s.
s   end_of_list.

s   formulas(goals).
(   R   (   R   R!   R   t   st   p9_assumption(    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   prover9_inputŠ   s    

c         C  s   d d d d d d g S(   sÁ   
        A list of directories that should be searched for the prover9
        executables.  This list is used by ``config_prover9`` when searching
        for the prover9 executables.
        s   /usr/local/bin/prover9s   /usr/local/bin/prover9/bins   /usr/local/bins   /usr/bins   /usr/local/prover9s   /usr/local/share/prover9(    (   R   (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   binary_locationsŸ   s    c         C  si   |  j  ƒ  } |  j d  k	 r. | |  j g 7} n  t j j | d | d d g d d d | | d g d | ƒS(	   Nt
   searchpathR.   R/   R0   s&   http://www.cs.unm.edu/~mccune/prover9/R1   s   .exeR2   (   RB   R3   R   R   R5   R6   (   R   R<   R2   RB   (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   _find_binary®   s    		c   	      C  s
  | r3 t  d | ƒ t  d | ƒ t  d | d ƒ n  | g | } y | j d ƒ } Wn t k
 rf n Xt j | d t j d t j d t j ƒ} | j d	 | ƒ \ } } | rô t  d
 | j ƒ | rØ t  d | d ƒ n  | rô t  d | d ƒ qô n  | j	 d ƒ | j f S(   s=  
        Call the binary with the given input.

        :param input_str: A string whose contents are used as stdin.
        :param binary: The location of the binary to call
        :param args: A list of command-line arguments.
        :return: A tuple (stdout, returncode)
        :see: ``config_prover9``
        s   Calling:s   Args:s   Input:
s   
t   utf8t   stdoutt   stderrt   stdint   inputs   Return code:s   stdout:
s   stderr:
s   utf-8(
   R   t   encodet   AttributeErrort
   subprocesst   Popent   PIPEt   STDOUTt   communicatet
   returncodet   decode(	   R   t	   input_strt   binaryt   argsR2   t   cmdt   pRF   RG   (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   _call»   s&    
$N(   R   R   R   R   R3   t   FalseR=   RA   RB   RD   RX   (    (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyR,   q   s   		c         C  s•   t  |  t ƒ rb g  } xF |  D]> } y | j t | j ƒ  ƒ ƒ Wq t d |  ƒ ‚  q Xq W| Sy t |  j ƒ  ƒ SWn t d |  ƒ ‚  n Xd S(   s;   
    Convert a ``logic.Expression`` to Prover9 format.
    s4   input %s cannot be converted to Prover9 input syntaxN(   R   t   listt   appendt   _convert_to_prover9R)   R   (   RI   t   resultR?   (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyR   ß   s    c         C  s  t  |  t ƒ r1 d t |  j ƒ d t |  j ƒ St  |  t ƒ rb d t |  j ƒ d t |  j ƒ St  |  t ƒ r† d t |  j ƒ d St  |  t ƒ r» d t |  j	 ƒ d t |  j
 ƒ d St  |  t ƒ rð d t |  j	 ƒ d t |  j
 ƒ d St  |  t ƒ r%d t |  j	 ƒ d	 t |  j
 ƒ d St  |  t ƒ rZd t |  j	 ƒ d
 t |  j
 ƒ d St  |  t ƒ rd t |  j	 ƒ d t |  j
 ƒ d St |  ƒ Sd S(   sC   
    Convert ``logic.Expression`` to Prover9 formatted string.
    s   exists t    s   all s   -(t   )t   (s    & s    | s    -> s    <-> s    = N(   R   R   t   strt   variableR\   t   termR   R   R   t   firstt   secondR   R	   R   R   (   t
   expression(    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyR\   ô   s"    ""&&&&&R   c           B  sY   e  Z d Z d Z d  d „ Z d d e d „ Z d „  Z g  e d „ Z	 g  e d „ Z
 RS(   i<   c         C  s   | |  _  d  S(   N(   t   _timeout(   R   R"   (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyR    8  s    	c         C  sF   | s g  } n  |  j  |  j | | ƒ d | ƒ\ } } | d k | f S(   sñ   
        Use Prover9 to prove a theorem.
        :return: A pair whose first element is a boolean indicating if the
        proof was successful (i.e. returns value of 0) and whose second element
        is the output of the prover.
        R2   i    (   t   _call_prover9RA   (   R   R!   R   R2   RF   RQ   (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   _prove>  s
    	!c         C  s   d } | t  j |  | | ƒ S(   s3   
        :see: Prover9Parent.prover9_input
        s   clear(auto_denials).
(   R,   RA   (   R   R!   R   R?   (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyRA   M  s    c   
      C  sû   |  j  d k r' |  j d | ƒ |  _  n  d } |  j d k rP | d |  j 7} n  | | 7} |  j | |  j  | | ƒ \ } } | d k rñ d } | | k r» | j | ƒ } | | j ƒ  }	 n d }	 | d k rß t | |	 ƒ ‚ qñ t | |	 ƒ ‚ n  | | f S(   s  
        Call the ``prover9`` binary with the given input.

        :param input_str: A string whose contents are used as stdin.
        :param args: A list of command-line arguments.
        :return: A tuple (stdout, returncode)
        :see: ``config_prover9``
        R   R>   i    s   assign(max_seconds, %d).

i   s   %%ERROR:i   i   i   i   N(   i    i   (   i   i   i   i   (	   R4   R   RD   Rg   RX   t   indext   stript   Prover9LimitExceededExceptiont   Prover9FatalException(
   R   RS   RU   R2   t   updated_input_strRF   RQ   t   errormsgprefixt   msgstartt   errormsg(    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyRh   T  s$    	
c         C  s@   |  j  d k r' |  j d | ƒ |  _  n  |  j | |  j  | | ƒ S(   s  
        Call the ``prooftrans`` binary with the given input.

        :param input_str: A string whose contents are used as stdin.
        :param args: A list of command-line arguments.
        :return: A tuple (stdout, returncode)
        :see: ``config_prover9``
        t
   prooftransN(   t   _prooftrans_binR   RD   RX   (   R   RS   RU   R2   (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyR&   w  s    	N(   R   R   R   R4   Rs   R    RY   Ri   RA   Rh   R&   (    (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyR   4  s   	#t   Prover9Exceptionc           B  s   e  Z d  „  Z RS(   c         C  s5   t  | } | r! | d | 7} n  t j |  | ƒ d  S(   Ns   
%s(   t   p9_return_codest	   ExceptionR    (   R   RQ   t   messaget   msg(    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyR    ‡  s    
(   R   R   R    (    (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyRt   †  s   Rm   c           B  s   e  Z RS(    (   R   R   (    (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyRm   Ž  s   Rl   c           B  s   e  Z RS(    (   R   R   (    (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyRl   ’  s   c          C  ss   t  j d ƒ }  t  j d ƒ } t | d |  g ƒ} d  | _ g  | _ | j ƒ  t | j ƒ  ƒ t | j ƒ  ƒ d  S(   Ns   (walk(j) & sing(j))s   walk(j)R   (	   R   t
   fromstringR   R   t   _executable_patht   prover9_searcht   proveR   t   proof(   R   t   gRW   (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   test_config›  s    		
c         C  s4   x- |  D]% } t  j | ƒ } t t | ƒ ƒ q Wd S(   s%   
    Test that parsing works OK.
    N(   R   Ry   R   R   (   t   exprt   tt   e(    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   test_convert_to_prover9¨  s    c         C  s—   x |  D]ˆ \ } } t  j | ƒ } g  | D] } t  j | ƒ ^ q) } t | d | ƒj ƒ  } x | D] } t d | ƒ qc Wt d | | f ƒ q Wd S(   s2   
    Try some proofs and exhibit the results.
    R   s      %ss
   |- %s: %s
N(   R   Ry   R   R|   R   (   t	   argumentsR!   R   R~   R   t   alistRW   (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt
   test_prove±  s    "s   (man(x) <-> (not (not man(x))))s   (not (man(x) & (not man(x))))s   (man(x) | (not man(x)))s   (man(x) & (not man(x)))s   (man(x) -> man(x))s   (man(x) <-> man(x))s   (not (man(x) <-> (not man(x))))s   mortal(Socrates)s   all x.(man(x) -> mortal(x))s   man(Socrates)sA   ((all x.(man(x) -> walks(x)) & man(Socrates)) -> some y.walks(y))s   (all x.man(x) -> all x.man(x))s   some x.all y.sees(x,y)s#   some e3.(walk(e3) & subj(e3, mary))sW   some e1.(see(e1) & subj(e1, john) & some e2.(pred(e1, e2) & walk(e2) & subj(e2, mary)))sV   some x e1.(see(e1) & subj(e1, x) & some e2.(pred(e1, e2) & walk(e2) & subj(e2, mary)))s   some x y.sees(x,y)s   some x.(man(x) & walks(x))s   \x.(man(x) & walks(x))s   \x y.sees(x,y)s   walks(john)s   \x.big(x, \y.mouse(y))s/   (walks(x) & (runs(x) & (threes(x) & fours(x))))s   (walks(x) -> runs(x))s   some x.(PRO(x) & sees(John, x))s    some x.(man(x) & (not walks(x)))s   all x.(man(x) -> walks(x))i-   c         C  s   t  d |  ƒ d  S(   Nt   -(   R   (   t   num(    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   spacerê  s    c           C  s`   t  d ƒ t ƒ  t ƒ  t  ƒ  t  d ƒ t ƒ  t t ƒ t  ƒ  t  d ƒ t ƒ  t t ƒ d  S(   Ns   Testing configurations$   Testing conversion to Prover9 formats   Testing proofs(   R   R‰   R   Rƒ   t   expressionsR†   R„   (    (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   demoî  s    



t   __main__()   R   t
   __future__R    R8   RL   R   t   nltk.sem.logicR   R   R   R   R   R   R   R   R	   t   nltk.inference.apiR
   R   R+   RY   Ru   t   objectR   R   R,   R   R\   R   Rv   Rt   Rm   Rl   R   Rƒ   R†   R„   RŠ   R‰   R‹   R   (    (    (    s5   lib/python2.7/site-packages/nltk/inference/prover9.pyt   <module>   sz   @
*n		@R																					