Ë
    çÍ:jac  ã                   óè  — 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/home/mcse/projects/srt_converter/srt-converter-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   sj   € Ü×$Ñ$ QÓ'€GÜŒS�˜‘˜TÓ"Ó#€AØ‡u�uˆW�dÔÜŒØ—G‘G“Iò 	%ˆDÜ�*˜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   è ø€ Ò/ rŒZ˜œE×"Ñ/ùs   ‚z.Set %r contains sequences of different lengths)ÚlenÚallÚmaxÚminÚ
ValueError)Úss    r   Úis_relr?   >   sK   € ô ˆ1ƒv�‚{Øä	Ñ/¨QÔ/Ô	/´C¼¸A»³KÄ3ÄsÈ1ÃvÃ;Ò4NØäÐIÈAÑ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   s^   € ô ‹%€CØò ˆÜ�dœCÔ Ø�G‰G�T�GÕÜ˜œcÔ"Ø�G‰G”C˜“IÕà�G‰G�D�Mðð €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%   € ô ˆ3ƒx�1‚}ØÜŒt�C‹y˜‰|ÓÐ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__   s~   ø€ ô 	‰ÑÔØò 	&‰HˆC�Ü˜#œsÔ#¤z°#´tÔ'<Ø��S’	Ü˜C¤Ô%Ü# C›L��S’	ä—m’mâADÁcð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›   sy   € ð ˆØ—;‘;“=ò 	ˆCÜ˜#œsÔ#Ø—
‘
˜3•Ü ¤TÕ*Ø—
‘
Ø(+×S˜f¸ÒS°À$ÑBR’TÐS�TÓSõð		ô �3‹xˆùó 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   € ô �d—i‘i“kÓ"Ð"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Ø�A‰Y€FØ�1‰I€Eà×Ñ˜ÔØ�a˜�ˆÜ"×*Ñ*¨5Ó1ˆáØˆLØ#ò -�Ø˜˜"�X�ÜÔ 1× 7Ñ 7¸Ó ;Ó<�Ø×#Ñ# GÕ,ñ-ô
 -×2Ñ2°5Ó9ˆLÜ�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³   € ð ÐØ�H‰H�XÓˆØ€JÜ" 1§<¡<£>Ó2ò O‰ˆ�Ø�z‰z‹|ˆØ�?‰?˜3Ô 4¨2¢:Øð	OØ×ÑÔ2°4Ó8Õ9ðOô �ZÓ Ð øô ò 	OÜÐ4°W°I¸RÀ¸vÐFÓGÈQÐ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Ø˜dŸk™kÑ)ð Ð+J×+QÑ+QØØ—K‘Kó,ó Ð)ô ! ”~ð ØCÀcÑ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‘	à�J‰JŒLØ×ÑÔØ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  sH   € ð ˆä˜Ÿ™Ó&ˆØò 	(‰HˆC�Ø˜˜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  sH   € ð ˆØ—J‘J“Lò 	ˆDØ˜‘G˜T !™WÐ%ˆDØ�L‰L˜Õð	ð ˆŒØ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]   € ð �d—k‘kÑ!ÐN c UÐ*@ÀÇÁÀÐ#NÓNÐ!Ü˜Œ~ÐTÐNÐQTÑ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—;‘;�/  D§N¡NÐ#5°QÐ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Ó0ˆFØ—L‘L ¨°%�LÓ8ˆEÙÜ”Ü˜˜$˜˜¨u¨g°ZÀ¸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ÑJù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ÑˆH�iÜ˜(Ô$>Ô?àŸ™ h°Ó2�ÜÔJÀ	ÔJÓJ�Ø &Ð(Ð(ð Ÿ™ f§o¡o°qÓ9�ØŸ™ f§o¡o°qÓ9�Ø˜f‘~Ð%Ü˜Ô 1Ô2Ø—|‘| F§K¡K°Ó3Ð3Ð3Ü˜¤Ô.Ø—<‘< §¡¨aÓ0ÒS°T·\±\À&Ç-Á-ÐQRÓ5SÐSÜ˜¤Ô-Ø—<‘< §¡¨aÓ0ÒR°D·L±LÀÇÁÐPQÓ4RÐRÜ˜¤Ô.ØŸ™ V§\¡\°1Ó5Ð5ÒX¸$¿,¹,ÀvÇ}Á}ÐVWÓ:XÐXÜ˜¤Ô.Ø—<‘< §¡¨aÓ0°D·L±LÀÇÁÐPQÓ4RÑRÐRÜ˜Ô 2Ô3Ø—<‘< §¡¨aÓ0°D·L±LÀÇÁÐPQÓ4RÑRÐRÜ˜¤Ô.Ø—F‘F“HˆEØ—[‘[ò !�Ø—	‘	˜&Ÿ/™/×.Ñ.°Ô2Ø—|‘| F§K¡K°Õ7Ù ð!ð Ü˜Ô 0Ô1Ø—F‘F“HˆEØ—[‘[ò  �Ø—	‘	˜&Ÿ/™/×.Ñ.°Ô2Ø—<‘< §¡¨UÕ3Ùð ð Ü˜¤Ô/Ø—F‘F“HˆEØ—[‘[ò  �Ø—	‘	˜&Ÿ/™/×.Ñ.°Ô2Ø—<‘< §¡¨UÕ3Ùð ð Ü˜Ô 0Ô1ØˆBØ—/‘/×&Ñ&ˆCØ—[‘[ò �Ø—l‘l 6§;¡;°·±°c¸1³Ó>�ð
 ��1’ðð ˆIà—6‘6˜& ! 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   «       |s|sŒit	        |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)z
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  sz  € ð ˆØ˜6 GÑ+Ñ,ˆØˆ
ä�eœSÔ!Ü˜5“/‰CàˆCà�&—+‘+“-ÑÙÜ”ÜØ˜gÑ%Ø)¨&¨Ð1CÀAÀ3ÐGñHôð —[‘[ò X�ØŸ™›�Ø—	‘	˜#Ÿ(™( AÔ&Ù˜U QšYØ$ q™y‘Hà �HØŸ™ V¨U°HÓ=�áÜ˜&Ð#;¸eÑ#CÑCÔDñ ÚÜ˜f¨°F°8¸8ÀEÀ7È)Ð'TÑTÕUð ×%Ñ% aÔ(ÚÜ˜f¨°F°8¸8ÀEÀ7È$ÈuÈgÐ'VÑVÕWð+Xð. ",Ö,˜A’aÐ,ˆFÐ,ð
 ˆô ˜sŸx™x˜jÐ(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Ü‹5€DÜ	Œt”TÓ	€BÜ	”DÓ	€Bä	„GÜ	ˆ#”‰*ÔÜ	Ð
'Ô(Ü	ˆ#”‰*ÔÜ	Ð
CÔDÜ	„GÜ	ˆ-œÔÜ	ˆ#”‰*Ôò€Ið( ò HˆÙÜŒGÜ�K‰K˜œb %Õ(ä�N 4 &¨¬r¯{©{¸4ÄÓ/DÐ.EÐFÕGñH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&   è ø€ ÒUÈ¤§¡¤Z×%:Ñ%:¸3Ó%?Ä× DÑUùs   ‚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Ü	Œt”TÓ	€BÜ	”D˜;¨Ð4Ó	5€BâÜŒÜˆc”D‰jÔÜˆmÔÜˆc”D‰jÔÜˆm˜X t¬RÔ0ÜÐ&¬Ô+â?ˆØ:?Ö@°Qœ
×-Ñ-¨aÕ0Ð@ˆÐ@äŒØ"ò 	PˆFðPÝâœrŸt™t F¬BÔ/ð1õð	Pò
ˆð &ò 	?‰IˆC�ð?ÜŸ™œj×3Ñ3°CÓ8¼"Ó=�ÜÑUÐPTÔUÓU�Ü˜˜˜Q˜t˜f O°G¸vÐ4EÐ3FÐGÕHñ		?ð9 ùò Aøô ò PÜÐEÈÑNÖOðPûô ò ?Ü˜˜˜Q˜t˜fÐ$<Ð=Ö>ð?ú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ð* ò HˆÜ
�‰Œ
ÙÜ�K‰K˜œb %Õ(ä�N 4 &¨¬r¯{©{¸4ÄÓ/DÐ.EÐFÕGñH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?Ö?¨dŒj×#Ñ# DÕ)Ð?€FÐ?àò 
ˆÜ
�‰Œ
ÜØ,×3Ñ3°A´r·}±}ÀQÈÌRÐQVÓ7WÓ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"  (  sQ   € ô œX¬'´gÑ>€Eð$Øˆˆc‰
˜ÖøÜò $Øò 	$ˆCØˆE�#‰J˜UÖ#ò	$ð$ú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 �—
‘
˜<Ó(€Ø�B—J‘J˜zÓ*Ð ØˆR�Z‰Zð'ð ‡J�Jó	€
ò óF!ô2~�ô ~÷BWñ Wð| 
€ó
*Hób5?óx%HóX-
ó`$ð* ˆzÒÙˆ�!Öð r   