.. Copyright (C) 2001-2018 NLTK Project
.. For license information, see LICENSE.TXT

=========
Semantics
=========

    >>> import nltk
    >>> from nltk.sem import Valuation, Model
    >>> v = [('adam', 'b1'), ('betty', 'g1'), ('fido', 'd1'),
    ... ('girl', set(['g1', 'g2'])), ('boy', set(['b1', 'b2'])),
    ... ('dog', set(['d1'])),
    ... ('love', set([('b1', 'g1'), ('b2', 'g2'), ('g1', 'b1'), ('g2', 'b1')]))]
    >>> val = Valuation(v)
    >>> dom = val.domain
    >>> m = Model(dom, val)

Evaluation
----------

The top-level method of a ``Model`` instance is ``evaluate()``, which
assigns a semantic value to expressions of the ``logic`` module, under
an assignment ``g``:

    >>> dom = val.domain
    >>> g = nltk.sem.Assignment(dom)
    >>> m.evaluate('all x.(boy(x) -> - girl(x))', g)
    True


``evaluate()`` calls a recursive function ``satisfy()``, which in turn
calls a function ``i()`` to interpret non-logical constants and
individual variables. ``i()`` delegates the interpretation of these to
the the model's ``Valuation`` and the variable assignment ``g``
respectively. Any atomic expression which cannot be assigned a value
by ``i`` raises an ``Undefined`` exception; this is caught by
``evaluate``, which returns the string ``'Undefined'``.

    >>> m.evaluate('walk(adam)', g, trace=2)
    <BLANKLINE>
    'walk(adam)' is undefined under M, g
    'Undefined'

Batch Processing
----------------

The utility functions ``interpret_sents()`` and ``evaluate_sents()`` are intended to
help with processing multiple sentences. Here's an example of the first of these:

    >>> sents = ['Mary walks']
    >>> results = nltk.sem.util.interpret_sents(sents, 'grammars/sample_grammars/sem2.fcfg')
    >>> for result in results:
    ...     for (synrep, semrep) in result:
    ...         print(synrep)
    (S[SEM=<walk(mary)>]
      (NP[-LOC, NUM='sg', SEM=<\P.P(mary)>]
        (PropN[-LOC, NUM='sg', SEM=<\P.P(mary)>] Mary))
      (VP[NUM='sg', SEM=<\x.walk(x)>]
        (IV[NUM='sg', SEM=<\x.walk(x)>, TNS='pres'] walks)))

In order to provide backwards compatibility with 'legacy' grammars where the semantics value
is specified with a lowercase
``sem`` feature, the relevant feature name can be passed to the function using the
``semkey`` parameter, as shown here:

    >>> sents = ['raining']
    >>> g = nltk.grammar.FeatureGrammar.fromstring("""
    ... % start S
    ... S[sem=<raining>] -> 'raining'
    ... """)
    >>> results = nltk.sem.util.interpret_sents(sents, g, semkey='sem')
    >>> for result in results:
    ...     for (synrep, semrep) in result:
    ...         print(semrep)
    raining

The function ``evaluate_sents()`` works in a similar manner, but also needs to be
passed a ``Model`` against which the semantic representations are evaluated.

Unit Tests
==========


Unit tests for relations and valuations
---------------------------------------

    >>> from nltk.sem import *

Relations are sets of tuples, all of the same length.

    >>> s1 = set([('d1', 'd2'), ('d1', 'd1'), ('d2', 'd1')])
    >>> is_rel(s1)
    True
    >>> s2 = set([('d1', 'd2'), ('d1', 'd2'), ('d1',)])
    >>> is_rel(s2)
    Traceback (most recent call last):
      . . .
    ValueError: Set set([('d1', 'd2'), ('d1',)]) contains sequences of different lengths
    >>> s3 = set(['d1', 'd2'])
    >>> is_rel(s3)
    Traceback (most recent call last):
      . . .
    ValueError: Set set(['d2', 'd1']) contains sequences of different lengths
    >>> s4 = set2rel(s3)
    >>> is_rel(s4)
    True
    >>> is_rel(set())
    True
    >>> null_binary_rel = set([(None, None)])
    >>> is_rel(null_binary_rel)
    True

Sets of entities are converted into sets of singleton tuples
(containing strings).

    >>> sorted(set2rel(s3))
    [('d1',), ('d2',)]
    >>> sorted(set2rel(set([1,3,5,])))
    ['1', '3', '5']
    >>> set2rel(set()) == set()
    True
    >>> set2rel(set2rel(s3)) == set2rel(s3)
    True

Predication is evaluated by set membership.

    >>> ('d1', 'd2') in s1
    True
    >>> ('d2', 'd2') in s1
    False
    >>> ('d1',) in s1
    False
    >>> 'd2' in s1
    False
    >>> ('d1',) in s4
    True
    >>> ('d1',) in set()
    False
    >>> 'd1' in  null_binary_rel
    False


    >>> val = Valuation([('Fido', 'd1'), ('dog', set(['d1', 'd2'])), ('walk', set())])
    >>> sorted(val['dog'])
    [('d1',), ('d2',)]
    >>> val.domain == set(['d1', 'd2'])
    True
    >>> print(val.symbols)
    ['Fido', 'dog', 'walk']


Parse a valuation from a string.

    >>> v = """
    ... john => b1
    ... mary => g1
    ... suzie => g2
    ... fido => d1
    ... tess => d2
    ... noosa => n
    ... girl => {g1, g2}
    ... boy => {b1, b2}
    ... dog => {d1, d2}
    ... bark => {d1, d2}
    ... walk => {b1, g2, d1}
    ... chase => {(b1, g1), (b2, g1), (g1, d1), (g2, d2)}
    ... see => {(b1, g1), (b2, d2), (g1, b1),(d2, b1), (g2, n)}
    ... in => {(b1, n), (b2, n), (d2, n)}
    ... with => {(b1, g1), (g1, b1), (d1, b1), (b1, d1)}
    ... """
    >>> val = Valuation.fromstring(v)

    >>> print(val) # doctest: +SKIP
    {'bark': set([('d1',), ('d2',)]),
     'boy': set([('b1',), ('b2',)]),
     'chase': set([('b1', 'g1'), ('g2', 'd2'), ('g1', 'd1'), ('b2', 'g1')]),
     'dog': set([('d1',), ('d2',)]),
     'fido': 'd1',
     'girl': set([('g2',), ('g1',)]),
     'in': set([('d2', 'n'), ('b1', 'n'), ('b2', 'n')]),
     'john': 'b1',
     'mary': 'g1',
     'noosa': 'n',
     'see': set([('b1', 'g1'), ('b2', 'd2'), ('d2', 'b1'), ('g2', 'n'), ('g1', 'b1')]),
     'suzie': 'g2',
     'tess': 'd2',
     'walk': set([('d1',), ('b1',), ('g2',)]),
     'with': set([('b1', 'g1'), ('d1', 'b1'), ('b1', 'd1'), ('g1', 'b1')])}


Unit tests for function argument application in a Model
-------------------------------------------------------

    >>> v = [('adam', 'b1'), ('betty', 'g1'), ('fido', 'd1'),\
    ...      ('girl', set(['g1', 'g2'])), ('boy', set(['b1', 'b2'])), ('dog', set(['d1'])),
    ...      ('love', set([('b1', 'g1'), ('b2', 'g2'), ('g1', 'b1'), ('g2', 'b1')])),
    ...      ('kiss', null_binary_rel)]
    >>> val = Valuation(v)
    >>> dom = val.domain
    >>> m = Model(dom, val)
    >>> g = Assignment(dom)
    >>> sorted(val['boy'])
    [('b1',), ('b2',)]
    >>> ('b1',) in val['boy']
    True
    >>> ('g1',) in val['boy']
    False
    >>> ('foo',) in val['boy']
    False
    >>> ('b1', 'g1') in val['love']
    True
    >>> ('b1', 'b1') in val['kiss']
    False
    >>> sorted(val.domain)
    ['b1', 'b2', 'd1', 'g1', 'g2']


Model Tests
===========

Extension of Lambda expressions

    >>> v0 = [('adam', 'b1'), ('betty', 'g1'), ('fido', 'd1'),\
    ... ('girl', set(['g1', 'g2'])), ('boy', set(['b1', 'b2'])),
    ... ('dog', set(['d1'])),
    ... ('love', set([('b1', 'g1'), ('b2', 'g2'), ('g1', 'b1'), ('g2', 'b1')]))]

    >>> val0 = Valuation(v0)
    >>> dom0 = val0.domain
    >>> m0 = Model(dom0, val0)
    >>> g0 = Assignment(dom0)

    >>> print(m0.evaluate(r'\x. \y. love(x, y)', g0) == {'g2': {'g2': False, 'b2': False, 'b1': True, 'g1': False, 'd1': False}, 'b2': {'g2': True, 'b2': False, 'b1': False, 'g1': False, 'd1': False}, 'b1': {'g2': False, 'b2': False, 'b1': False, 'g1': True, 'd1': False}, 'g1': {'g2': False, 'b2': False, 'b1': True, 'g1': False, 'd1': False}, 'd1': {'g2': False, 'b2': False, 'b1': False, 'g1': False, 'd1': False}})
    True
    >>> print(m0.evaluate(r'\x. dog(x) (adam)', g0))
    False
    >>> print(m0.evaluate(r'\x. (dog(x) | boy(x)) (adam)', g0))
    True
    >>> print(m0.evaluate(r'\x. \y. love(x, y)(fido)', g0) == {'g2': False, 'b2': False, 'b1': False, 'g1': False, 'd1': False})
    True
    >>> print(m0.evaluate(r'\x. \y. love(x, y)(adam)', g0) == {'g2': False, 'b2': False, 'b1': False, 'g1': True, 'd1': False})
    True
    >>> print(m0.evaluate(r'\x. \y. love(x, y)(betty)', g0) == {'g2': False, 'b2': False, 'b1': True, 'g1': False, 'd1': False})
    True
    >>> print(m0.evaluate(r'\x. \y. love(x, y)(betty)(adam)', g0))
    True
    >>> print(m0.evaluate(r'\x. \y. love(x, y)(betty, adam)', g0))
    True
    >>> print(m0.evaluate(r'\y. \x. love(x, y)(fido)(adam)', g0))
    False
    >>> print(m0.evaluate(r'\y. \x. love(x, y)(betty, adam)', g0))
    True
    >>> print(m0.evaluate(r'\x. exists y. love(x, y)', g0) == {'g2': True, 'b2': True, 'b1': True, 'g1': True, 'd1': False})
    True
    >>> print(m0.evaluate(r'\z. adam', g0) == {'g2': 'b1', 'b2': 'b1', 'b1': 'b1', 'g1': 'b1', 'd1': 'b1'})
    True
    >>> print(m0.evaluate(r'\z. love(x, y)', g0) == {'g2': False, 'b2': False, 'b1': False, 'g1': False, 'd1': False})
    True


Propositional Model Test
------------------------

    >>> tests = [
    ...     ('P & Q', True),
    ...     ('P & R', False),
    ...     ('- P', False),
    ...     ('- R', True),
    ...     ('- - P', True),
    ...     ('- (P & R)', True),
    ...     ('P | R', True),
    ...     ('R | P', True),
    ...     ('R | R', False),
    ...     ('- P | R', False),
    ...     ('P | - P', True),
    ...     ('P -> Q', True),
    ...     ('P -> R', False),
    ...     ('R -> P', True),
    ...     ('P <-> P', True),
    ...     ('R <-> R', True),
    ...     ('P <-> R', False),
    ...     ]
    >>> val1 = Valuation([('P', True), ('Q', True), ('R', False)])
    >>> dom = set([])
    >>> m = Model(dom, val1)
    >>> g = Assignment(dom)
    >>> for (sent, testvalue) in tests:
    ...     semvalue = m.evaluate(sent, g)
    ...     if semvalue == testvalue:
    ...         print('*', end=' ')
    * * * * * * * * * * * * * * * * *


Test of i Function
------------------

    >>> from nltk.sem import Expression
    >>> v = [('adam', 'b1'), ('betty', 'g1'), ('fido', 'd1'),
    ...      ('girl', set(['g1', 'g2'])), ('boy', set(['b1', 'b2'])), ('dog', set(['d1'])),
    ...      ('love', set([('b1', 'g1'), ('b2', 'g2'), ('g1', 'b1'), ('g2', 'b1')]))]
    >>> val = Valuation(v)
    >>> dom = val.domain
    >>> m = Model(dom, val)
    >>> g = Assignment(dom, [('x', 'b1'), ('y', 'g2')])
    >>> exprs = ['adam', 'girl', 'love', 'walks', 'x', 'y', 'z']
    >>> parsed_exprs = [Expression.fromstring(e) for e in exprs]
    >>> sorted_set = lambda x: sorted(x) if isinstance(x, set) else x
    >>> for parsed in parsed_exprs:
    ...     try:
    ...         print("'%s' gets value %s" % (parsed, sorted_set(m.i(parsed, g))))
    ...     except Undefined:
    ...         print("'%s' is Undefined" % parsed)
    'adam' gets value b1
    'girl' gets value [('g1',), ('g2',)]
    'love' gets value [('b1', 'g1'), ('b2', 'g2'), ('g1', 'b1'), ('g2', 'b1')]
    'walks' is Undefined
    'x' gets value b1
    'y' gets value g2
    'z' is Undefined

Test for formulas in Model
--------------------------

    >>> tests = [
    ...     ('love(adam, betty)', True),
    ...     ('love(adam, sue)', 'Undefined'),
    ...     ('dog(fido)', True),
    ...     ('- dog(fido)', False),
    ...     ('- - dog(fido)', True),
    ...     ('- dog(sue)', 'Undefined'),
    ...     ('dog(fido) & boy(adam)', True),
    ...     ('- (dog(fido) & boy(adam))', False),
    ...     ('- dog(fido) & boy(adam)', False),
    ...     ('dog(fido) | boy(adam)', True),
    ...     ('- (dog(fido) | boy(adam))', False),
    ...     ('- dog(fido) | boy(adam)', True),
    ...     ('- dog(fido) | - boy(adam)', False),
    ...     ('dog(fido) -> boy(adam)', True),
    ...     ('- (dog(fido) -> boy(adam))', False),
    ...     ('- dog(fido) -> boy(adam)', True),
    ...     ('exists x . love(adam, x)', True),
    ...     ('all x . love(adam, x)', False),
    ...     ('fido = fido', True),
    ...     ('exists x . all y. love(x, y)', False),
    ...     ('exists x . (x = fido)', True),
    ...     ('all x . (dog(x) | - dog(x))', True),
    ...     ('adam = mia', 'Undefined'),
    ...     ('\\x. (boy(x) | girl(x))', {'g2': True, 'b2': True, 'b1': True, 'g1': True, 'd1': False}),
    ...     ('\\x. exists y. (boy(x) & love(x, y))', {'g2': False, 'b2': True, 'b1': True, 'g1': False, 'd1': False}),
    ...     ('exists z1. boy(z1)', True),
    ...     ('exists x. (boy(x) & - (x = adam))', True),
    ...     ('exists x. (boy(x) & all y. love(y, x))', False),
    ...     ('all x. (boy(x) | girl(x))', False),
    ...     ('all x. (girl(x) -> exists y. boy(y) & love(x, y))', False),
    ...     ('exists x. (boy(x) & all y. (girl(y) -> love(y, x)))', True),
    ...     ('exists x. (boy(x) & all y. (girl(y) -> love(x, y)))', False),
    ...     ('all x. (dog(x) -> - girl(x))', True),
    ...     ('exists x. exists y. (love(x, y) & love(x, y))', True),
    ...     ]
    >>> for (sent, testvalue) in tests:
    ...     semvalue = m.evaluate(sent, g)
    ...     if semvalue == testvalue:
    ...         print('*', end=' ')
    ...     else:
    ...         print(sent, semvalue)
    * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *



Satisfier Tests
---------------

    >>> formulas = [
    ...     'boy(x)',
    ...     '(x = x)',
    ...     '(boy(x) | girl(x))',
    ...     '(boy(x) & girl(x))',
    ...     'love(adam, x)',
    ...     'love(x, adam)',
    ...     '- (x = adam)',
    ...     'exists z22. love(x, z22)',
    ...     'exists y. love(y, x)',
    ...     'all y. (girl(y) -> love(x, y))',
    ...     'all y. (girl(y) -> love(y, x))',
    ...     'all y. (girl(y) -> (boy(x) & love(y, x)))',
    ...     'boy(x) & all y. (girl(y) -> love(x, y))',
    ...     'boy(x) & all y. (girl(y) -> love(y, x))',
    ...     'boy(x) & exists y. (girl(y) & love(y, x))',
    ...     'girl(x) -> dog(x)',
    ...     'all y. (dog(y) -> (x = y))',
    ...     '- exists y. love(y, x)',
    ...     'exists y. (love(adam, y) & love(y, x))'
    ...     ]
    >>> g.purge()
    >>> g.add('x', 'b1')
    {'x': 'b1'}
    >>> for f in formulas: # doctest: +NORMALIZE_WHITESPACE
    ...     try:
    ...         print("'%s' gets value: %s" % (f, m.evaluate(f, g)))
    ...     except Undefined:
    ...         print("'%s' is Undefined" % f)
    'boy(x)' gets value: True
    '(x = x)' gets value: True
    '(boy(x) | girl(x))' gets value: True
    '(boy(x) & girl(x))' gets value: False
    'love(adam, x)' gets value: False
    'love(x, adam)' gets value: False
    '- (x = adam)' gets value: False
    'exists z22. love(x, z22)' gets value: True
    'exists y. love(y, x)' gets value: True
    'all y. (girl(y) -> love(x, y))' gets value: False
    'all y. (girl(y) -> love(y, x))' gets value: True
    'all y. (girl(y) -> (boy(x) & love(y, x)))' gets value: True
    'boy(x) & all y. (girl(y) -> love(x, y))' gets value: False
    'boy(x) & all y. (girl(y) -> love(y, x))' gets value: True
    'boy(x) & exists y. (girl(y) & love(y, x))' gets value: True
    'girl(x) -> dog(x)' gets value: True
    'all y. (dog(y) -> (x = y))' gets value: False
    '- exists y. love(y, x)' gets value: False
    'exists y. (love(adam, y) & love(y, x))' gets value: True

    >>> from nltk.sem import Expression
    >>> for fmla in formulas: # doctest: +NORMALIZE_WHITESPACE
    ...     p = Expression.fromstring(fmla)
    ...     g.purge()
    ...     print("Satisfiers of '%s':\n\t%s" % (p, sorted(m.satisfiers(p, 'x', g))))
    Satisfiers of 'boy(x)':
    ['b1', 'b2']
    Satisfiers of '(x = x)':
    ['b1', 'b2', 'd1', 'g1', 'g2']
    Satisfiers of '(boy(x) | girl(x))':
    ['b1', 'b2', 'g1', 'g2']
    Satisfiers of '(boy(x) & girl(x))':
    []
    Satisfiers of 'love(adam,x)':
    ['g1']
    Satisfiers of 'love(x,adam)':
    ['g1', 'g2']
    Satisfiers of '-(x = adam)':
    ['b2', 'd1', 'g1', 'g2']
    Satisfiers of 'exists z22.love(x,z22)':
    ['b1', 'b2', 'g1', 'g2']
    Satisfiers of 'exists y.love(y,x)':
    ['b1', 'g1', 'g2']
    Satisfiers of 'all y.(girl(y) -> love(x,y))':
    []
    Satisfiers of 'all y.(girl(y) -> love(y,x))':
    ['b1']
    Satisfiers of 'all y.(girl(y) -> (boy(x) & love(y,x)))':
    ['b1']
    Satisfiers of '(boy(x) & all y.(girl(y) -> love(x,y)))':
    []
    Satisfiers of '(boy(x) & all y.(girl(y) -> love(y,x)))':
    ['b1']
    Satisfiers of '(boy(x) & exists y.(girl(y) & love(y,x)))':
    ['b1']
    Satisfiers of '(girl(x) -> dog(x))':
    ['b1', 'b2', 'd1']
    Satisfiers of 'all y.(dog(y) -> (x = y))':
    ['d1']
    Satisfiers of '-exists y.love(y,x)':
    ['b2', 'd1']
    Satisfiers of 'exists y.(love(adam,y) & love(y,x))':
    ['b1']


Tests based on the Blackburn & Bos testsuite
--------------------------------------------

    >>> v1 = [('jules', 'd1'), ('vincent', 'd2'), ('pumpkin', 'd3'),
    ...       ('honey_bunny', 'd4'), ('yolanda', 'd5'),
    ...       ('customer', set(['d1', 'd2'])),
    ...       ('robber', set(['d3', 'd4'])),
    ...       ('love', set([('d3', 'd4')]))]
    >>> val1 = Valuation(v1)
    >>> dom1 = val1.domain
    >>> m1 = Model(dom1, val1)
    >>> g1 = Assignment(dom1)

    >>> v2 = [('jules', 'd1'), ('vincent', 'd2'), ('pumpkin', 'd3'),
    ...       ('honey_bunny', 'd4'), ('yolanda', 'd4'),
    ...       ('customer', set(['d1', 'd2', 'd5', 'd6'])),
    ...       ('robber', set(['d3', 'd4'])),
    ...       ('love', set([(None, None)]))]
    >>> val2 = Valuation(v2)
    >>> dom2 = set(['d1', 'd2', 'd3', 'd4', 'd5', 'd6'])
    >>> m2 = Model(dom2, val2)
    >>> g2 = Assignment(dom2)
    >>> g21 = Assignment(dom2)
    >>> g21.add('y', 'd3')
    {'y': 'd3'}

    >>> v3 = [('mia', 'd1'), ('jody', 'd2'), ('jules', 'd3'),
    ...       ('vincent', 'd4'),
    ...       ('woman', set(['d1', 'd2'])), ('man', set(['d3', 'd4'])),
    ...       ('joke', set(['d5', 'd6'])), ('episode', set(['d7', 'd8'])),
    ...       ('in', set([('d5', 'd7'), ('d5', 'd8')])),
    ...       ('tell', set([('d1', 'd5'), ('d2', 'd6')]))]
    >>> val3 = Valuation(v3)
    >>> dom3 = set(['d1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8'])
    >>> m3 = Model(dom3, val3)
    >>> g3 = Assignment(dom3)

    >>> tests = [
    ...     ('exists x. robber(x)', m1, g1, True),
    ...     ('exists x. exists y. love(y, x)', m1, g1, True),
    ...     ('exists x0. exists x1. love(x1, x0)', m2, g2, False),
    ...     ('all x. all y. love(y, x)', m2, g2, False),
    ...     ('- (all x. all y. love(y, x))', m2, g2, True),
    ...     ('all x. all y. - love(y, x)', m2, g2, True),
    ...     ('yolanda = honey_bunny', m2, g2, True),
    ...     ('mia = honey_bunny', m2, g2, 'Undefined'),
    ...     ('- (yolanda = honey_bunny)', m2, g2, False),
    ...     ('- (mia = honey_bunny)', m2, g2, 'Undefined'),
    ...     ('all x. (robber(x) | customer(x))', m2, g2, True),
    ...     ('- (all x. (robber(x) | customer(x)))', m2, g2, False),
    ...     ('(robber(x) | customer(x))', m2, g2, 'Undefined'),
    ...     ('(robber(y) | customer(y))', m2, g21, True),
    ...     ('exists x. (man(x) & exists x. woman(x))', m3, g3, True),
    ...     ('exists x. (man(x) & exists x. woman(x))', m3, g3, True),
    ...     ('- exists x. woman(x)', m3, g3, False),
    ...     ('exists x. (tasty(x) & burger(x))', m3, g3, 'Undefined'),
    ...     ('- exists x. (tasty(x) & burger(x))', m3, g3, 'Undefined'),
    ...     ('exists x. (man(x) & - exists y. woman(y))', m3, g3, False),
    ...     ('exists x. (man(x) & - exists x. woman(x))', m3, g3, False),
    ...     ('exists x. (woman(x) & - exists x. customer(x))', m2, g2, 'Undefined'),
    ... ]

    >>> for item in tests:
    ...     sentence, model, g, testvalue = item
    ...     semvalue = model.evaluate(sentence, g)
    ...     if semvalue == testvalue:
    ...         print('*', end=' ')
    ...     g.purge()
    * * * * * * * * * * * * * * * * * * * * * *


Tests for mapping from syntax to semantics
------------------------------------------

Load a valuation from a file.

    >>> import nltk.data
    >>> from nltk.sem.util import parse_sents
    >>> val = nltk.data.load('grammars/sample_grammars/valuation1.val')
    >>> dom = val.domain
    >>> m = Model(dom, val)
    >>> g = Assignment(dom)
    >>> gramfile = 'grammars/sample_grammars/sem2.fcfg'
    >>> inputs = ['John sees a girl', 'every dog barks']
    >>> parses = parse_sents(inputs, gramfile)
    >>> for sent, trees in zip(inputs, parses):
    ...     print()
    ...     print("Sentence: %s" % sent)
    ...     for tree in trees:
    ...         print("Parse:\n %s" %tree)
    ...         print("Semantics: %s" %  root_semrep(tree))
    <BLANKLINE>
    Sentence: John sees a girl
    Parse:
     (S[SEM=<exists x.(girl(x) & see(john,x))>]
      (NP[-LOC, NUM='sg', SEM=<\P.P(john)>]
        (PropN[-LOC, NUM='sg', SEM=<\P.P(john)>] John))
      (VP[NUM='sg', SEM=<\y.exists x.(girl(x) & see(y,x))>]
        (TV[NUM='sg', SEM=<\X y.X(\x.see(y,x))>, TNS='pres'] sees)
        (NP[NUM='sg', SEM=<\Q.exists x.(girl(x) & Q(x))>]
          (Det[NUM='sg', SEM=<\P Q.exists x.(P(x) & Q(x))>] a)
          (Nom[NUM='sg', SEM=<\x.girl(x)>]
            (N[NUM='sg', SEM=<\x.girl(x)>] girl)))))
    Semantics: exists x.(girl(x) & see(john,x))
    <BLANKLINE>
    Sentence: every dog barks
    Parse:
     (S[SEM=<all x.(dog(x) -> bark(x))>]
      (NP[NUM='sg', SEM=<\Q.all x.(dog(x) -> Q(x))>]
        (Det[NUM='sg', SEM=<\P Q.all x.(P(x) -> Q(x))>] every)
        (Nom[NUM='sg', SEM=<\x.dog(x)>]
          (N[NUM='sg', SEM=<\x.dog(x)>] dog)))
      (VP[NUM='sg', SEM=<\x.bark(x)>]
        (IV[NUM='sg', SEM=<\x.bark(x)>, TNS='pres'] barks)))
    Semantics: all x.(dog(x) -> bark(x))

    >>> sent = "every dog barks"
    >>> result = nltk.sem.util.interpret_sents([sent], gramfile)[0]
    >>> for (syntree, semrep) in result:
    ...     print(syntree)
    ...     print()
    ...     print(semrep)
    (S[SEM=<all x.(dog(x) -> bark(x))>]
      (NP[NUM='sg', SEM=<\Q.all x.(dog(x) -> Q(x))>]
        (Det[NUM='sg', SEM=<\P Q.all x.(P(x) -> Q(x))>] every)
        (Nom[NUM='sg', SEM=<\x.dog(x)>]
          (N[NUM='sg', SEM=<\x.dog(x)>] dog)))
      (VP[NUM='sg', SEM=<\x.bark(x)>]
        (IV[NUM='sg', SEM=<\x.bark(x)>, TNS='pres'] barks)))
    <BLANKLINE>
    all x.(dog(x) -> bark(x))

    >>> result = nltk.sem.util.evaluate_sents([sent], gramfile, m, g)[0]
    >>> for (syntree, semrel, value) in result:
    ...     print(syntree)
    ...     print()
    ...     print(semrep)
    ...     print()
    ...     print(value)
    (S[SEM=<all x.(dog(x) -> bark(x))>]
      (NP[NUM='sg', SEM=<\Q.all x.(dog(x) -> Q(x))>]
        (Det[NUM='sg', SEM=<\P Q.all x.(P(x) -> Q(x))>] every)
        (Nom[NUM='sg', SEM=<\x.dog(x)>]
          (N[NUM='sg', SEM=<\x.dog(x)>] dog)))
      (VP[NUM='sg', SEM=<\x.bark(x)>]
        (IV[NUM='sg', SEM=<\x.bark(x)>, TNS='pres'] barks)))
    <BLANKLINE>
    all x.(dog(x) -> bark(x))
    <BLANKLINE>
    True

    >>> sents = ['Mary walks', 'John sees a dog']
    >>> results = nltk.sem.util.interpret_sents(sents, 'grammars/sample_grammars/sem2.fcfg')
    >>> for result in results:
    ...     for (synrep, semrep) in result:
    ...         print(synrep)
    (S[SEM=<walk(mary)>]
      (NP[-LOC, NUM='sg', SEM=<\P.P(mary)>]
        (PropN[-LOC, NUM='sg', SEM=<\P.P(mary)>] Mary))
      (VP[NUM='sg', SEM=<\x.walk(x)>]
        (IV[NUM='sg', SEM=<\x.walk(x)>, TNS='pres'] walks)))
    (S[SEM=<exists x.(dog(x) & see(john,x))>]
      (NP[-LOC, NUM='sg', SEM=<\P.P(john)>]
        (PropN[-LOC, NUM='sg', SEM=<\P.P(john)>] John))
      (VP[NUM='sg', SEM=<\y.exists x.(dog(x) & see(y,x))>]
        (TV[NUM='sg', SEM=<\X y.X(\x.see(y,x))>, TNS='pres'] sees)
        (NP[NUM='sg', SEM=<\Q.exists x.(dog(x) & Q(x))>]
          (Det[NUM='sg', SEM=<\P Q.exists x.(P(x) & Q(x))>] a)
          (Nom[NUM='sg', SEM=<\x.dog(x)>]
            (N[NUM='sg', SEM=<\x.dog(x)>] dog)))))

Cooper Storage
--------------

    >>> from nltk.sem import cooper_storage as cs
    >>> sentence = 'every girl chases a dog'
    >>> trees = cs.parse_with_bindops(sentence, grammar='grammars/book_grammars/storage.fcfg')
    >>> semrep = trees[0].label()['SEM']
    >>> cs_semrep = cs.CooperStore(semrep)
    >>> print(cs_semrep.core)
    chase(z2,z4)
    >>> for bo in cs_semrep.store:
    ...     print(bo)
    bo(\P.all x.(girl(x) -> P(x)),z2)
    bo(\P.exists x.(dog(x) & P(x)),z4)
    >>> cs_semrep.s_retrieve(trace=True)
    Permutation 1
       (\P.all x.(girl(x) -> P(x)))(\z2.chase(z2,z4))
       (\P.exists x.(dog(x) & P(x)))(\z4.all x.(girl(x) -> chase(x,z4)))
    Permutation 2
       (\P.exists x.(dog(x) & P(x)))(\z4.chase(z2,z4))
       (\P.all x.(girl(x) -> P(x)))(\z2.exists x.(dog(x) & chase(z2,x)))

    >>> for reading in cs_semrep.readings:
    ...     print(reading)
    exists x.(dog(x) & all z3.(girl(z3) -> chase(z3,x)))
    all x.(girl(x) -> exists z4.(dog(z4) & chase(x,z4)))