
    gfc                        d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ  G d de      Z G d d	e      Zd
 Zd Zd Zd Z  G d de!      Z" ejF                  d      Z$ ejF                  d      Z% ejF                  dejL                        Z'd Z(d"dZ) G d de!      Z* G d d      Z+dZ,d"dZ-d#dZ.d"dZ/d"dZ0d$dZ1e2dk(  r e1d d!       yy)%zK
This module provides data structures for representing first-order
models.
    Npformat)	decorator)AbstractVariableExpressionAllExpressionAndExpressionApplicationExpressionEqualityExpressionExistsExpression
ExpressionIffExpressionImpExpressionIndividualVariableExpressionIotaExpressionLambdaExpressionNegatedExpressionOrExpressionVariable	is_indvarc                       e Zd Zy)ErrorN__name__
__module____qualname__     F/var/www/openai/venv/lib/python3.12/site-packages/nltk/sem/evaluate.pyr   r   ,       r   r   c                       e Zd Zy)	UndefinedNr   r   r   r   r!   r!   0   r   r   r!   c                     t        j                  |       }t        t        |d   |            }|j	                  dd       r-t                |j                         D ]  }t        d|z           | |i |S )Nr   tracez%s => %s)inspectgetfullargspecdictzippopprintitems)fargskwargspecditems         r   r#   r#   4   se    $$Q'GST"#AuuWdGGID*t#$ d>b>r   c                     t        |       dk(  ryt        d | D              r*t        t        |             t        t        |             k(  ryt	        d| z        )z
    Check whether a set represents a relation (of any arity).

    :param s: a set containing tuples of str elements
    :type s: set
    :rtype: bool
    r   Tc              3   <   K   | ]  }t        |t                y wN)
isinstancetuple).0els     r   	<genexpr>zis_rel.<locals>.<genexpr>J   s     /QrZE"Qs   z.Set %r contains sequences of different lengths)lenallmaxmin
ValueError)ss    r   is_relr?   >   sK     1v{	/Q/	/CAK3s1v;4NIAMNNr   c                     t               }| D ]a  }t        |t              r|j                  |f       &t        |t              r|j                  t        |             Q|j                  |       c |S )aR  
    Convert a set containing individuals (strings or numbers) into a set of
    unary tuples. Any tuples of strings already in the set are passed through
    unchanged.

    For example:
      - set(['a', 'b']) => set([('a',), ('b',)])
      - set([3, 27]) => set([('3',), ('27',)])

    :type s: set
    :rtype: set of tuple of str
    )setr4   straddint)r>   newelems      r   set2relrG   P   sY     %CdC GGTGc"GGCIGGDM  Jr   c                 N    t        |       dk(  ryt        t        |       d         S )ze
    Check the arity of a relation.
    :type rel: set of tuples
    :rtype: int of tuple of str
    r   )r9   list)rels    r   arityrK   h   s%     3x1}tCy|r   c                   ^     e Zd ZdZ fdZd Zd Zed        Zed        Z	e
d        Z xZS )	Valuationa  
    A dictionary which represents a model-theoretic Valuation of non-logical constants.
    Keys are strings representing the constants to be interpreted, and values correspond
    to individuals (represented as strings) and n-ary relations (represented as sets of tuples
    of strings).

    An instance of ``Valuation`` will raise a KeyError exception (i.e.,
    just behave like a standard  dictionary) if indexed with an expression that
    is not in its list of symbols.
    c                    t         |           |D ]q  \  }}t        |t              st        |t              r|| |<   ,t        |t
              rt        |      | |<   Kt        j                  d|d|d      }t        |       y)z=
        :param xs: a list of (symbol, value) pairs.
        z@Error in initializing Valuation. Unrecognized value for symbol 'z':
B   )widthN)
super__init__r4   rB   boolrA   rG   textwrapfillr=   )selfxssymvalmsg	__class__s        r   rR   zValuation.__init__   sy     	HC#s#z#t'<S	C%#CLS	mmADcK !o% r   c                 R    || v rt         j                  | |      S t        d|z        )NzUnknown expression: '%s'r&   __getitem__r!   rV   keys     r   r^   zValuation.__getitem__   s-    $;##D#..6<==r   c                     t        |       S r3   r   rV   s    r   __str__zValuation.__str__   s    t}r   c           	         g }| j                         D ]`  }t        |t              r|j                  |       %t        |t              r6|j                  |D cg c]  }|D ]  }||	  c}}       b t        |      S c c}}w )z7Set-theoretic domain of the value-space of a Valuation.)valuesr4   rB   appendrS   extendrA   )rV   domrY   tuple_rF   s        r   domainzValuation.domain   st     ;;=C#s#

3T*

(+Sf$BRTTS	 ! 3x Ts   B&Bc                 4    t        | j                               S )z9The non-logical constants which the Valuation recognizes.)sortedkeysrb   s    r   symbolszValuation.symbols   s     diik""r   c                     t        |      S r3   )read_valuation)clsr>   s     r   
fromstringzValuation.fromstring   s    a  r   )r   r   r   __doc__rR   r^   rc   propertyrj   rn   classmethodrr   __classcell__r[   s   @r   rM   rM   s   sS    	&&> 
 
 # # ! !r   rM   z	\s*=+>\s*z\s*,\s*zg\s*
                                (\([^)]+\))  # tuple-expression
                                \s*c                 ^   t         j                  |       }|d   }|d   }|j                  d      rz|dd }t        j	                  |      }|r>g }|D ]6  }|dd }t        t        j                  |            }|j                  |       8 nt        j                  |      }t        |      }||fS )a  
    Read a line in a valuation file.

    Lines are expected to be of the form::

      noosa => n
      girl => {g1, g2}
      chase => {(b1, g1), (b2, g1), (g1, d1), (g2, d2)}

    :param s: input line
    :type s: str
    :return: a pair (symbol, value)
    :rtype: tuple
    r      {)	_VAL_SPLIT_REsplit
startswith
_TUPLES_REfindallr5   _ELEMENT_SPLIT_RErf   rA   )r>   piecessymbolvaluetuple_stringsset_elementstselements           r   _read_valuation_liner      s       #FAYF1IEa"**51L#"X 1 7 7 ;<##G, $
 -2259LL!5=r   c                 N   || j                  |      } g }t        | j                               D ]G  \  }}|j                         }|j	                  d      s|dk(  r-	 |j                  t        |             I t        |      S # t        $ r}t        d| d|       |d}~ww xY w)a  
    Convert a valuation string into a valuation.

    :param s: a valuation string
    :type s: str
    :param encoding: the encoding of the input string, if it is binary
    :type encoding: str
    :return: a ``nltk.sem`` valuation
    :rtype: Valuation
    N# zUnable to parse line z: )	decode	enumerate
splitlinesstripr~   rf   r   r=   rM   )r>   encoding
statementslinenumlinees         r   rp   rp      s     HHXJ"1<<>2zz|??342:	O2489 3 Z    	O4WIRvFGQN	Os   B	B$BB$c                   J     e Zd ZdZd	 fd	Zd Zd Zd	dZd Zd Z	d Z
 xZS )

Assignmentae  
    A dictionary which represents an assignment of values to variables.

    An assignment can only assign values from its domain.

    If an unknown expression *a* is passed to a model *M*\ 's
    interpretation function *i*, *i* will first check whether *M*\ 's
    valuation assigns an interpretation to *a* as a constant, and if
    this fails, *i* will delegate the interpretation of *a* to
    *g*. *g* only assigns values to individual variables (i.e.,
    members of the class ``IndividualVariableExpression`` in the ``logic``
    module. If a variable is not assigned a value by *g*, it will raise
    an ``Undefined`` exception.

    A variable *Assignment* is a mapping from individual variables to
    entities in the domain. Individual variables are usually indicated
    with the letters ``'x'``, ``'y'``, ``'w'`` and ``'z'``, optionally
    followed by an integer (e.g., ``'x0'``, ``'y332'``).  Assignments are
    created using the ``Assignment`` constructor, which also takes the
    domain as a parameter.

        >>> from nltk.sem.evaluate import Assignment
        >>> dom = set(['u1', 'u2', 'u3', 'u4'])
        >>> g3 = Assignment(dom, [('x', 'u1'), ('y', 'u2')])
        >>> g3 == {'x': 'u1', 'y': 'u2'}
        True

    There is also a ``print`` format for assignments which uses a notation
    closer to that in logic textbooks:

        >>> print(g3)
        g[u1/x][u2/y]

    It is also possible to update an assignment using the ``add`` method:

        >>> dom = set(['u1', 'u2', 'u3', 'u4'])
        >>> g4 = Assignment(dom)
        >>> g4.add('x', 'u1')
        {'x': 'u1'}

    With no arguments, ``purge()`` is equivalent to ``clear()`` on a dictionary:

        >>> g4.purge()
        >>> g4
        {}

    :param domain: the domain of discourse
    :type domain: set
    :param assign: a list of (varname, value) associations
    :type assign: list
    c                    t         |           || _        |rS|D ]N  \  }}|| j                  v s!J dj                  || j                               t	        |      s
J d|z         || |<   P d | _        | j                          y )Nz'{}' is not in the domain: {}-Wrong format for an Individual Variable: '%s')rQ   rR   rj   formatr   variant_addvariant)rV   rj   assignvarrY   r[   s        r   rR   zAssignment.__init__0  s    "Sdkk) +J+Q+QKK, ) !~ CcI~  S	 # r   c                 R    || v rt         j                  | |      S t        d|z        )Nz"Not recognized as a variable: '%s'r]   r_   s     r   r^   zAssignment.__getitem__@  s-    $;##D#..@3FGGr   c                 R    t        | j                        }|j                  |        |S r3   )r   rj   update)rV   rE   s     r   copyzAssignment.copyF  s!    %

4
r   c                 P    |r| |= n| j                          | j                          y)z
        Remove one or all keys (i.e. logic variables) from an
        assignment, and update ``self.variant``.

        :param var: a Variable acting as a key for the assignment.
        N)clearr   )rV   r   s     r   purgezAssignment.purgeK  s&     S	JJLr   c                 `    d}t        | j                        }|D ]  \  }}|d| d| dz  } |S )zQ
        Pretty printing for assignments. {'x', 'u'} appears as 'g[u/x]'
        g[/])rl   r   )rV   gstringr   rY   r   s        r   rc   zAssignment.__str__Y  sC     &HC3%qQ''G  r   c                 v    g }| j                         D ]  }|d   |d   f}|j                  |        || _        y)zK
        Create a more pretty-printable version of the assignment.
        ry   r   N)r*   rf   r   )rV   list_r0   pairs       r   r   zAssignment._addvariantd  sC     JJLDGT!W%DLL ! r   c                     || j                   v sJ | d| j                           t        |      s
J d|z         || |<   | j                          | S )zh
        Add a new variable-value pair to the assignment, and update
        ``self.variant``.

        z is not in the domain r   )rj   r   r   )rV   r   rY   s      r   rC   zAssignment.addo  s]     dkk!NcU*@#NN!~TNQTTT~S	r   r3   )r   r   r   rs   rR   r^   r   r   rc   r   rC   rv   rw   s   @r   r   r      s-    2h H
		
r   r   c                   B    e Zd ZdZd Zd Zd Zd
dZd
dZddZ	dd	Z
y)Modela[  
    A first order model is a domain *D* of discourse and a valuation *V*.

    A domain *D* is a set, and a valuation *V* is a map that associates
    expressions with values in the model.
    The domain of *V* should be a subset of *D*.

    Construct a new ``Model``.

    :type domain: set
    :param domain: A set of entities representing the domain of discourse of the model.
    :type valuation: Valuation
    :param valuation: the valuation of the model.
    :param prop: If this is set, then we are building a propositional    model and don't require the domain of *V* to be subset of *D*.
    c                     t        |t              sJ || _        || _        |j	                  |j                        st        d|j                  d|      y )NzThe valuation domain, z*, must be a subset of the model's domain, )r4   rA   rj   	valuation
issupersetr   )rV   rj   r   s      r   rR   zModel.__init__  sV    &#&&&"  !1!12##V-  3r   c                 <    d| j                   d| j                  dS )N(z, )rj   r   rb   s    r   __repr__zModel.__repr__  s     4;;/DNN#5Q77r   c                 :    d| j                    d| j                   S )Nz	Domain = z,
Valuation = 
r   rb   s    r   rc   zModel.__str__  s    4;;-'88HIIr   Nc                     	 t        j                  |      }| j                  |||      }|rt                t        d| d| d|        |S # t        $ r  |rt                t        d| d|        Y yw xY w)aA  
        Read input expressions, and provide a handler for ``satisfy``
        that blocks further propagation of the ``Undefined`` error.
        :param expr: An ``Expression`` of ``logic``.
        :type g: Assignment
        :param g: an assignment to individual variables.
        :rtype: bool or 'Undefined'
        r#   'z' evaluates to z
 under M, z' is undefined under M, r!   )r   rr   satisfyr)   r!   )rV   exprr   r#   parsedr   s         r   evaluatezModel.evaluate  s    	**40FLL%L8E$ugZsCDL 	$7s;<		s   A
A &A65A6c                 :    t        |t              r|j                         \  }}t        |t              r+ j	                  |      }t         fd|D              }||v S  j	                  |j                        } j	                  |j                        }||   S t        |t              r j	                  |j                         S t        |t              r: j	                  |j                        xr  j	                  |j                        S t        |t              r: j	                  |j                        xs  j	                  |j                        S t        |t              r; j	                  |j                         xs  j	                  |j                        S t        |t              r9 j	                  |j                         j	                  |j                        k(  S t        |t               r9 j	                  |j                         j	                  |j                        k(  S t        |t"              rfj%                         }	 j&                  D ]F  }
|	j)                  |j*                  j,                  |
        j	                  |j                  |	      rF y yt        |t.              rfj%                         }	 j&                  D ]F  }
|	j)                  |j*                  j,                  |
        j	                  |j                  |	      sF y yt        |t0              rfj%                         }	 j&                  D ]F  }
|	j)                  |j*                  j,                  |
        j	                  |j                  |	      sF y yt        |t2              r\i }|j*                  j,                  } j&                  D ]3  }
 j	                  |j                  j)                  ||
            }|||
<   5 |S  j5                  ||      S )a  
        Recursive interpretation function for a formula of first-order logic.

        Raises an ``Undefined`` error when ``parsed`` is an atomic string
        but is not a symbol or an individual variable.

        :return: Returns a truth value or ``Undefined`` if ``parsed`` is        complex, and calls the interpretation function ``i`` if ``parsed``        is atomic.

        :param parsed: An expression of ``logic``.
        :type g: Assignment
        :param g: an assignment to individual variables.
        c              3   B   K   | ]  }j                  |        y wr3   )r   )r6   argr   rV   s     r   r8   z Model.satisfy.<locals>.<genexpr>  s     J	S! 4	s   FT)r4   r	   uncurryr   r   r5   functionargumentr   termr   firstsecondr   r   r   r
   r   r   rj   rC   variablenamer   r   r   i)rV   r   r   r#   r   	argumentsfunvalargvalsargvalnew_gucfr   rY   s   ` `           r   r   zModel.satisfy  s&     f34"(.."2Hi($>?h2J	JJ&(( fooq9fooq9f~% 12||FKK333.<<a0ST\\&--QR5SS-<<a0RDLLPQ4RR.V\\155X$,,v}}VW:XX.<<a0DLLPQ4RRR 23<<a0DLLPQ4RRR.FFHE[[		&//..2||FKK7  !  01FFHE[[		&//..2<<U3 ! /FFHE[[		&//..2<<U3 !  01B//&&C[[ll6;;c1>
 1 ! I66&!U++r   c                    |j                   j                  | j                  j                  v r#| j                  |j                   j                     S t	        |t
              r||j                   j                     S t        d|z        )a  
        An interpretation function.

        Assuming that ``parsed`` is atomic:

        - if ``parsed`` is a non-logical constant, calls the valuation *V*
        - else if ``parsed`` is an individual variable, calls assignment *g*
        - else returns ``Undefined``.

        :param parsed: an ``Expression`` of ``logic``.
        :type g: Assignment
        :param g: an assignment to individual variables.
        :return: a semantic value
        zCan't find a value for %s)r   r   r   rn   r4   r   r!   )rV   r   r   r#   s       r   r   zModel.i   sl    $ ??4>>#9#99>>&//"6"677 <=V__))** 7&@AAr   c           
         d}|||z  z   }g }t        |t              rt        |      }	n|}	|	|j                         v r|r!t	                t	        ||z  d| d| z          | j
                  D ]  }
|j                         }|j                  |	j                  |
       |r|dkD  r|dz
  }nd}| j                  |||      }|rt	        |d|z  z          |dk(  r|slt	        |d| d	| d
z          |j                  |
       |st	        |d| d	| d| z           |D ch c]  }| }}|S t        |	j                   d|       c c}w )a  
        Generate the entities from the model's domain that satisfy an open formula.

        :param parsed: an open formula
        :type parsed: Expression
        :param varex: the relevant free individual variable in ``parsed``.
        :type varex: VariableExpression or str
        :param g: a variable assignment
        :type g:  Assignment
        :return: a set of the entities that satisfy ``parsed``.
        z   zOpen formula is 'z' with assignment ry   r   z(trying assignment %s)Fz
value of 'z' under z	 is Falsez is z is not free in )r4   rB   r   freer)   rj   r   rC   r   r   rf   r!   )rV   r   varexr   r#   nestingspacerindent
candidatesr   r   r   lowtracer   cresults                   r   
satisfierszModel.satisfiers  sx    6G+,
eS!5/CC&++-g%)&1CA3GH [[		#((A&UQY$qyH HVUH=&#;e#CCD E>fF88E7)'TTU %%a(fF88E7$ug'VVW+ !. ",,AaF,
  sxxj(8ABB -s   	Er3   )F)Nr   )r   r   r   rs   rR   r   rc   r   r   r   r   r   r   r   r   r   |  s.    "8J,I,XB49r   r      c           
         t        g d      at               at	        t        t              at        t              at                t        dt        z         t        d       t        dt        z         t        d       t                t        dt
               t        dt        z         g d}|D ]S  }| r&t                t
        j                  |t        |        +t        d| dt
        j                  |t                      U y	)
z!Example of a propositional model.))PT)QT)RF*zPropositional Formulas Demoz7(Propositional constants treated as nullary predicates)z
Model m1:
)z(P & Q)z(P & R)z- Pz- Rz- - Pz	- (P & R)z(P | R)z(R | P)z(R | R)z	(- P | R)z	(P | - P)z(P -> Q)z(P -> R)z(R -> P)z	(P <-> P)z	(R <-> R)z	(P <-> R)The value of '' is: N)rM   val1rA   dom1r   m1r   g1r)   multr   )r#   	sentencessents      r   propdemor   _  s     =>D5D	tT	B	D	B	G	#*	
'(	#*	
CD	G	-	#*I( GKKb%(N4&r{{4/D.EFG r   c           
         ddddddhfddd	hfd
dhfdh dfga t        t               at        j                  at        t        t              at        t        ddg      a| s t                t        dt        z         t        d       t        dt        z         t        dddt               t        dt               g d}|D cg c]  }t        j                  |       }}t                |D ],  }	 t        d|dt        j                  |t                     . g d}|D ]Z  \  }}	 t        j                  t        j                  |      t              }	t        d |D              }
t        | d| d|
|	v         \ yyc c}w # t        $ r t        d|z         Y w xY w# t        $ r t        | d| d       Y w xY w) zExample of a first-order model.)adamb1)bettyr   )fidod1girlr   g2boyr   b2dogr   love>   r   r   r   r   r   r   r   r   )xr   )yr   r   zModels Demoz
Model m2:
z--------------
zVariable assignment = )r   r   r   walksr  r  zzThe interpretation of 'z' in m2 is z-The interpretation of '%s' in m2 is Undefined))r   r   )r  )r   )r   )r   r  )r   )r  r   c              3   v   K   | ]1  }t         j                  t        j                  |      t               3 y wr3   )m2r   r   rr   r   )r6   r   s     r   r8   zfolmodel.<locals>.<genexpr>  s)     UPTZ%:%:3%? DPTs   79r   z) evaluates to z) evaluates to UndefinedN)v2rM   val2rj   dom2r   r  r   r   r)   r   r   rr   r   r!   r5   )quietr#   exprsr   parsed_exprsr   applicationsfunr,   r   argsvals              r   folmodelr    s    		$	t		IJ
B R=D;;D	tT	B	D;4	5BcDjmcDjmXtR0&+?:?@%Q
--a0%@"FPrttFB/1 #
 &IC?j33C8"=UPTUUQtfOGv4E3FGH	 &9  A  PENOP  ?Qtf$<=>?s+   F2)F*AF$F! F!$G Gc           
      Z   t        d       t                t        dt        z         t        d       t        dt        z         g d}|D ]]  }t        j	                          | rt
        j                  |t        |        5t        d| dt
        j                  |t                      _ y)	zF
    Interpretation of closed expressions in a first-order model.
    Tr  r   zFOL Formulas Demo)zlove (adam, betty)z(adam = mia)z\x. (boy(x) | girl(x))z\x. boy(x)(adam)z\x y. love(x, y)z\x y. love(x, y)(adam)(betty)z\x y. love(x, y)(adam, betty)z\x y. (boy(x) & love(x, y))z#\x. exists y. (boy(x) & love(x, y))zexists z1. boy(z1)z!exists x. (boy(x) &  -(x = adam))z&exists x. (boy(x) & all y. love(y, x))zall x. (boy(x) | girl(x))z1all x. (girl(x) -> exists y. boy(y) & love(x, y))z3exists x. (boy(x) & all y. (girl(y) -> love(y, x)))z3exists x. (boy(x) & all y. (girl(y) -> love(x, y)))zall x. (dog(x) -> - girl(x))z-exists x. exists y. (love(x, y) & love(x, y))r   r   N)r  r)   r   r   r   r  r   )r#   formulasfmlas      r   foldemor    s     4	G	#*	
	#*H* 

KKb%(N4&r{{4/D.EFG r   c                    t                t        dt        z         t        d       t        dt        z         t        d       g d}| rt        t               |D ]"  }t        |       t	        j
                  |       $ |D cg c]  }t	        j
                  |       }}|D ]K  }t        j                          t        dj                  |t        j                  |dt        |                    M yc c}w )	z5Satisfiers of an open formula in a first order model.r   zSatisfiers DemoTr  )zboy(x)z(x = x)z(boy(x) | girl(x))z(boy(x) & girl(x))zlove(adam, x)zlove(x, adam)z-(x = adam)zexists z22. love(x, z22)exists y. love(y, x)zall y. (girl(y) -> love(x, y))zall y. (girl(y) -> love(y, x))z)all y. (girl(y) -> (boy(x) & love(y, x)))z)(boy(x) & all y. (girl(y) -> love(x, y)))z)(boy(x) & all y. (girl(y) -> love(y, x)))z+(boy(x) & exists y. (girl(y) & love(y, x)))z(girl(x) -> dog(x))zall y. (dog(y) -> (x = y))r  z&exists y. (love(adam, y) & love(y, x))zThe satisfiers of '{}' are: {}r  N)
r)   r   r  r  r   rr   r   r   r   r   )r#   r  r  r   ps        r   satdemor    s     
G	#*	
	#*4H, b	dd#  7??hdj##D)hF?

,33Ar}}QRQV7WX	
  @s   C5c                     t         t        t        t        d}	  ||    |       y# t        $ r |D ]  }  ||    |        Y yw xY w)aO  
    Run exists demos.

     - num = 1: propositional logic demo
     - num = 2: first order model demo (only if trace is set)
     - num = 3: first order sentences demo
     - num = 4: satisfaction of open formulas demo
     - any other value: run all the demos

    :param trace: trace = 1, or trace = 2 for more verbose tracing
    )ry            r   N)r   r  r  r  KeyError)numr#   demoss      r   demor"  (  sL     X'g>E$c
 $CE#JU# $s   & AA__main__r  r   r3   )FN)r   N)3rs   r$   resysrT   pprintr   nltk.decoratorsr   nltk.sem.logicr   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   	Exceptionr   r!   r#   r?   rG   rK   r&   rM   compiler|   r   VERBOSEr   r   rp   r   r   r   r   r  r  r  r"  r   r   r   r   <module>r,     s  
  	 
   %    (	I 		 	O$0<! <!D 

<(BJJz* RZZ' JJ	
 F!2~ ~BW W| 

*Hb5?x%HX-
`$* z! r   