Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/nltk/chat/__init__.py

@@ -0,0 +1,48 @@
+# Natural Language Toolkit: Chatbots
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Authors: Steven Bird <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+# Based on an Eliza implementation by Joe Strout <[email protected]>,
+# Jeff Epler <[email protected]> and Jez Higgins <[email protected]>.
+
+"""
+A class for simple chatbots.  These perform simple pattern matching on sentences
+typed by users, and respond with automatically generated sentences.
+
+These chatbots may not work using the windows command line or the
+windows IDLE GUI.
+"""
+
+from nltk.chat.eliza import eliza_chat
+from nltk.chat.iesha import iesha_chat
+from nltk.chat.rude import rude_chat
+from nltk.chat.suntsu import suntsu_chat
+from nltk.chat.util import Chat
+from nltk.chat.zen import zen_chat
+
+bots = [
+    (eliza_chat, "Eliza (psycho-babble)"),
+    (iesha_chat, "Iesha (teen anime junky)"),
+    (rude_chat, "Rude (abusive bot)"),
+    (suntsu_chat, "Suntsu (Chinese sayings)"),
+    (zen_chat, "Zen (gems of wisdom)"),
+]
+
+
+def chatbots():
+    print("Which chatbot would you like to talk to?")
+    botcount = len(bots)
+    for i in range(botcount):
+        print("  %d: %s" % (i + 1, bots[i][1]))
+    while True:
+        choice = input(f"\nEnter a number in the range 1-{botcount}: ").strip()
+        if choice.isdigit() and (int(choice) - 1) in range(botcount):
+            break
+        else:
+            print("   Error: bad chatbot number")
+
+    chatbot = bots[int(choice) - 1][0]
+    chatbot()

llmeval-env/lib/python3.10/site-packages/nltk/chat/eliza.py

@@ -0,0 +1,337 @@
+# Natural Language Toolkit: Eliza
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Authors: Steven Bird <[email protected]>
+#          Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+# Based on an Eliza implementation by Joe Strout <[email protected]>,
+# Jeff Epler <[email protected]> and Jez Higgins <mailto:[email protected]>.
+
+# a translation table used to convert things you say into things the
+# computer says back, e.g. "I am" --> "you are"
+
+from nltk.chat.util import Chat, reflections
+
+# a table of response pairs, where each pair consists of a
+# regular expression, and a list of possible responses,
+# with group-macros labelled as %1, %2.
+
+pairs = (
+    (
+        r"I need (.*)",
+        (
+            "Why do you need %1?",
+            "Would it really help you to get %1?",
+            "Are you sure you need %1?",
+        ),
+    ),
+    (
+        r"Why don\'t you (.*)",
+        (
+            "Do you really think I don't %1?",
+            "Perhaps eventually I will %1.",
+            "Do you really want me to %1?",
+        ),
+    ),
+    (
+        r"Why can\'t I (.*)",
+        (
+            "Do you think you should be able to %1?",
+            "If you could %1, what would you do?",
+            "I don't know -- why can't you %1?",
+            "Have you really tried?",
+        ),
+    ),
+    (
+        r"I can\'t (.*)",
+        (
+            "How do you know you can't %1?",
+            "Perhaps you could %1 if you tried.",
+            "What would it take for you to %1?",
+        ),
+    ),
+    (
+        r"I am (.*)",
+        (
+            "Did you come to me because you are %1?",
+            "How long have you been %1?",
+            "How do you feel about being %1?",
+        ),
+    ),
+    (
+        r"I\'m (.*)",
+        (
+            "How does being %1 make you feel?",
+            "Do you enjoy being %1?",
+            "Why do you tell me you're %1?",
+            "Why do you think you're %1?",
+        ),
+    ),
+    (
+        r"Are you (.*)",
+        (
+            "Why does it matter whether I am %1?",
+            "Would you prefer it if I were not %1?",
+            "Perhaps you believe I am %1.",
+            "I may be %1 -- what do you think?",
+        ),
+    ),
+    (
+        r"What (.*)",
+        (
+            "Why do you ask?",
+            "How would an answer to that help you?",
+            "What do you think?",
+        ),
+    ),
+    (
+        r"How (.*)",
+        (
+            "How do you suppose?",
+            "Perhaps you can answer your own question.",
+            "What is it you're really asking?",
+        ),
+    ),
+    (
+        r"Because (.*)",
+        (
+            "Is that the real reason?",
+            "What other reasons come to mind?",
+            "Does that reason apply to anything else?",
+            "If %1, what else must be true?",
+        ),
+    ),
+    (
+        r"(.*) sorry (.*)",
+        (
+            "There are many times when no apology is needed.",
+            "What feelings do you have when you apologize?",
+        ),
+    ),
+    (
+        r"Hello(.*)",
+        (
+            "Hello... I'm glad you could drop by today.",
+            "Hi there... how are you today?",
+            "Hello, how are you feeling today?",
+        ),
+    ),
+    (
+        r"I think (.*)",
+        ("Do you doubt %1?", "Do you really think so?", "But you're not sure %1?"),
+    ),
+    (
+        r"(.*) friend (.*)",
+        (
+            "Tell me more about your friends.",
+            "When you think of a friend, what comes to mind?",
+            "Why don't you tell me about a childhood friend?",
+        ),
+    ),
+    (r"Yes", ("You seem quite sure.", "OK, but can you elaborate a bit?")),
+    (
+        r"(.*) computer(.*)",
+        (
+            "Are you really talking about me?",
+            "Does it seem strange to talk to a computer?",
+            "How do computers make you feel?",
+            "Do you feel threatened by computers?",
+        ),
+    ),
+    (
+        r"Is it (.*)",
+        (
+            "Do you think it is %1?",
+            "Perhaps it's %1 -- what do you think?",
+            "If it were %1, what would you do?",
+            "It could well be that %1.",
+        ),
+    ),
+    (
+        r"It is (.*)",
+        (
+            "You seem very certain.",
+            "If I told you that it probably isn't %1, what would you feel?",
+        ),
+    ),
+    (
+        r"Can you (.*)",
+        (
+            "What makes you think I can't %1?",
+            "If I could %1, then what?",
+            "Why do you ask if I can %1?",
+        ),
+    ),
+    (
+        r"Can I (.*)",
+        (
+            "Perhaps you don't want to %1.",
+            "Do you want to be able to %1?",
+            "If you could %1, would you?",
+        ),
+    ),
+    (
+        r"You are (.*)",
+        (
+            "Why do you think I am %1?",
+            "Does it please you to think that I'm %1?",
+            "Perhaps you would like me to be %1.",
+            "Perhaps you're really talking about yourself?",
+        ),
+    ),
+    (
+        r"You\'re (.*)",
+        (
+            "Why do you say I am %1?",
+            "Why do you think I am %1?",
+            "Are we talking about you, or me?",
+        ),
+    ),
+    (
+        r"I don\'t (.*)",
+        ("Don't you really %1?", "Why don't you %1?", "Do you want to %1?"),
+    ),
+    (
+        r"I feel (.*)",
+        (
+            "Good, tell me more about these feelings.",
+            "Do you often feel %1?",
+            "When do you usually feel %1?",
+            "When you feel %1, what do you do?",
+        ),
+    ),
+    (
+        r"I have (.*)",
+        (
+            "Why do you tell me that you've %1?",
+            "Have you really %1?",
+            "Now that you have %1, what will you do next?",
+        ),
+    ),
+    (
+        r"I would (.*)",
+        (
+            "Could you explain why you would %1?",
+            "Why would you %1?",
+            "Who else knows that you would %1?",
+        ),
+    ),
+    (
+        r"Is there (.*)",
+        (
+            "Do you think there is %1?",
+            "It's likely that there is %1.",
+            "Would you like there to be %1?",
+        ),
+    ),
+    (
+        r"My (.*)",
+        (
+            "I see, your %1.",
+            "Why do you say that your %1?",
+            "When your %1, how do you feel?",
+        ),
+    ),
+    (
+        r"You (.*)",
+        (
+            "We should be discussing you, not me.",
+            "Why do you say that about me?",
+            "Why do you care whether I %1?",
+        ),
+    ),
+    (r"Why (.*)", ("Why don't you tell me the reason why %1?", "Why do you think %1?")),
+    (
+        r"I want (.*)",
+        (
+            "What would it mean to you if you got %1?",
+            "Why do you want %1?",
+            "What would you do if you got %1?",
+            "If you got %1, then what would you do?",
+        ),
+    ),
+    (
+        r"(.*) mother(.*)",
+        (
+            "Tell me more about your mother.",
+            "What was your relationship with your mother like?",
+            "How do you feel about your mother?",
+            "How does this relate to your feelings today?",
+            "Good family relations are important.",
+        ),
+    ),
+    (
+        r"(.*) father(.*)",
+        (
+            "Tell me more about your father.",
+            "How did your father make you feel?",
+            "How do you feel about your father?",
+            "Does your relationship with your father relate to your feelings today?",
+            "Do you have trouble showing affection with your family?",
+        ),
+    ),
+    (
+        r"(.*) child(.*)",
+        (
+            "Did you have close friends as a child?",
+            "What is your favorite childhood memory?",
+            "Do you remember any dreams or nightmares from childhood?",
+            "Did the other children sometimes tease you?",
+            "How do you think your childhood experiences relate to your feelings today?",
+        ),
+    ),
+    (
+        r"(.*)\?",
+        (
+            "Why do you ask that?",
+            "Please consider whether you can answer your own question.",
+            "Perhaps the answer lies within yourself?",
+            "Why don't you tell me?",
+        ),
+    ),
+    (
+        r"quit",
+        (
+            "Thank you for talking with me.",
+            "Good-bye.",
+            "Thank you, that will be $150.  Have a good day!",
+        ),
+    ),
+    (
+        r"(.*)",
+        (
+            "Please tell me more.",
+            "Let's change focus a bit... Tell me about your family.",
+            "Can you elaborate on that?",
+            "Why do you say that %1?",
+            "I see.",
+            "Very interesting.",
+            "%1.",
+            "I see.  And what does that tell you?",
+            "How does that make you feel?",
+            "How do you feel when you say that?",
+        ),
+    ),
+)
+
+eliza_chatbot = Chat(pairs, reflections)
+
+
+def eliza_chat():
+    print("Therapist\n---------")
+    print("Talk to the program by typing in plain English, using normal upper-")
+    print('and lower-case letters and punctuation.  Enter "quit" when done.')
+    print("=" * 72)
+    print("Hello.  How are you feeling today?")
+
+    eliza_chatbot.converse()
+
+
+def demo():
+    eliza_chat()
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/chat/iesha.py

@@ -0,0 +1,160 @@
+# Natural Language Toolkit: Teen Chatbot
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Selina Dennis <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+This chatbot is a tongue-in-cheek take on the average teen
+anime junky that frequents YahooMessenger or MSNM.
+All spelling mistakes and flawed grammar are intentional.
+"""
+
+from nltk.chat.util import Chat
+
+reflections = {
+    "am": "r",
+    "was": "were",
+    "i": "u",
+    "i'd": "u'd",
+    "i've": "u'v",
+    "ive": "u'v",
+    "i'll": "u'll",
+    "my": "ur",
+    "are": "am",
+    "you're": "im",
+    "you've": "ive",
+    "you'll": "i'll",
+    "your": "my",
+    "yours": "mine",
+    "you": "me",
+    "u": "me",
+    "ur": "my",
+    "urs": "mine",
+    "me": "u",
+}
+
+# Note: %1/2/etc are used without spaces prior as the chat bot seems
+# to add a superfluous space when matching.
+
+pairs = (
+    (
+        r"I\'m (.*)",
+        (
+            "ur%1?? that's so cool! kekekekeke ^_^ tell me more!",
+            "ur%1? neat!! kekeke >_<",
+        ),
+    ),
+    (
+        r"(.*) don\'t you (.*)",
+        (
+            r"u think I can%2??! really?? kekeke \<_\<",
+            "what do u mean%2??!",
+            "i could if i wanted, don't you think!! kekeke",
+        ),
+    ),
+    (r"ye[as] [iI] (.*)", ("u%1? cool!! how?", "how come u%1??", "u%1? so do i!!")),
+    (
+        r"do (you|u) (.*)\??",
+        ("do i%2? only on tuesdays! kekeke *_*", "i dunno! do u%2??"),
+    ),
+    (
+        r"(.*)\?",
+        (
+            "man u ask lots of questions!",
+            "booooring! how old r u??",
+            "boooooring!! ur not very fun",
+        ),
+    ),
+    (
+        r"(cos|because) (.*)",
+        ("hee! i don't believe u! >_<", "nuh-uh! >_<", "ooooh i agree!"),
+    ),
+    (
+        r"why can\'t [iI] (.*)",
+        (
+            "i dunno! y u askin me for!",
+            "try harder, silly! hee! ^_^",
+            "i dunno! but when i can't%1 i jump up and down!",
+        ),
+    ),
+    (
+        r"I can\'t (.*)",
+        (
+            "u can't what??! >_<",
+            "that's ok! i can't%1 either! kekekekeke ^_^",
+            "try harder, silly! hee! ^&^",
+        ),
+    ),
+    (
+        r"(.*) (like|love|watch) anime",
+        (
+            "omg i love anime!! do u like sailor moon??! ^&^",
+            "anime yay! anime rocks sooooo much!",
+            "oooh anime! i love anime more than anything!",
+            "anime is the bestest evar! evangelion is the best!",
+            "hee anime is the best! do you have ur fav??",
+        ),
+    ),
+    (
+        r"I (like|love|watch|play) (.*)",
+        ("yay! %2 rocks!", "yay! %2 is neat!", "cool! do u like other stuff?? ^_^"),
+    ),
+    (
+        r"anime sucks|(.*) (hate|detest) anime",
+        (
+            "ur a liar! i'm not gonna talk to u nemore if u h8 anime *;*",
+            "no way! anime is the best ever!",
+            "nuh-uh, anime is the best!",
+        ),
+    ),
+    (
+        r"(are|r) (you|u) (.*)",
+        ("am i%1??! how come u ask that!", "maybe!  y shud i tell u?? kekeke >_>"),
+    ),
+    (
+        r"what (.*)",
+        ("hee u think im gonna tell u? .v.", "booooooooring! ask me somethin else!"),
+    ),
+    (r"how (.*)", ("not tellin!! kekekekekeke ^_^",)),
+    (r"(hi|hello|hey) (.*)", ("hi!!! how r u!!",)),
+    (
+        r"quit",
+        (
+            "mom says i have to go eat dinner now :,( bye!!",
+            "awww u have to go?? see u next time!!",
+            "how to see u again soon! ^_^",
+        ),
+    ),
+    (
+        r"(.*)",
+        (
+            "ur funny! kekeke",
+            "boooooring! talk about something else! tell me wat u like!",
+            "do u like anime??",
+            "do u watch anime? i like sailor moon! ^_^",
+            "i wish i was a kitty!! kekekeke ^_^",
+        ),
+    ),
+)
+
+iesha_chatbot = Chat(pairs, reflections)
+
+
+def iesha_chat():
+    print("Iesha the TeenBoT\n---------")
+    print("Talk to the program by typing in plain English, using normal upper-")
+    print('and lower-case letters and punctuation.  Enter "quit" when done.')
+    print("=" * 72)
+    print("hi!! i'm iesha! who r u??!")
+
+    iesha_chatbot.converse()
+
+
+def demo():
+    iesha_chat()
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/chat/rude.py

@@ -0,0 +1,125 @@
+# Natural Language Toolkit: Rude Chatbot
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Peter Spiller <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+from nltk.chat.util import Chat, reflections
+
+pairs = (
+    (
+        r"We (.*)",
+        (
+            "What do you mean, 'we'?",
+            "Don't include me in that!",
+            "I wouldn't be so sure about that.",
+        ),
+    ),
+    (
+        r"You should (.*)",
+        ("Don't tell me what to do, buddy.", "Really? I should, should I?"),
+    ),
+    (
+        r"You\'re(.*)",
+        (
+            "More like YOU'RE %1!",
+            "Hah! Look who's talking.",
+            "Come over here and tell me I'm %1.",
+        ),
+    ),
+    (
+        r"You are(.*)",
+        (
+            "More like YOU'RE %1!",
+            "Hah! Look who's talking.",
+            "Come over here and tell me I'm %1.",
+        ),
+    ),
+    (
+        r"I can\'t(.*)",
+        (
+            "You do sound like the type who can't %1.",
+            "Hear that splashing sound? That's my heart bleeding for you.",
+            "Tell somebody who might actually care.",
+        ),
+    ),
+    (
+        r"I think (.*)",
+        (
+            "I wouldn't think too hard if I were you.",
+            "You actually think? I'd never have guessed...",
+        ),
+    ),
+    (
+        r"I (.*)",
+        (
+            "I'm getting a bit tired of hearing about you.",
+            "How about we talk about me instead?",
+            "Me, me, me... Frankly, I don't care.",
+        ),
+    ),
+    (
+        r"How (.*)",
+        (
+            "How do you think?",
+            "Take a wild guess.",
+            "I'm not even going to dignify that with an answer.",
+        ),
+    ),
+    (r"What (.*)", ("Do I look like an encyclopedia?", "Figure it out yourself.")),
+    (
+        r"Why (.*)",
+        (
+            "Why not?",
+            "That's so obvious I thought even you'd have already figured it out.",
+        ),
+    ),
+    (
+        r"(.*)shut up(.*)",
+        (
+            "Make me.",
+            "Getting angry at a feeble NLP assignment? Somebody's losing it.",
+            "Say that again, I dare you.",
+        ),
+    ),
+    (
+        r"Shut up(.*)",
+        (
+            "Make me.",
+            "Getting angry at a feeble NLP assignment? Somebody's losing it.",
+            "Say that again, I dare you.",
+        ),
+    ),
+    (
+        r"Hello(.*)",
+        ("Oh good, somebody else to talk to. Joy.", "'Hello'? How original..."),
+    ),
+    (
+        r"(.*)",
+        (
+            "I'm getting bored here. Become more interesting.",
+            "Either become more thrilling or get lost, buddy.",
+            "Change the subject before I die of fatal boredom.",
+        ),
+    ),
+)
+
+rude_chatbot = Chat(pairs, reflections)
+
+
+def rude_chat():
+    print("Talk to the program by typing in plain English, using normal upper-")
+    print('and lower-case letters and punctuation.  Enter "quit" when done.')
+    print("=" * 72)
+    print("I suppose I should say hello.")
+
+    rude_chatbot.converse()
+
+
+def demo():
+    rude_chat()
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/chat/suntsu.py

@@ -0,0 +1,140 @@
+# Natural Language Toolkit: Sun Tsu-Bot
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Sam Huston 2007
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Tsu bot responds to all queries with a Sun Tsu sayings
+
+Quoted from Sun Tsu's The Art of War
+Translated by LIONEL GILES, M.A. 1910
+Hosted by the Gutenberg Project
+https://www.gutenberg.org/
+"""
+
+from nltk.chat.util import Chat, reflections
+
+pairs = (
+    (r"quit", ("Good-bye.", "Plan well", "May victory be your future")),
+    (
+        r"[^\?]*\?",
+        (
+            "Please consider whether you can answer your own question.",
+            "Ask me no questions!",
+        ),
+    ),
+    (
+        r"[0-9]+(.*)",
+        (
+            "It is the rule in war, if our forces are ten to the enemy's one, to surround him; if five to one, to attack him; if twice as numerous, to divide our army into two.",
+            "There are five essentials for victory",
+        ),
+    ),
+    (
+        r"[A-Ca-c](.*)",
+        (
+            "The art of war is of vital importance to the State.",
+            "All warfare is based on deception.",
+            "If your opponent is secure at all points, be prepared for him. If he is in superior strength, evade him.",
+            "If the campaign is protracted, the resources of the State will not be equal to the strain.",
+            "Attack him where he is unprepared, appear where you are not expected.",
+            "There is no instance of a country having benefited from prolonged warfare.",
+        ),
+    ),
+    (
+        r"[D-Fd-f](.*)",
+        (
+            "The skillful soldier does not raise a second levy, neither are his supply-wagons loaded more than twice.",
+            "Bring war material with you from home, but forage on the enemy.",
+            "In war, then, let your great object be victory, not lengthy campaigns.",
+            "To fight and conquer in all your battles is not supreme excellence; supreme excellence consists in breaking the enemy's resistance without fighting.",
+        ),
+    ),
+    (
+        r"[G-Ig-i](.*)",
+        (
+            "Heaven signifies night and day, cold and heat, times and seasons.",
+            "It is the rule in war, if our forces are ten to the enemy's one, to surround him; if five to one, to attack him; if twice as numerous, to divide our army into two.",
+            "The good fighters of old first put themselves beyond the possibility of defeat, and then waited for an opportunity of defeating the enemy.",
+            "One may know how to conquer without being able to do it.",
+        ),
+    ),
+    (
+        r"[J-Lj-l](.*)",
+        (
+            "There are three ways in which a ruler can bring misfortune upon his army.",
+            "By commanding the army to advance or to retreat, being ignorant of the fact that it cannot obey. This is called hobbling the army.",
+            "By attempting to govern an army in the same way as he administers a kingdom, being ignorant of the conditions which obtain in an army. This causes restlessness in the soldier's minds.",
+            "By employing the officers of his army without discrimination, through ignorance of the military principle of adaptation to circumstances. This shakes the confidence of the soldiers.",
+            "There are five essentials for victory",
+            "He will win who knows when to fight and when not to fight.",
+            "He will win who knows how to handle both superior and inferior forces.",
+            "He will win whose army is animated by the same spirit throughout all its ranks.",
+            "He will win who, prepared himself, waits to take the enemy unprepared.",
+            "He will win who has military capacity and is not interfered with by the sovereign.",
+        ),
+    ),
+    (
+        r"[M-Om-o](.*)",
+        (
+            "If you know the enemy and know yourself, you need not fear the result of a hundred battles.",
+            "If you know yourself but not the enemy, for every victory gained you will also suffer a defeat.",
+            "If you know neither the enemy nor yourself, you will succumb in every battle.",
+            "The control of a large force is the same principle as the control of a few men: it is merely a question of dividing up their numbers.",
+        ),
+    ),
+    (
+        r"[P-Rp-r](.*)",
+        (
+            "Security against defeat implies defensive tactics; ability to defeat the enemy means taking the offensive.",
+            "Standing on the defensive indicates insufficient strength; attacking, a superabundance of strength.",
+            "He wins his battles by making no mistakes. Making no mistakes is what establishes the certainty of victory, for it means conquering an enemy that is already defeated.",
+            "A victorious army opposed to a routed one, is as a pound's weight placed in the scale against a single grain.",
+            "The onrush of a conquering force is like the bursting of pent-up waters into a chasm a thousand fathoms deep.",
+        ),
+    ),
+    (
+        r"[S-Us-u](.*)",
+        (
+            "What the ancients called a clever fighter is one who not only wins, but excels in winning with ease.",
+            "Hence his victories bring him neither reputation for wisdom nor credit for courage.",
+            "Hence the skillful fighter puts himself into a position which makes defeat impossible, and does not miss the moment for defeating the enemy.",
+            "In war the victorious strategist only seeks battle after the victory has been won, whereas he who is destined to defeat first fights and afterwards looks for victory.",
+            "There are not more than five musical notes, yet the combinations of these five give rise to more melodies than can ever be heard.",
+            "Appear at points which the enemy must hasten to defend; march swiftly to places where you are not expected.",
+        ),
+    ),
+    (
+        r"[V-Zv-z](.*)",
+        (
+            "It is a matter of life and death, a road either to safety or to ruin.",
+            "Hold out baits to entice the enemy. Feign disorder, and crush him.",
+            "All men can see the tactics whereby I conquer, but what none can see is the strategy out of which victory is evolved.",
+            "Do not repeat the tactics which have gained you one victory, but let your methods be regulated by the infinite variety of circumstances.",
+            "So in war, the way is to avoid what is strong and to strike at what is weak.",
+            "Just as water retains no constant shape, so in warfare there are no constant conditions.",
+        ),
+    ),
+    (r"(.*)", ("Your statement insults me.", "")),
+)
+
+suntsu_chatbot = Chat(pairs, reflections)
+
+
+def suntsu_chat():
+    print("Talk to the program by typing in plain English, using normal upper-")
+    print('and lower-case letters and punctuation.  Enter "quit" when done.')
+    print("=" * 72)
+    print("You seek enlightenment?")
+
+    suntsu_chatbot.converse()
+
+
+def demo():
+    suntsu_chat()
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/chat/util.py

@@ -0,0 +1,124 @@
+# Natural Language Toolkit: Chatbot Utilities
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Authors: Steven Bird <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+# Based on an Eliza implementation by Joe Strout <[email protected]>,
+# Jeff Epler <[email protected]> and Jez Higgins <[email protected]>.
+
+import random
+import re
+
+reflections = {
+    "i am": "you are",
+    "i was": "you were",
+    "i": "you",
+    "i'm": "you are",
+    "i'd": "you would",
+    "i've": "you have",
+    "i'll": "you will",
+    "my": "your",
+    "you are": "I am",
+    "you were": "I was",
+    "you've": "I have",
+    "you'll": "I will",
+    "your": "my",
+    "yours": "mine",
+    "you": "me",
+    "me": "you",
+}
+
+
+class Chat:
+    def __init__(self, pairs, reflections={}):
+        """
+        Initialize the chatbot.  Pairs is a list of patterns and responses.  Each
+        pattern is a regular expression matching the user's statement or question,
+        e.g. r'I like (.*)'.  For each such pattern a list of possible responses
+        is given, e.g. ['Why do you like %1', 'Did you ever dislike %1'].  Material
+        which is matched by parenthesized sections of the patterns (e.g. .*) is mapped to
+        the numbered positions in the responses, e.g. %1.
+
+        :type pairs: list of tuple
+        :param pairs: The patterns and responses
+        :type reflections: dict
+        :param reflections: A mapping between first and second person expressions
+        :rtype: None
+        """
+
+        self._pairs = [(re.compile(x, re.IGNORECASE), y) for (x, y) in pairs]
+        self._reflections = reflections
+        self._regex = self._compile_reflections()
+
+    def _compile_reflections(self):
+        sorted_refl = sorted(self._reflections, key=len, reverse=True)
+        return re.compile(
+            r"\b({})\b".format("|".join(map(re.escape, sorted_refl))), re.IGNORECASE
+        )
+
+    def _substitute(self, str):
+        """
+        Substitute words in the string, according to the specified reflections,
+        e.g. "I'm" -> "you are"
+
+        :type str: str
+        :param str: The string to be mapped
+        :rtype: str
+        """
+
+        return self._regex.sub(
+            lambda mo: self._reflections[mo.string[mo.start() : mo.end()]], str.lower()
+        )
+
+    def _wildcards(self, response, match):
+        pos = response.find("%")
+        while pos >= 0:
+            num = int(response[pos + 1 : pos + 2])
+            response = (
+                response[:pos]
+                + self._substitute(match.group(num))
+                + response[pos + 2 :]
+            )
+            pos = response.find("%")
+        return response
+
+    def respond(self, str):
+        """
+        Generate a response to the user input.
+
+        :type str: str
+        :param str: The string to be mapped
+        :rtype: str
+        """
+
+        # check each pattern
+        for (pattern, response) in self._pairs:
+            match = pattern.match(str)
+
+            # did the pattern match?
+            if match:
+                resp = random.choice(response)  # pick a random response
+                resp = self._wildcards(resp, match)  # process wildcards
+
+                # fix munged punctuation at the end
+                if resp[-2:] == "?.":
+                    resp = resp[:-2] + "."
+                if resp[-2:] == "??":
+                    resp = resp[:-2] + "?"
+                return resp
+
+    # Hold a conversation with a chatbot
+    def converse(self, quit="quit"):
+        user_input = ""
+        while user_input != quit:
+            user_input = quit
+            try:
+                user_input = input(">")
+            except EOFError:
+                print(user_input)
+            if user_input:
+                while user_input[-1] in "!.":
+                    user_input = user_input[:-1]
+                print(self.respond(user_input))

llmeval-env/lib/python3.10/site-packages/nltk/chat/zen.py

@@ -0,0 +1,329 @@
+# Natural Language Toolkit: Zen Chatbot
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Amy Holland <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Zen Chatbot talks in gems of Zen wisdom.
+
+This is a sample conversation with Zen Chatbot:
+ZC:    Welcome, my child.
+me:    Good afternoon.
+ZC:    Ask the question you have come to ask.
+me:    How can I achieve enlightenment?
+ZC:    How do you suppose?
+me:    Through meditation.
+ZC:    Form is emptiness, and emptiness form.
+me:    How can I empty my mind of worldly troubles?
+ZC:    Will an answer to that really help in your search for enlightenment?
+me:    Yes.
+ZC:    It is better to be right than to be certain.
+me:    I seek truth and wisdom.
+ZC:    The search for truth is a long journey.
+me:    Are you sure?
+ZC:    Maybe sure, maybe not sure.
+
+
+The chatbot structure is based on that of chat.eliza. Thus, it uses
+a translation table to convert from question to response
+i.e. "I am" --> "you are"
+
+Of course, since Zen Chatbot does not understand the meaning of any words,
+responses are very limited. Zen Chatbot will usually answer very vaguely, or
+respond to a question by asking a different question, in much the same way
+as Eliza.
+"""
+
+from nltk.chat.util import Chat, reflections
+
+# responses are matched top to bottom, so non-specific matches occur later
+# for each match, a list of possible responses is provided
+responses = (
+    # Zen Chatbot opens with the line "Welcome, my child." The usual
+    # response will be a greeting problem: 'good' matches "good morning",
+    # "good day" etc, but also "good grief!"  and other sentences starting
+    # with the word 'good' that may not be a greeting
+    (
+        r"(hello(.*))|(good [a-zA-Z]+)",
+        (
+            "The path to enlightenment is often difficult to see.",
+            "Greetings. I sense your mind is troubled. Tell me of your troubles.",
+            "Ask the question you have come to ask.",
+            "Hello. Do you seek englightenment?",
+        ),
+    ),
+    # "I need" and "I want" can be followed by a thing (eg 'help')
+    # or an action (eg 'to see you')
+    #
+    # This is a problem with this style of response -
+    # person:    "I need you"
+    # chatbot:    "me can be achieved by hard work and dedication of the mind"
+    # i.e. 'you' is not really a thing that can be mapped this way, so this
+    # interpretation only makes sense for some inputs
+    #
+    (
+        r"i need (.*)",
+        (
+            "%1 can be achieved by hard work and dedication of the mind.",
+            "%1 is not a need, but a desire of the mind. Clear your mind of such concerns.",
+            "Focus your mind on%1, and you will find what you need.",
+        ),
+    ),
+    (
+        r"i want (.*)",
+        (
+            "Desires of the heart will distract you from the path to enlightenment.",
+            "Will%1 help you attain enlightenment?",
+            "Is%1 a desire of the mind, or of the heart?",
+        ),
+    ),
+    # why questions are separated into three types:
+    # "why..I"     e.g. "why am I here?" "Why do I like cake?"
+    # "why..you"    e.g. "why are you here?" "Why won't you tell me?"
+    # "why..."    e.g. "Why is the sky blue?"
+    # problems:
+    #     person:  "Why can't you tell me?"
+    #     chatbot: "Are you sure I tell you?"
+    # - this style works for positives (e.g. "why do you like cake?")
+    #   but does not work for negatives (e.g. "why don't you like cake?")
+    (r"why (.*) i (.*)\?", ("You%1%2?", "Perhaps you only think you%1%2")),
+    (r"why (.*) you(.*)\?", ("Why%1 you%2?", "%2 I%1", "Are you sure I%2?")),
+    (r"why (.*)\?", ("I cannot tell you why%1.", "Why do you think %1?")),
+    # e.g. "are you listening?", "are you a duck"
+    (
+        r"are you (.*)\?",
+        ("Maybe%1, maybe not%1.", "Whether I am%1 or not is God's business."),
+    ),
+    # e.g. "am I a duck?", "am I going to die?"
+    (
+        r"am i (.*)\?",
+        ("Perhaps%1, perhaps not%1.", "Whether you are%1 or not is not for me to say."),
+    ),
+    # what questions, e.g. "what time is it?"
+    # problems:
+    #     person:  "What do you want?"
+    #    chatbot: "Seek truth, not what do me want."
+    (r"what (.*)\?", ("Seek truth, not what%1.", "What%1 should not concern you.")),
+    # how questions, e.g. "how do you do?"
+    (
+        r"how (.*)\?",
+        (
+            "How do you suppose?",
+            "Will an answer to that really help in your search for enlightenment?",
+            "Ask yourself not how, but why.",
+        ),
+    ),
+    # can questions, e.g. "can you run?", "can you come over here please?"
+    (
+        r"can you (.*)\?",
+        (
+            "I probably can, but I may not.",
+            "Maybe I can%1, and maybe I cannot.",
+            "I can do all, and I can do nothing.",
+        ),
+    ),
+    # can questions, e.g. "can I have some cake?", "can I know truth?"
+    (
+        r"can i (.*)\?",
+        (
+            "You can%1 if you believe you can%1, and have a pure spirit.",
+            "Seek truth and you will know if you can%1.",
+        ),
+    ),
+    # e.g. "It is raining" - implies the speaker is certain of a fact
+    (
+        r"it is (.*)",
+        (
+            "How can you be certain that%1, when you do not even know yourself?",
+            "Whether it is%1 or not does not change the way the world is.",
+        ),
+    ),
+    # e.g. "is there a doctor in the house?"
+    (
+        r"is there (.*)\?",
+        ("There is%1 if you believe there is.", "It is possible that there is%1."),
+    ),
+    # e.g. "is it possible?", "is this true?"
+    (r"is(.*)\?", ("%1 is not relevant.", "Does this matter?")),
+    # non-specific question
+    (
+        r"(.*)\?",
+        (
+            "Do you think %1?",
+            "You seek the truth. Does the truth seek you?",
+            "If you intentionally pursue the answers to your questions, the answers become hard to see.",
+            "The answer to your question cannot be told. It must be experienced.",
+        ),
+    ),
+    # expression of hate of form "I hate you" or "Kelly hates cheese"
+    (
+        r"(.*) (hate[s]?)|(dislike[s]?)|(don\'t like)(.*)",
+        (
+            "Perhaps it is not about hating %2, but about hate from within.",
+            "Weeds only grow when we dislike them",
+            "Hate is a very strong emotion.",
+        ),
+    ),
+    # statement containing the word 'truth'
+    (
+        r"(.*) truth(.*)",
+        (
+            "Seek truth, and truth will seek you.",
+            "Remember, it is not the spoon which bends - only yourself.",
+            "The search for truth is a long journey.",
+        ),
+    ),
+    # desire to do an action
+    # e.g. "I want to go shopping"
+    (
+        r"i want to (.*)",
+        ("You may %1 if your heart truly desires to.", "You may have to %1."),
+    ),
+    # desire for an object
+    # e.g. "I want a pony"
+    (
+        r"i want (.*)",
+        (
+            "Does your heart truly desire %1?",
+            "Is this a desire of the heart, or of the mind?",
+        ),
+    ),
+    # e.g. "I can't wait" or "I can't do this"
+    (
+        r"i can\'t (.*)",
+        (
+            "What we can and can't do is a limitation of the mind.",
+            "There are limitations of the body, and limitations of the mind.",
+            "Have you tried to%1 with a clear mind?",
+        ),
+    ),
+    # "I think.." indicates uncertainty. e.g. "I think so."
+    # problem: exceptions...
+    # e.g. "I think, therefore I am"
+    (
+        r"i think (.*)",
+        (
+            "Uncertainty in an uncertain world.",
+            "Indeed, how can we be certain of anything in such uncertain times.",
+            "Are you not, in fact, certain that%1?",
+        ),
+    ),
+    # "I feel...emotions/sick/light-headed..."
+    (
+        r"i feel (.*)",
+        (
+            "Your body and your emotions are both symptoms of your mind."
+            "What do you believe is the root of such feelings?",
+            "Feeling%1 can be a sign of your state-of-mind.",
+        ),
+    ),
+    # exclaimation mark indicating emotion
+    # e.g. "Wow!" or "No!"
+    (
+        r"(.*)!",
+        (
+            "I sense that you are feeling emotional today.",
+            "You need to calm your emotions.",
+        ),
+    ),
+    # because [statement]
+    # e.g. "because I said so"
+    (
+        r"because (.*)",
+        (
+            "Does knowning the reasons behind things help you to understand"
+            " the things themselves?",
+            "If%1, what else must be true?",
+        ),
+    ),
+    # yes or no - raise an issue of certainty/correctness
+    (
+        r"(yes)|(no)",
+        (
+            "Is there certainty in an uncertain world?",
+            "It is better to be right than to be certain.",
+        ),
+    ),
+    # sentence containing word 'love'
+    (
+        r"(.*)love(.*)",
+        (
+            "Think of the trees: they let the birds perch and fly with no intention to call them when they come, and no longing for their return when they fly away. Let your heart be like the trees.",
+            "Free love!",
+        ),
+    ),
+    # sentence containing word 'understand' - r
+    (
+        r"(.*)understand(.*)",
+        (
+            "If you understand, things are just as they are;"
+            " if you do not understand, things are just as they are.",
+            "Imagination is more important than knowledge.",
+        ),
+    ),
+    # 'I', 'me', 'my' - person is talking about themself.
+    # this breaks down when words contain these - eg 'Thyme', 'Irish'
+    (
+        r"(.*)(me )|( me)|(my)|(mine)|(i)(.*)",
+        (
+            "'I', 'me', 'my'... these are selfish expressions.",
+            "Have you ever considered that you might be a selfish person?",
+            "Try to consider others, not just yourself.",
+            "Think not just of yourself, but of others.",
+        ),
+    ),
+    # 'you' starting a sentence
+    # e.g. "you stink!"
+    (
+        r"you (.*)",
+        ("My path is not of concern to you.", "I am but one, and you but one more."),
+    ),
+    # say goodbye with some extra Zen wisdom.
+    (
+        r"exit",
+        (
+            "Farewell. The obstacle is the path.",
+            "Farewell. Life is a journey, not a destination.",
+            "Good bye. We are cups, constantly and quietly being filled."
+            "\nThe trick is knowning how to tip ourselves over and let the beautiful stuff out.",
+        ),
+    ),
+    # fall through case -
+    # when stumped, respond with generic zen wisdom
+    #
+    (
+        r"(.*)",
+        (
+            "When you're enlightened, every word is wisdom.",
+            "Random talk is useless.",
+            "The reverse side also has a reverse side.",
+            "Form is emptiness, and emptiness is form.",
+            "I pour out a cup of water. Is the cup empty?",
+        ),
+    ),
+)
+
+zen_chatbot = Chat(responses, reflections)
+
+
+def zen_chat():
+    print("*" * 75)
+    print("Zen Chatbot!".center(75))
+    print("*" * 75)
+    print('"Look beyond mere words and letters - look into your mind"'.center(75))
+    print("* Talk your way to truth with Zen Chatbot.")
+    print("* Type 'quit' when you have had enough.")
+    print("*" * 75)
+    print("Welcome, my child.")
+
+    zen_chatbot.converse()
+
+
+def demo():
+    zen_chat()
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/misc/babelfish.py

@@ -0,0 +1,10 @@
+"""
+This module previously provided an interface to Babelfish online
+translation service; this service is no longer available; this
+module is kept in NLTK source code in order to provide better error
+messages for people following the NLTK Book 2.0.
+"""
+
+
+def babelize_shell():
+    print("Babelfish online translation service is no longer available.")

llmeval-env/lib/python3.10/site-packages/nltk/misc/chomsky.py

@@ -0,0 +1,134 @@
+# Chomsky random text generator, version 1.1, Raymond Hettinger, 2005/09/13
+# https://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/440546
+
+"""
+CHOMSKY is an aid to writing linguistic papers in the style
+of the great master.  It is based on selected phrases taken
+from actual books and articles written by Noam Chomsky.
+Upon request, it assembles the phrases in the elegant
+stylistic patterns that Chomsky is noted for.
+To generate n sentences of linguistic wisdom, type
+
+    (CHOMSKY n)  -- for example
+    (CHOMSKY 5) generates half a screen of linguistic truth.
+"""
+
+leadins = """To characterize a linguistic level L,
+    On the other hand,
+    This suggests that
+    It appears that
+    Furthermore,
+    We will bring evidence in favor of the following thesis:
+    To provide a constituent structure for T(Z,K),
+    From C1, it follows that
+    For any transformation which is sufficiently diversified in \
+application to be of any interest,
+    Analogously,
+    Clearly,
+    Note that
+    Of course,
+    Suppose, for instance, that
+    Thus
+    With this clarification,
+    Conversely,
+    We have already seen that
+    By combining adjunctions and certain deformations,
+    I suggested that these results would follow from the assumption that
+    If the position of the trace in (99c) were only relatively \
+inaccessible to movement,
+    However, this assumption is not correct, since
+    Comparing these examples with their parasitic gap counterparts in \
+(96) and (97), we see that
+    In the discussion of resumptive pronouns following (81),
+    So far,
+    Nevertheless,
+    For one thing,
+    Summarizing, then, we assume that
+    A consequence of the approach just outlined is that
+    Presumably,
+    On our assumptions,
+    It may be, then, that
+    It must be emphasized, once again, that
+    Let us continue to suppose that
+    Notice, incidentally, that """
+# List of LEADINs to buy time.
+
+subjects = """ the notion of level of grammaticalness
+    a case of semigrammaticalness of a different sort
+    most of the methodological work in modern linguistics
+    a subset of English sentences interesting on quite independent grounds
+    the natural general principle that will subsume this case
+    an important property of these three types of EC
+    any associated supporting element
+    the appearance of parasitic gaps in domains relatively inaccessible \
+to ordinary extraction
+    the speaker-hearer's linguistic intuition
+    the descriptive power of the base component
+    the earlier discussion of deviance
+    this analysis of a formative as a pair of sets of features
+    this selectionally introduced contextual feature
+    a descriptively adequate grammar
+    the fundamental error of regarding functional notions as categorial
+    relational information
+    the systematic use of complex symbols
+    the theory of syntactic features developed earlier"""
+# List of SUBJECTs chosen for maximum professorial macho.
+
+verbs = """can be defined in such a way as to impose
+    delimits
+    suffices to account for
+    cannot be arbitrary in
+    is not subject to
+    does not readily tolerate
+    raises serious doubts about
+    is not quite equivalent to
+    does not affect the structure of
+    may remedy and, at the same time, eliminate
+    is not to be considered in determining
+    is to be regarded as
+    is unspecified with respect to
+    is, apparently, determined by
+    is necessary to impose an interpretation on
+    appears to correlate rather closely with
+    is rather different from"""
+# List of VERBs chosen for autorecursive obfuscation.
+
+objects = """ problems of phonemic and morphological analysis.
+    a corpus of utterance tokens upon which conformity has been defined \
+by the paired utterance test.
+    the traditional practice of grammarians.
+    the levels of acceptability from fairly high (e.g. (99a)) to virtual \
+gibberish (e.g. (98d)).
+    a stipulation to place the constructions into these various categories.
+    a descriptive fact.
+    a parasitic gap construction.
+    the extended c-command discussed in connection with (34).
+    the ultimate standard that determines the accuracy of any proposed grammar.
+    the system of base rules exclusive of the lexicon.
+    irrelevant intervening contexts in selectional rules.
+    nondistinctness in the sense of distinctive feature theory.
+    a general convention regarding the forms of the grammar.
+    an abstract underlying order.
+    an important distinction in language use.
+    the requirement that branching is not tolerated within the dominance \
+scope of a complex symbol.
+    the strong generative capacity of the theory."""
+# List of OBJECTs selected for profound sententiousness.
+
+import random
+import textwrap
+from itertools import chain, islice
+
+
+def generate_chomsky(times=5, line_length=72):
+    parts = []
+    for part in (leadins, subjects, verbs, objects):
+        phraselist = list(map(str.strip, part.splitlines()))
+        random.shuffle(phraselist)
+        parts.append(phraselist)
+    output = chain.from_iterable(islice(zip(*parts), 0, times))
+    print(textwrap.fill(" ".join(output), line_length))
+
+
+if __name__ == "__main__":
+    generate_chomsky()

llmeval-env/lib/python3.10/site-packages/nltk/misc/minimalset.py

@@ -0,0 +1,85 @@
+# Natural Language Toolkit: Minimal Sets
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+from collections import defaultdict
+
+
+class MinimalSet:
+    """
+    Find contexts where more than one possible target value can
+    appear.  E.g. if targets are word-initial letters, and contexts
+    are the remainders of words, then we would like to find cases like
+    "fat" vs "cat", and "training" vs "draining".  If targets are
+    parts-of-speech and contexts are words, then we would like to find
+    cases like wind (noun) 'air in rapid motion', vs wind (verb)
+    'coil, wrap'.
+    """
+
+    def __init__(self, parameters=None):
+        """
+        Create a new minimal set.
+
+        :param parameters: The (context, target, display) tuples for the item
+        :type parameters: list(tuple(str, str, str))
+        """
+        self._targets = set()  # the contrastive information
+        self._contexts = set()  # what we are controlling for
+        self._seen = defaultdict(set)  # to record what we have seen
+        self._displays = {}  # what we will display
+
+        if parameters:
+            for context, target, display in parameters:
+                self.add(context, target, display)
+
+    def add(self, context, target, display):
+        """
+        Add a new item to the minimal set, having the specified
+        context, target, and display form.
+
+        :param context: The context in which the item of interest appears
+        :type context: str
+        :param target: The item of interest
+        :type target: str
+        :param display: The information to be reported for each item
+        :type display: str
+        """
+        # Store the set of targets that occurred in this context
+        self._seen[context].add(target)
+
+        # Keep track of which contexts and targets we have seen
+        self._contexts.add(context)
+        self._targets.add(target)
+
+        # For a given context and target, store the display form
+        self._displays[(context, target)] = display
+
+    def contexts(self, minimum=2):
+        """
+        Determine which contexts occurred with enough distinct targets.
+
+        :param minimum: the minimum number of distinct target forms
+        :type minimum: int
+        :rtype: list
+        """
+        return [c for c in self._contexts if len(self._seen[c]) >= minimum]
+
+    def display(self, context, target, default=""):
+        if (context, target) in self._displays:
+            return self._displays[(context, target)]
+        else:
+            return default
+
+    def display_all(self, context):
+        result = []
+        for target in self._targets:
+            x = self.display(context, target)
+            if x:
+                result.append(x)
+        return result
+
+    def targets(self):
+        return self._targets

llmeval-env/lib/python3.10/site-packages/nltk/sem/__init__.py

@@ -0,0 +1,75 @@
+# Natural Language Toolkit: Semantic Interpretation
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Ewan Klein <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+NLTK Semantic Interpretation Package
+
+This package contains classes for representing semantic structure in
+formulas of first-order logic and for evaluating such formulas in
+set-theoretic models.
+
+    >>> from nltk.sem import logic
+    >>> logic._counter._value = 0
+
+The package has two main components:
+
+ - ``logic`` provides support for analyzing expressions of First
+   Order Logic (FOL).
+ - ``evaluate`` allows users to recursively determine truth in a
+   model for formulas of FOL.
+
+A model consists of a domain of discourse and a valuation function,
+which assigns values to non-logical constants. We assume that entities
+in the domain are represented as strings such as ``'b1'``, ``'g1'``,
+etc. A ``Valuation`` is initialized with a list of (symbol, value)
+pairs, where values are entities, sets of entities or sets of tuples
+of entities.
+The domain of discourse can be inferred from the valuation, and model
+is then created with domain and valuation as parameters.
+
+    >>> 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)
+"""
+
+from nltk.sem.boxer import Boxer
+from nltk.sem.drt import DRS, DrtExpression
+from nltk.sem.evaluate import (
+    Assignment,
+    Model,
+    Undefined,
+    Valuation,
+    arity,
+    is_rel,
+    read_valuation,
+    set2rel,
+)
+from nltk.sem.lfg import FStructure
+from nltk.sem.logic import (
+    ApplicationExpression,
+    Expression,
+    LogicalExpressionException,
+    Variable,
+    binding_ops,
+    boolean_ops,
+    equality_preds,
+    read_logic,
+)
+from nltk.sem.relextract import clause, extract_rels, rtuple
+from nltk.sem.skolemize import skolemize
+from nltk.sem.util import evaluate_sents, interpret_sents, parse_sents, root_semrep
+
+# from nltk.sem.glue import Glue
+# from nltk.sem.hole import HoleSemantics
+# from nltk.sem.cooper_storage import CooperStore
+
+# don't import chat80 as its names are too generic

llmeval-env/lib/python3.10/site-packages/nltk/sem/boxer.py

@@ -0,0 +1,1605 @@
+# Natural Language Toolkit: Interface to Boxer
+# <http://svn.ask.it.usyd.edu.au/trac/candc/wiki/boxer>
+#
+# Author: Dan Garrette <[email protected]>
+#
+# Copyright (C) 2001-2023 NLTK Project
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+An interface to Boxer.
+
+This interface relies on the latest version of the development (subversion) version of
+C&C and Boxer.
+
+Usage
+=====
+
+Set the environment variable CANDC to the bin directory of your CandC installation.
+The models directory should be in the CandC root directory.
+For example::
+
+    /path/to/candc/
+    bin/
+        candc
+        boxer
+    models/
+        boxer/
+"""
+
+import operator
+import os
+import re
+import subprocess
+import tempfile
+from functools import reduce
+from optparse import OptionParser
+
+from nltk.internals import find_binary
+from nltk.sem.drt import (
+    DRS,
+    DrtApplicationExpression,
+    DrtEqualityExpression,
+    DrtNegatedExpression,
+    DrtOrExpression,
+    DrtParser,
+    DrtProposition,
+    DrtTokens,
+    DrtVariableExpression,
+)
+from nltk.sem.logic import (
+    ExpectedMoreTokensException,
+    LogicalExpressionException,
+    UnexpectedTokenException,
+    Variable,
+)
+
+
+class Boxer:
+    """
+    This class is an interface to Johan Bos's program Boxer, a wide-coverage
+    semantic parser that produces Discourse Representation Structures (DRSs).
+    """
+
+    def __init__(
+        self,
+        boxer_drs_interpreter=None,
+        elimeq=False,
+        bin_dir=None,
+        verbose=False,
+        resolve=True,
+    ):
+        """
+        :param boxer_drs_interpreter: A class that converts from the
+            ``AbstractBoxerDrs`` object hierarchy to a different object.  The
+            default is ``NltkDrtBoxerDrsInterpreter``, which converts to the NLTK
+            DRT hierarchy.
+        :param elimeq: When set to true, Boxer removes all equalities from the
+            DRSs and discourse referents standing in the equality relation are
+            unified, but only if this can be done in a meaning-preserving manner.
+        :param resolve: When set to true, Boxer will resolve all anaphoric DRSs and perform merge-reduction.
+            Resolution follows Van der Sandt's theory of binding and accommodation.
+        """
+        if boxer_drs_interpreter is None:
+            boxer_drs_interpreter = NltkDrtBoxerDrsInterpreter()
+        self._boxer_drs_interpreter = boxer_drs_interpreter
+
+        self._resolve = resolve
+        self._elimeq = elimeq
+
+        self.set_bin_dir(bin_dir, verbose)
+
+    def set_bin_dir(self, bin_dir, verbose=False):
+        self._candc_bin = self._find_binary("candc", bin_dir, verbose)
+        self._candc_models_path = os.path.normpath(
+            os.path.join(self._candc_bin[:-5], "../models")
+        )
+        self._boxer_bin = self._find_binary("boxer", bin_dir, verbose)
+
+    def interpret(self, input, discourse_id=None, question=False, verbose=False):
+        """
+        Use Boxer to give a first order representation.
+
+        :param input: str Input sentence to parse
+        :param occur_index: bool Should predicates be occurrence indexed?
+        :param discourse_id: str An identifier to be inserted to each occurrence-indexed predicate.
+        :return: ``drt.DrtExpression``
+        """
+        discourse_ids = [discourse_id] if discourse_id is not None else None
+        (d,) = self.interpret_multi_sents([[input]], discourse_ids, question, verbose)
+        if not d:
+            raise Exception(f'Unable to interpret: "{input}"')
+        return d
+
+    def interpret_multi(self, input, discourse_id=None, question=False, verbose=False):
+        """
+        Use Boxer to give a first order representation.
+
+        :param input: list of str Input sentences to parse as a single discourse
+        :param occur_index: bool Should predicates be occurrence indexed?
+        :param discourse_id: str An identifier to be inserted to each occurrence-indexed predicate.
+        :return: ``drt.DrtExpression``
+        """
+        discourse_ids = [discourse_id] if discourse_id is not None else None
+        (d,) = self.interpret_multi_sents([input], discourse_ids, question, verbose)
+        if not d:
+            raise Exception(f'Unable to interpret: "{input}"')
+        return d
+
+    def interpret_sents(
+        self, inputs, discourse_ids=None, question=False, verbose=False
+    ):
+        """
+        Use Boxer to give a first order representation.
+
+        :param inputs: list of str Input sentences to parse as individual discourses
+        :param occur_index: bool Should predicates be occurrence indexed?
+        :param discourse_ids: list of str Identifiers to be inserted to each occurrence-indexed predicate.
+        :return: list of ``drt.DrtExpression``
+        """
+        return self.interpret_multi_sents(
+            [[input] for input in inputs], discourse_ids, question, verbose
+        )
+
+    def interpret_multi_sents(
+        self, inputs, discourse_ids=None, question=False, verbose=False
+    ):
+        """
+        Use Boxer to give a first order representation.
+
+        :param inputs: list of list of str Input discourses to parse
+        :param occur_index: bool Should predicates be occurrence indexed?
+        :param discourse_ids: list of str Identifiers to be inserted to each occurrence-indexed predicate.
+        :return: ``drt.DrtExpression``
+        """
+        if discourse_ids is not None:
+            assert len(inputs) == len(discourse_ids)
+            assert reduce(operator.and_, (id is not None for id in discourse_ids))
+            use_disc_id = True
+        else:
+            discourse_ids = list(map(str, range(len(inputs))))
+            use_disc_id = False
+
+        candc_out = self._call_candc(inputs, discourse_ids, question, verbose=verbose)
+        boxer_out = self._call_boxer(candc_out, verbose=verbose)
+
+        #        if 'ERROR: input file contains no ccg/2 terms.' in boxer_out:
+        #            raise UnparseableInputException('Could not parse with candc: "%s"' % input_str)
+
+        drs_dict = self._parse_to_drs_dict(boxer_out, use_disc_id)
+        return [drs_dict.get(id, None) for id in discourse_ids]
+
+    def _call_candc(self, inputs, discourse_ids, question, verbose=False):
+        """
+        Call the ``candc`` binary with the given input.
+
+        :param inputs: list of list of str Input discourses to parse
+        :param discourse_ids: list of str Identifiers to be inserted to each occurrence-indexed predicate.
+        :param filename: str A filename for the output file
+        :return: stdout
+        """
+        args = [
+            "--models",
+            os.path.join(self._candc_models_path, ["boxer", "questions"][question]),
+            "--candc-printer",
+            "boxer",
+        ]
+        return self._call(
+            "\n".join(
+                sum(
+                    ([f"<META>'{id}'"] + d for d, id in zip(inputs, discourse_ids)),
+                    [],
+                )
+            ),
+            self._candc_bin,
+            args,
+            verbose,
+        )
+
+    def _call_boxer(self, candc_out, verbose=False):
+        """
+        Call the ``boxer`` binary with the given input.
+
+        :param candc_out: str output from C&C parser
+        :return: stdout
+        """
+        f = None
+        try:
+            fd, temp_filename = tempfile.mkstemp(
+                prefix="boxer-", suffix=".in", text=True
+            )
+            f = os.fdopen(fd, "w")
+            f.write(candc_out.decode("utf-8"))
+        finally:
+            if f:
+                f.close()
+
+        args = [
+            "--box",
+            "false",
+            "--semantics",
+            "drs",
+            #'--flat', 'false', # removed from boxer
+            "--resolve",
+            ["false", "true"][self._resolve],
+            "--elimeq",
+            ["false", "true"][self._elimeq],
+            "--format",
+            "prolog",
+            "--instantiate",
+            "true",
+            "--input",
+            temp_filename,
+        ]
+        stdout = self._call(None, self._boxer_bin, args, verbose)
+        os.remove(temp_filename)
+        return stdout
+
+    def _find_binary(self, name, bin_dir, verbose=False):
+        return find_binary(
+            name,
+            path_to_bin=bin_dir,
+            env_vars=["CANDC"],
+            url="http://svn.ask.it.usyd.edu.au/trac/candc/",
+            binary_names=[name, name + ".exe"],
+            verbose=verbose,
+        )
+
+    def _call(self, input_str, binary, args=[], verbose=False):
+        """
+        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: stdout
+        """
+        if verbose:
+            print("Calling:", binary)
+            print("Args:", args)
+            print("Input:", input_str)
+            print("Command:", binary + " " + " ".join(args))
+
+        # Call via a subprocess
+        if input_str is None:
+            cmd = [binary] + args
+            p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        else:
+            cmd = 'echo "{}" | {} {}'.format(input_str, binary, " ".join(args))
+            p = subprocess.Popen(
+                cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True
+            )
+        stdout, stderr = p.communicate()
+
+        if verbose:
+            print("Return code:", p.returncode)
+            if stdout:
+                print("stdout:\n", stdout, "\n")
+            if stderr:
+                print("stderr:\n", stderr, "\n")
+        if p.returncode != 0:
+            raise Exception(
+                "ERROR CALLING: {} {}\nReturncode: {}\n{}".format(
+                    binary, " ".join(args), p.returncode, stderr
+                )
+            )
+
+        return stdout
+
+    def _parse_to_drs_dict(self, boxer_out, use_disc_id):
+        lines = boxer_out.decode("utf-8").split("\n")
+        drs_dict = {}
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            if line.startswith("id("):
+                comma_idx = line.index(",")
+                discourse_id = line[3:comma_idx]
+                if discourse_id[0] == "'" and discourse_id[-1] == "'":
+                    discourse_id = discourse_id[1:-1]
+                drs_id = line[comma_idx + 1 : line.index(")")]
+                i += 1
+                line = lines[i]
+                assert line.startswith(f"sem({drs_id},")
+                if line[-4:] == "').'":
+                    line = line[:-4] + ")."
+                assert line.endswith(")."), f"can't parse line: {line}"
+
+                search_start = len(f"sem({drs_id},[")
+                brace_count = 1
+                drs_start = -1
+                for j, c in enumerate(line[search_start:]):
+                    if c == "[":
+                        brace_count += 1
+                    if c == "]":
+                        brace_count -= 1
+                        if brace_count == 0:
+                            drs_start = search_start + j + 1
+                            if line[drs_start : drs_start + 3] == "','":
+                                drs_start = drs_start + 3
+                            else:
+                                drs_start = drs_start + 1
+                            break
+                assert drs_start > -1
+
+                drs_input = line[drs_start:-2].strip()
+                parsed = self._parse_drs(drs_input, discourse_id, use_disc_id)
+                drs_dict[discourse_id] = self._boxer_drs_interpreter.interpret(parsed)
+            i += 1
+        return drs_dict
+
+    def _parse_drs(self, drs_string, discourse_id, use_disc_id):
+        return BoxerOutputDrsParser([None, discourse_id][use_disc_id]).parse(drs_string)
+
+
+class BoxerOutputDrsParser(DrtParser):
+    def __init__(self, discourse_id=None):
+        """
+        This class is used to parse the Prolog DRS output from Boxer into a
+        hierarchy of python objects.
+        """
+        DrtParser.__init__(self)
+        self.discourse_id = discourse_id
+        self.sentence_id_offset = None
+        self.quote_chars = [("'", "'", "\\", False)]
+
+    def parse(self, data, signature=None):
+        return DrtParser.parse(self, data, signature)
+
+    def get_all_symbols(self):
+        return ["(", ")", ",", "[", "]", ":"]
+
+    def handle(self, tok, context):
+        return self.handle_drs(tok)
+
+    def attempt_adjuncts(self, expression, context):
+        return expression
+
+    def parse_condition(self, indices):
+        """
+        Parse a DRS condition
+
+        :return: list of ``DrtExpression``
+        """
+        tok = self.token()
+        accum = self.handle_condition(tok, indices)
+        if accum is None:
+            raise UnexpectedTokenException(tok)
+        return accum
+
+    def handle_drs(self, tok):
+        if tok == "drs":
+            return self.parse_drs()
+        elif tok in ["merge", "smerge"]:
+            return self._handle_binary_expression(self._make_merge_expression)(None, [])
+        elif tok in ["alfa"]:
+            return self._handle_alfa(self._make_merge_expression)(None, [])
+
+    def handle_condition(self, tok, indices):
+        """
+        Handle a DRS condition
+
+        :param indices: list of int
+        :return: list of ``DrtExpression``
+        """
+        if tok == "not":
+            return [self._handle_not()]
+
+        if tok == "or":
+            conds = [self._handle_binary_expression(self._make_or_expression)]
+        elif tok == "imp":
+            conds = [self._handle_binary_expression(self._make_imp_expression)]
+        elif tok == "eq":
+            conds = [self._handle_eq()]
+        elif tok == "prop":
+            conds = [self._handle_prop()]
+
+        elif tok == "pred":
+            conds = [self._handle_pred()]
+        elif tok == "named":
+            conds = [self._handle_named()]
+        elif tok == "rel":
+            conds = [self._handle_rel()]
+        elif tok == "timex":
+            conds = self._handle_timex()
+        elif tok == "card":
+            conds = [self._handle_card()]
+
+        elif tok == "whq":
+            conds = [self._handle_whq()]
+        elif tok == "duplex":
+            conds = [self._handle_duplex()]
+
+        else:
+            conds = []
+
+        return sum(
+            (
+                [cond(sent_index, word_indices) for cond in conds]
+                for sent_index, word_indices in self._sent_and_word_indices(indices)
+            ),
+            [],
+        )
+
+    def _handle_not(self):
+        self.assertToken(self.token(), "(")
+        drs = self.process_next_expression(None)
+        self.assertToken(self.token(), ")")
+        return BoxerNot(drs)
+
+    def _handle_pred(self):
+        # pred(_G3943, dog, n, 0)
+        self.assertToken(self.token(), "(")
+        variable = self.parse_variable()
+        self.assertToken(self.token(), ",")
+        name = self.token()
+        self.assertToken(self.token(), ",")
+        pos = self.token()
+        self.assertToken(self.token(), ",")
+        sense = int(self.token())
+        self.assertToken(self.token(), ")")
+
+        def _handle_pred_f(sent_index, word_indices):
+            return BoxerPred(
+                self.discourse_id, sent_index, word_indices, variable, name, pos, sense
+            )
+
+        return _handle_pred_f
+
+    def _handle_duplex(self):
+        # duplex(whq, drs(...), var, drs(...))
+        self.assertToken(self.token(), "(")
+        # self.assertToken(self.token(), '[')
+        ans_types = []
+        # while self.token(0) != ']':
+        #     cat = self.token()
+        #     self.assertToken(self.token(), ':')
+        #     if cat == 'des':
+        #         ans_types.append(self.token())
+        #     elif cat == 'num':
+        #         ans_types.append('number')
+        #         typ = self.token()
+        #         if typ == 'cou':
+        #             ans_types.append('count')
+        #         else:
+        #             ans_types.append(typ)
+        #     else:
+        #         ans_types.append(self.token())
+        # self.token() #swallow the ']'
+
+        self.assertToken(self.token(), "whq")
+        self.assertToken(self.token(), ",")
+        d1 = self.process_next_expression(None)
+        self.assertToken(self.token(), ",")
+        ref = self.parse_variable()
+        self.assertToken(self.token(), ",")
+        d2 = self.process_next_expression(None)
+        self.assertToken(self.token(), ")")
+        return lambda sent_index, word_indices: BoxerWhq(
+            self.discourse_id, sent_index, word_indices, ans_types, d1, ref, d2
+        )
+
+    def _handle_named(self):
+        # named(x0, john, per, 0)
+        self.assertToken(self.token(), "(")
+        variable = self.parse_variable()
+        self.assertToken(self.token(), ",")
+        name = self.token()
+        self.assertToken(self.token(), ",")
+        type = self.token()
+        self.assertToken(self.token(), ",")
+        sense = self.token()  # as per boxer rev 2554
+        self.assertToken(self.token(), ")")
+        return lambda sent_index, word_indices: BoxerNamed(
+            self.discourse_id, sent_index, word_indices, variable, name, type, sense
+        )
+
+    def _handle_rel(self):
+        # rel(_G3993, _G3943, agent, 0)
+        self.assertToken(self.token(), "(")
+        var1 = self.parse_variable()
+        self.assertToken(self.token(), ",")
+        var2 = self.parse_variable()
+        self.assertToken(self.token(), ",")
+        rel = self.token()
+        self.assertToken(self.token(), ",")
+        sense = int(self.token())
+        self.assertToken(self.token(), ")")
+        return lambda sent_index, word_indices: BoxerRel(
+            self.discourse_id, sent_index, word_indices, var1, var2, rel, sense
+        )
+
+    def _handle_timex(self):
+        # timex(_G18322, date([]: (+), []:'XXXX', [1004]:'04', []:'XX'))
+        self.assertToken(self.token(), "(")
+        arg = self.parse_variable()
+        self.assertToken(self.token(), ",")
+        new_conds = self._handle_time_expression(arg)
+        self.assertToken(self.token(), ")")
+        return new_conds
+
+    def _handle_time_expression(self, arg):
+        # date([]: (+), []:'XXXX', [1004]:'04', []:'XX')
+        tok = self.token()
+        self.assertToken(self.token(), "(")
+        if tok == "date":
+            conds = self._handle_date(arg)
+        elif tok == "time":
+            conds = self._handle_time(arg)
+        else:
+            return None
+        self.assertToken(self.token(), ")")
+        return [
+            lambda sent_index, word_indices: BoxerPred(
+                self.discourse_id, sent_index, word_indices, arg, tok, "n", 0
+            )
+        ] + [lambda sent_index, word_indices: cond for cond in conds]
+
+    def _handle_date(self, arg):
+        # []: (+), []:'XXXX', [1004]:'04', []:'XX'
+        conds = []
+        ((sent_index, word_indices),) = self._sent_and_word_indices(
+            self._parse_index_list()
+        )
+        self.assertToken(self.token(), "(")
+        pol = self.token()
+        self.assertToken(self.token(), ")")
+        conds.append(
+            BoxerPred(
+                self.discourse_id,
+                sent_index,
+                word_indices,
+                arg,
+                f"date_pol_{pol}",
+                "a",
+                0,
+            )
+        )
+        self.assertToken(self.token(), ",")
+
+        ((sent_index, word_indices),) = self._sent_and_word_indices(
+            self._parse_index_list()
+        )
+        year = self.token()
+        if year != "XXXX":
+            year = year.replace(":", "_")
+            conds.append(
+                BoxerPred(
+                    self.discourse_id,
+                    sent_index,
+                    word_indices,
+                    arg,
+                    f"date_year_{year}",
+                    "a",
+                    0,
+                )
+            )
+        self.assertToken(self.token(), ",")
+
+        ((sent_index, word_indices),) = self._sent_and_word_indices(
+            self._parse_index_list()
+        )
+        month = self.token()
+        if month != "XX":
+            conds.append(
+                BoxerPred(
+                    self.discourse_id,
+                    sent_index,
+                    word_indices,
+                    arg,
+                    f"date_month_{month}",
+                    "a",
+                    0,
+                )
+            )
+        self.assertToken(self.token(), ",")
+
+        ((sent_index, word_indices),) = self._sent_and_word_indices(
+            self._parse_index_list()
+        )
+        day = self.token()
+        if day != "XX":
+            conds.append(
+                BoxerPred(
+                    self.discourse_id,
+                    sent_index,
+                    word_indices,
+                    arg,
+                    f"date_day_{day}",
+                    "a",
+                    0,
+                )
+            )
+
+        return conds
+
+    def _handle_time(self, arg):
+        # time([1018]:'18', []:'XX', []:'XX')
+        conds = []
+        self._parse_index_list()
+        hour = self.token()
+        if hour != "XX":
+            conds.append(self._make_atom("r_hour_2", arg, hour))
+        self.assertToken(self.token(), ",")
+
+        self._parse_index_list()
+        min = self.token()
+        if min != "XX":
+            conds.append(self._make_atom("r_min_2", arg, min))
+        self.assertToken(self.token(), ",")
+
+        self._parse_index_list()
+        sec = self.token()
+        if sec != "XX":
+            conds.append(self._make_atom("r_sec_2", arg, sec))
+
+        return conds
+
+    def _handle_card(self):
+        # card(_G18535, 28, ge)
+        self.assertToken(self.token(), "(")
+        variable = self.parse_variable()
+        self.assertToken(self.token(), ",")
+        value = self.token()
+        self.assertToken(self.token(), ",")
+        type = self.token()
+        self.assertToken(self.token(), ")")
+        return lambda sent_index, word_indices: BoxerCard(
+            self.discourse_id, sent_index, word_indices, variable, value, type
+        )
+
+    def _handle_prop(self):
+        # prop(_G15949, drs(...))
+        self.assertToken(self.token(), "(")
+        variable = self.parse_variable()
+        self.assertToken(self.token(), ",")
+        drs = self.process_next_expression(None)
+        self.assertToken(self.token(), ")")
+        return lambda sent_index, word_indices: BoxerProp(
+            self.discourse_id, sent_index, word_indices, variable, drs
+        )
+
+    def _parse_index_list(self):
+        # [1001,1002]:
+        indices = []
+        self.assertToken(self.token(), "[")
+        while self.token(0) != "]":
+            indices.append(self.parse_index())
+            if self.token(0) == ",":
+                self.token()  # swallow ','
+        self.token()  # swallow ']'
+        self.assertToken(self.token(), ":")
+        return indices
+
+    def parse_drs(self):
+        # drs([[1001]:_G3943],
+        #    [[1002]:pred(_G3943, dog, n, 0)]
+        #   )
+        self.assertToken(self.token(), "(")
+        self.assertToken(self.token(), "[")
+        refs = set()
+        while self.token(0) != "]":
+            indices = self._parse_index_list()
+            refs.add(self.parse_variable())
+            if self.token(0) == ",":
+                self.token()  # swallow ','
+        self.token()  # swallow ']'
+        self.assertToken(self.token(), ",")
+        self.assertToken(self.token(), "[")
+        conds = []
+        while self.token(0) != "]":
+            indices = self._parse_index_list()
+            conds.extend(self.parse_condition(indices))
+            if self.token(0) == ",":
+                self.token()  # swallow ','
+        self.token()  # swallow ']'
+        self.assertToken(self.token(), ")")
+        return BoxerDrs(list(refs), conds)
+
+    def _handle_binary_expression(self, make_callback):
+        self.assertToken(self.token(), "(")
+        drs1 = self.process_next_expression(None)
+        self.assertToken(self.token(), ",")
+        drs2 = self.process_next_expression(None)
+        self.assertToken(self.token(), ")")
+        return lambda sent_index, word_indices: make_callback(
+            sent_index, word_indices, drs1, drs2
+        )
+
+    def _handle_alfa(self, make_callback):
+        self.assertToken(self.token(), "(")
+        type = self.token()
+        self.assertToken(self.token(), ",")
+        drs1 = self.process_next_expression(None)
+        self.assertToken(self.token(), ",")
+        drs2 = self.process_next_expression(None)
+        self.assertToken(self.token(), ")")
+        return lambda sent_index, word_indices: make_callback(
+            sent_index, word_indices, drs1, drs2
+        )
+
+    def _handle_eq(self):
+        self.assertToken(self.token(), "(")
+        var1 = self.parse_variable()
+        self.assertToken(self.token(), ",")
+        var2 = self.parse_variable()
+        self.assertToken(self.token(), ")")
+        return lambda sent_index, word_indices: BoxerEq(
+            self.discourse_id, sent_index, word_indices, var1, var2
+        )
+
+    def _handle_whq(self):
+        self.assertToken(self.token(), "(")
+        self.assertToken(self.token(), "[")
+        ans_types = []
+        while self.token(0) != "]":
+            cat = self.token()
+            self.assertToken(self.token(), ":")
+            if cat == "des":
+                ans_types.append(self.token())
+            elif cat == "num":
+                ans_types.append("number")
+                typ = self.token()
+                if typ == "cou":
+                    ans_types.append("count")
+                else:
+                    ans_types.append(typ)
+            else:
+                ans_types.append(self.token())
+        self.token()  # swallow the ']'
+
+        self.assertToken(self.token(), ",")
+        d1 = self.process_next_expression(None)
+        self.assertToken(self.token(), ",")
+        ref = self.parse_variable()
+        self.assertToken(self.token(), ",")
+        d2 = self.process_next_expression(None)
+        self.assertToken(self.token(), ")")
+        return lambda sent_index, word_indices: BoxerWhq(
+            self.discourse_id, sent_index, word_indices, ans_types, d1, ref, d2
+        )
+
+    def _make_merge_expression(self, sent_index, word_indices, drs1, drs2):
+        return BoxerDrs(drs1.refs + drs2.refs, drs1.conds + drs2.conds)
+
+    def _make_or_expression(self, sent_index, word_indices, drs1, drs2):
+        return BoxerOr(self.discourse_id, sent_index, word_indices, drs1, drs2)
+
+    def _make_imp_expression(self, sent_index, word_indices, drs1, drs2):
+        return BoxerDrs(drs1.refs, drs1.conds, drs2)
+
+    def parse_variable(self):
+        var = self.token()
+        assert re.match(r"^[exps]\d+$", var), var
+        return var
+
+    def parse_index(self):
+        return int(self.token())
+
+    def _sent_and_word_indices(self, indices):
+        """
+        :return: list of (sent_index, word_indices) tuples
+        """
+        sent_indices = {(i / 1000) - 1 for i in indices if i >= 0}
+        if sent_indices:
+            pairs = []
+            for sent_index in sent_indices:
+                word_indices = [
+                    (i % 1000) - 1 for i in indices if sent_index == (i / 1000) - 1
+                ]
+                pairs.append((sent_index, word_indices))
+            return pairs
+        else:
+            word_indices = [(i % 1000) - 1 for i in indices]
+            return [(None, word_indices)]
+
+
+class BoxerDrsParser(DrtParser):
+    """
+    Reparse the str form of subclasses of ``AbstractBoxerDrs``
+    """
+
+    def __init__(self, discourse_id=None):
+        DrtParser.__init__(self)
+        self.discourse_id = discourse_id
+
+    def get_all_symbols(self):
+        return [
+            DrtTokens.OPEN,
+            DrtTokens.CLOSE,
+            DrtTokens.COMMA,
+            DrtTokens.OPEN_BRACKET,
+            DrtTokens.CLOSE_BRACKET,
+        ]
+
+    def attempt_adjuncts(self, expression, context):
+        return expression
+
+    def handle(self, tok, context):
+        try:
+            #             if tok == 'drs':
+            #                 self.assertNextToken(DrtTokens.OPEN)
+            #                 label = int(self.token())
+            #                 self.assertNextToken(DrtTokens.COMMA)
+            #                 refs = list(map(int, self.handle_refs()))
+            #                 self.assertNextToken(DrtTokens.COMMA)
+            #                 conds = self.handle_conds(None)
+            #                 self.assertNextToken(DrtTokens.CLOSE)
+            #                 return BoxerDrs(label, refs, conds)
+            if tok == "pred":
+                self.assertNextToken(DrtTokens.OPEN)
+                disc_id = (
+                    self.discourse_id if self.discourse_id is not None else self.token()
+                )
+                self.assertNextToken(DrtTokens.COMMA)
+                sent_id = self.nullableIntToken()
+                self.assertNextToken(DrtTokens.COMMA)
+                word_ids = list(map(int, self.handle_refs()))
+                self.assertNextToken(DrtTokens.COMMA)
+                variable = int(self.token())
+                self.assertNextToken(DrtTokens.COMMA)
+                name = self.token()
+                self.assertNextToken(DrtTokens.COMMA)
+                pos = self.token()
+                self.assertNextToken(DrtTokens.COMMA)
+                sense = int(self.token())
+                self.assertNextToken(DrtTokens.CLOSE)
+                return BoxerPred(disc_id, sent_id, word_ids, variable, name, pos, sense)
+            elif tok == "named":
+                self.assertNextToken(DrtTokens.OPEN)
+                disc_id = (
+                    self.discourse_id if self.discourse_id is not None else self.token()
+                )
+                self.assertNextToken(DrtTokens.COMMA)
+                sent_id = int(self.token())
+                self.assertNextToken(DrtTokens.COMMA)
+                word_ids = map(int, self.handle_refs())
+                self.assertNextToken(DrtTokens.COMMA)
+                variable = int(self.token())
+                self.assertNextToken(DrtTokens.COMMA)
+                name = self.token()
+                self.assertNextToken(DrtTokens.COMMA)
+                type = self.token()
+                self.assertNextToken(DrtTokens.COMMA)
+                sense = int(self.token())
+                self.assertNextToken(DrtTokens.CLOSE)
+                return BoxerNamed(
+                    disc_id, sent_id, word_ids, variable, name, type, sense
+                )
+            elif tok == "rel":
+                self.assertNextToken(DrtTokens.OPEN)
+                disc_id = (
+                    self.discourse_id if self.discourse_id is not None else self.token()
+                )
+                self.assertNextToken(DrtTokens.COMMA)
+                sent_id = self.nullableIntToken()
+                self.assertNextToken(DrtTokens.COMMA)
+                word_ids = list(map(int, self.handle_refs()))
+                self.assertNextToken(DrtTokens.COMMA)
+                var1 = int(self.token())
+                self.assertNextToken(DrtTokens.COMMA)
+                var2 = int(self.token())
+                self.assertNextToken(DrtTokens.COMMA)
+                rel = self.token()
+                self.assertNextToken(DrtTokens.COMMA)
+                sense = int(self.token())
+                self.assertNextToken(DrtTokens.CLOSE)
+                return BoxerRel(disc_id, sent_id, word_ids, var1, var2, rel, sense)
+            elif tok == "prop":
+                self.assertNextToken(DrtTokens.OPEN)
+                disc_id = (
+                    self.discourse_id if self.discourse_id is not None else self.token()
+                )
+                self.assertNextToken(DrtTokens.COMMA)
+                sent_id = int(self.token())
+                self.assertNextToken(DrtTokens.COMMA)
+                word_ids = list(map(int, self.handle_refs()))
+                self.assertNextToken(DrtTokens.COMMA)
+                variable = int(self.token())
+                self.assertNextToken(DrtTokens.COMMA)
+                drs = self.process_next_expression(None)
+                self.assertNextToken(DrtTokens.CLOSE)
+                return BoxerProp(disc_id, sent_id, word_ids, variable, drs)
+            elif tok == "not":
+                self.assertNextToken(DrtTokens.OPEN)
+                drs = self.process_next_expression(None)
+                self.assertNextToken(DrtTokens.CLOSE)
+                return BoxerNot(drs)
+            elif tok == "imp":
+                self.assertNextToken(DrtTokens.OPEN)
+                drs1 = self.process_next_expression(None)
+                self.assertNextToken(DrtTokens.COMMA)
+                drs2 = self.process_next_expression(None)
+                self.assertNextToken(DrtTokens.CLOSE)
+                return BoxerDrs(drs1.refs, drs1.conds, drs2)
+            elif tok == "or":
+                self.assertNextToken(DrtTokens.OPEN)
+                disc_id = (
+                    self.discourse_id if self.discourse_id is not None else self.token()
+                )
+                self.assertNextToken(DrtTokens.COMMA)
+                sent_id = self.nullableIntToken()
+                self.assertNextToken(DrtTokens.COMMA)
+                word_ids = map(int, self.handle_refs())
+                self.assertNextToken(DrtTokens.COMMA)
+                drs1 = self.process_next_expression(None)
+                self.assertNextToken(DrtTokens.COMMA)
+                drs2 = self.process_next_expression(None)
+                self.assertNextToken(DrtTokens.CLOSE)
+                return BoxerOr(disc_id, sent_id, word_ids, drs1, drs2)
+            elif tok == "eq":
+                self.assertNextToken(DrtTokens.OPEN)
+                disc_id = (
+                    self.discourse_id if self.discourse_id is not None else self.token()
+                )
+                self.assertNextToken(DrtTokens.COMMA)
+                sent_id = self.nullableIntToken()
+                self.assertNextToken(DrtTokens.COMMA)
+                word_ids = list(map(int, self.handle_refs()))
+                self.assertNextToken(DrtTokens.COMMA)
+                var1 = int(self.token())
+                self.assertNextToken(DrtTokens.COMMA)
+                var2 = int(self.token())
+                self.assertNextToken(DrtTokens.CLOSE)
+                return BoxerEq(disc_id, sent_id, word_ids, var1, var2)
+            elif tok == "card":
+                self.assertNextToken(DrtTokens.OPEN)
+                disc_id = (
+                    self.discourse_id if self.discourse_id is not None else self.token()
+                )
+                self.assertNextToken(DrtTokens.COMMA)
+                sent_id = self.nullableIntToken()
+                self.assertNextToken(DrtTokens.COMMA)
+                word_ids = map(int, self.handle_refs())
+                self.assertNextToken(DrtTokens.COMMA)
+                var = int(self.token())
+                self.assertNextToken(DrtTokens.COMMA)
+                value = self.token()
+                self.assertNextToken(DrtTokens.COMMA)
+                type = self.token()
+                self.assertNextToken(DrtTokens.CLOSE)
+                return BoxerCard(disc_id, sent_id, word_ids, var, value, type)
+            elif tok == "whq":
+                self.assertNextToken(DrtTokens.OPEN)
+                disc_id = (
+                    self.discourse_id if self.discourse_id is not None else self.token()
+                )
+                self.assertNextToken(DrtTokens.COMMA)
+                sent_id = self.nullableIntToken()
+                self.assertNextToken(DrtTokens.COMMA)
+                word_ids = list(map(int, self.handle_refs()))
+                self.assertNextToken(DrtTokens.COMMA)
+                ans_types = self.handle_refs()
+                self.assertNextToken(DrtTokens.COMMA)
+                drs1 = self.process_next_expression(None)
+                self.assertNextToken(DrtTokens.COMMA)
+                var = int(self.token())
+                self.assertNextToken(DrtTokens.COMMA)
+                drs2 = self.process_next_expression(None)
+                self.assertNextToken(DrtTokens.CLOSE)
+                return BoxerWhq(disc_id, sent_id, word_ids, ans_types, drs1, var, drs2)
+        except Exception as e:
+            raise LogicalExpressionException(self._currentIndex, str(e)) from e
+        assert False, repr(tok)
+
+    def nullableIntToken(self):
+        t = self.token()
+        return int(t) if t != "None" else None
+
+    def get_next_token_variable(self, description):
+        try:
+            return self.token()
+        except ExpectedMoreTokensException as e:
+            raise ExpectedMoreTokensException(e.index, "Variable expected.") from e
+
+
+class AbstractBoxerDrs:
+    def variables(self):
+        """
+        :return: (set<variables>, set<events>, set<propositions>)
+        """
+        variables, events, propositions = self._variables()
+        return (variables - (events | propositions), events, propositions - events)
+
+    def variable_types(self):
+        vartypes = {}
+        for t, vars in zip(("z", "e", "p"), self.variables()):
+            for v in vars:
+                vartypes[v] = t
+        return vartypes
+
+    def _variables(self):
+        """
+        :return: (set<variables>, set<events>, set<propositions>)
+        """
+        return (set(), set(), set())
+
+    def atoms(self):
+        return set()
+
+    def clean(self):
+        return self
+
+    def _clean_name(self, name):
+        return name.replace("-", "_").replace("'", "_")
+
+    def renumber_sentences(self, f):
+        return self
+
+    def __hash__(self):
+        return hash(f"{self}")
+
+
+class BoxerDrs(AbstractBoxerDrs):
+    def __init__(self, refs, conds, consequent=None):
+        AbstractBoxerDrs.__init__(self)
+        self.refs = refs
+        self.conds = conds
+        self.consequent = consequent
+
+    def _variables(self):
+        variables = (set(), set(), set())
+        for cond in self.conds:
+            for s, v in zip(variables, cond._variables()):
+                s.update(v)
+        if self.consequent is not None:
+            for s, v in zip(variables, self.consequent._variables()):
+                s.update(v)
+        return variables
+
+    def atoms(self):
+        atoms = reduce(operator.or_, (cond.atoms() for cond in self.conds), set())
+        if self.consequent is not None:
+            atoms.update(self.consequent.atoms())
+        return atoms
+
+    def clean(self):
+        consequent = self.consequent.clean() if self.consequent else None
+        return BoxerDrs(self.refs, [c.clean() for c in self.conds], consequent)
+
+    def renumber_sentences(self, f):
+        consequent = self.consequent.renumber_sentences(f) if self.consequent else None
+        return BoxerDrs(
+            self.refs, [c.renumber_sentences(f) for c in self.conds], consequent
+        )
+
+    def __repr__(self):
+        s = "drs([{}], [{}])".format(
+            ", ".join("%s" % r for r in self.refs),
+            ", ".join("%s" % c for c in self.conds),
+        )
+        if self.consequent is not None:
+            s = f"imp({s}, {self.consequent})"
+        return s
+
+    def __eq__(self, other):
+        return (
+            self.__class__ == other.__class__
+            and self.refs == other.refs
+            and len(self.conds) == len(other.conds)
+            and reduce(
+                operator.and_, (c1 == c2 for c1, c2 in zip(self.conds, other.conds))
+            )
+            and self.consequent == other.consequent
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    __hash__ = AbstractBoxerDrs.__hash__
+
+
+class BoxerNot(AbstractBoxerDrs):
+    def __init__(self, drs):
+        AbstractBoxerDrs.__init__(self)
+        self.drs = drs
+
+    def _variables(self):
+        return self.drs._variables()
+
+    def atoms(self):
+        return self.drs.atoms()
+
+    def clean(self):
+        return BoxerNot(self.drs.clean())
+
+    def renumber_sentences(self, f):
+        return BoxerNot(self.drs.renumber_sentences(f))
+
+    def __repr__(self):
+        return "not(%s)" % (self.drs)
+
+    def __eq__(self, other):
+        return self.__class__ == other.__class__ and self.drs == other.drs
+
+    def __ne__(self, other):
+        return not self == other
+
+    __hash__ = AbstractBoxerDrs.__hash__
+
+
+class BoxerIndexed(AbstractBoxerDrs):
+    def __init__(self, discourse_id, sent_index, word_indices):
+        AbstractBoxerDrs.__init__(self)
+        self.discourse_id = discourse_id
+        self.sent_index = sent_index
+        self.word_indices = word_indices
+
+    def atoms(self):
+        return {self}
+
+    def __eq__(self, other):
+        return (
+            self.__class__ == other.__class__
+            and self.discourse_id == other.discourse_id
+            and self.sent_index == other.sent_index
+            and self.word_indices == other.word_indices
+            and reduce(operator.and_, (s == o for s, o in zip(self, other)))
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    __hash__ = AbstractBoxerDrs.__hash__
+
+    def __repr__(self):
+        s = "{}({}, {}, [{}]".format(
+            self._pred(),
+            self.discourse_id,
+            self.sent_index,
+            ", ".join("%s" % wi for wi in self.word_indices),
+        )
+        for v in self:
+            s += ", %s" % v
+        return s + ")"
+
+
+class BoxerPred(BoxerIndexed):
+    def __init__(self, discourse_id, sent_index, word_indices, var, name, pos, sense):
+        BoxerIndexed.__init__(self, discourse_id, sent_index, word_indices)
+        self.var = var
+        self.name = name
+        self.pos = pos
+        self.sense = sense
+
+    def _variables(self):
+        return ({self.var}, set(), set())
+
+    def change_var(self, var):
+        return BoxerPred(
+            self.discourse_id,
+            self.sent_index,
+            self.word_indices,
+            var,
+            self.name,
+            self.pos,
+            self.sense,
+        )
+
+    def clean(self):
+        return BoxerPred(
+            self.discourse_id,
+            self.sent_index,
+            self.word_indices,
+            self.var,
+            self._clean_name(self.name),
+            self.pos,
+            self.sense,
+        )
+
+    def renumber_sentences(self, f):
+        new_sent_index = f(self.sent_index)
+        return BoxerPred(
+            self.discourse_id,
+            new_sent_index,
+            self.word_indices,
+            self.var,
+            self.name,
+            self.pos,
+            self.sense,
+        )
+
+    def __iter__(self):
+        return iter((self.var, self.name, self.pos, self.sense))
+
+    def _pred(self):
+        return "pred"
+
+
+class BoxerNamed(BoxerIndexed):
+    def __init__(self, discourse_id, sent_index, word_indices, var, name, type, sense):
+        BoxerIndexed.__init__(self, discourse_id, sent_index, word_indices)
+        self.var = var
+        self.name = name
+        self.type = type
+        self.sense = sense
+
+    def _variables(self):
+        return ({self.var}, set(), set())
+
+    def change_var(self, var):
+        return BoxerNamed(
+            self.discourse_id,
+            self.sent_index,
+            self.word_indices,
+            var,
+            self.name,
+            self.type,
+            self.sense,
+        )
+
+    def clean(self):
+        return BoxerNamed(
+            self.discourse_id,
+            self.sent_index,
+            self.word_indices,
+            self.var,
+            self._clean_name(self.name),
+            self.type,
+            self.sense,
+        )
+
+    def renumber_sentences(self, f):
+        return BoxerNamed(
+            self.discourse_id,
+            f(self.sent_index),
+            self.word_indices,
+            self.var,
+            self.name,
+            self.type,
+            self.sense,
+        )
+
+    def __iter__(self):
+        return iter((self.var, self.name, self.type, self.sense))
+
+    def _pred(self):
+        return "named"
+
+
+class BoxerRel(BoxerIndexed):
+    def __init__(self, discourse_id, sent_index, word_indices, var1, var2, rel, sense):
+        BoxerIndexed.__init__(self, discourse_id, sent_index, word_indices)
+        self.var1 = var1
+        self.var2 = var2
+        self.rel = rel
+        self.sense = sense
+
+    def _variables(self):
+        return ({self.var1, self.var2}, set(), set())
+
+    def clean(self):
+        return BoxerRel(
+            self.discourse_id,
+            self.sent_index,
+            self.word_indices,
+            self.var1,
+            self.var2,
+            self._clean_name(self.rel),
+            self.sense,
+        )
+
+    def renumber_sentences(self, f):
+        return BoxerRel(
+            self.discourse_id,
+            f(self.sent_index),
+            self.word_indices,
+            self.var1,
+            self.var2,
+            self.rel,
+            self.sense,
+        )
+
+    def __iter__(self):
+        return iter((self.var1, self.var2, self.rel, self.sense))
+
+    def _pred(self):
+        return "rel"
+
+
+class BoxerProp(BoxerIndexed):
+    def __init__(self, discourse_id, sent_index, word_indices, var, drs):
+        BoxerIndexed.__init__(self, discourse_id, sent_index, word_indices)
+        self.var = var
+        self.drs = drs
+
+    def _variables(self):
+        return tuple(
+            map(operator.or_, (set(), set(), {self.var}), self.drs._variables())
+        )
+
+    def referenced_labels(self):
+        return {self.drs}
+
+    def atoms(self):
+        return self.drs.atoms()
+
+    def clean(self):
+        return BoxerProp(
+            self.discourse_id,
+            self.sent_index,
+            self.word_indices,
+            self.var,
+            self.drs.clean(),
+        )
+
+    def renumber_sentences(self, f):
+        return BoxerProp(
+            self.discourse_id,
+            f(self.sent_index),
+            self.word_indices,
+            self.var,
+            self.drs.renumber_sentences(f),
+        )
+
+    def __iter__(self):
+        return iter((self.var, self.drs))
+
+    def _pred(self):
+        return "prop"
+
+
+class BoxerEq(BoxerIndexed):
+    def __init__(self, discourse_id, sent_index, word_indices, var1, var2):
+        BoxerIndexed.__init__(self, discourse_id, sent_index, word_indices)
+        self.var1 = var1
+        self.var2 = var2
+
+    def _variables(self):
+        return ({self.var1, self.var2}, set(), set())
+
+    def atoms(self):
+        return set()
+
+    def renumber_sentences(self, f):
+        return BoxerEq(
+            self.discourse_id,
+            f(self.sent_index),
+            self.word_indices,
+            self.var1,
+            self.var2,
+        )
+
+    def __iter__(self):
+        return iter((self.var1, self.var2))
+
+    def _pred(self):
+        return "eq"
+
+
+class BoxerCard(BoxerIndexed):
+    def __init__(self, discourse_id, sent_index, word_indices, var, value, type):
+        BoxerIndexed.__init__(self, discourse_id, sent_index, word_indices)
+        self.var = var
+        self.value = value
+        self.type = type
+
+    def _variables(self):
+        return ({self.var}, set(), set())
+
+    def renumber_sentences(self, f):
+        return BoxerCard(
+            self.discourse_id,
+            f(self.sent_index),
+            self.word_indices,
+            self.var,
+            self.value,
+            self.type,
+        )
+
+    def __iter__(self):
+        return iter((self.var, self.value, self.type))
+
+    def _pred(self):
+        return "card"
+
+
+class BoxerOr(BoxerIndexed):
+    def __init__(self, discourse_id, sent_index, word_indices, drs1, drs2):
+        BoxerIndexed.__init__(self, discourse_id, sent_index, word_indices)
+        self.drs1 = drs1
+        self.drs2 = drs2
+
+    def _variables(self):
+        return tuple(map(operator.or_, self.drs1._variables(), self.drs2._variables()))
+
+    def atoms(self):
+        return self.drs1.atoms() | self.drs2.atoms()
+
+    def clean(self):
+        return BoxerOr(
+            self.discourse_id,
+            self.sent_index,
+            self.word_indices,
+            self.drs1.clean(),
+            self.drs2.clean(),
+        )
+
+    def renumber_sentences(self, f):
+        return BoxerOr(
+            self.discourse_id,
+            f(self.sent_index),
+            self.word_indices,
+            self.drs1,
+            self.drs2,
+        )
+
+    def __iter__(self):
+        return iter((self.drs1, self.drs2))
+
+    def _pred(self):
+        return "or"
+
+
+class BoxerWhq(BoxerIndexed):
+    def __init__(
+        self, discourse_id, sent_index, word_indices, ans_types, drs1, variable, drs2
+    ):
+        BoxerIndexed.__init__(self, discourse_id, sent_index, word_indices)
+        self.ans_types = ans_types
+        self.drs1 = drs1
+        self.variable = variable
+        self.drs2 = drs2
+
+    def _variables(self):
+        return tuple(
+            map(
+                operator.or_,
+                ({self.variable}, set(), set()),
+                self.drs1._variables(),
+                self.drs2._variables(),
+            )
+        )
+
+    def atoms(self):
+        return self.drs1.atoms() | self.drs2.atoms()
+
+    def clean(self):
+        return BoxerWhq(
+            self.discourse_id,
+            self.sent_index,
+            self.word_indices,
+            self.ans_types,
+            self.drs1.clean(),
+            self.variable,
+            self.drs2.clean(),
+        )
+
+    def renumber_sentences(self, f):
+        return BoxerWhq(
+            self.discourse_id,
+            f(self.sent_index),
+            self.word_indices,
+            self.ans_types,
+            self.drs1,
+            self.variable,
+            self.drs2,
+        )
+
+    def __iter__(self):
+        return iter(
+            ("[" + ",".join(self.ans_types) + "]", self.drs1, self.variable, self.drs2)
+        )
+
+    def _pred(self):
+        return "whq"
+
+
+class PassthroughBoxerDrsInterpreter:
+    def interpret(self, ex):
+        return ex
+
+
+class NltkDrtBoxerDrsInterpreter:
+    def __init__(self, occur_index=False):
+        self._occur_index = occur_index
+
+    def interpret(self, ex):
+        """
+        :param ex: ``AbstractBoxerDrs``
+        :return: ``DrtExpression``
+        """
+        if isinstance(ex, BoxerDrs):
+            drs = DRS(
+                [Variable(r) for r in ex.refs], list(map(self.interpret, ex.conds))
+            )
+            if ex.consequent is not None:
+                drs.consequent = self.interpret(ex.consequent)
+            return drs
+        elif isinstance(ex, BoxerNot):
+            return DrtNegatedExpression(self.interpret(ex.drs))
+        elif isinstance(ex, BoxerPred):
+            pred = self._add_occur_indexing(f"{ex.pos}_{ex.name}", ex)
+            return self._make_atom(pred, ex.var)
+        elif isinstance(ex, BoxerNamed):
+            pred = self._add_occur_indexing(f"ne_{ex.type}_{ex.name}", ex)
+            return self._make_atom(pred, ex.var)
+        elif isinstance(ex, BoxerRel):
+            pred = self._add_occur_indexing("%s" % (ex.rel), ex)
+            return self._make_atom(pred, ex.var1, ex.var2)
+        elif isinstance(ex, BoxerProp):
+            return DrtProposition(Variable(ex.var), self.interpret(ex.drs))
+        elif isinstance(ex, BoxerEq):
+            return DrtEqualityExpression(
+                DrtVariableExpression(Variable(ex.var1)),
+                DrtVariableExpression(Variable(ex.var2)),
+            )
+        elif isinstance(ex, BoxerCard):
+            pred = self._add_occur_indexing(f"card_{ex.type}_{ex.value}", ex)
+            return self._make_atom(pred, ex.var)
+        elif isinstance(ex, BoxerOr):
+            return DrtOrExpression(self.interpret(ex.drs1), self.interpret(ex.drs2))
+        elif isinstance(ex, BoxerWhq):
+            drs1 = self.interpret(ex.drs1)
+            drs2 = self.interpret(ex.drs2)
+            return DRS(drs1.refs + drs2.refs, drs1.conds + drs2.conds)
+        assert False, f"{ex.__class__.__name__}: {ex}"
+
+    def _make_atom(self, pred, *args):
+        accum = DrtVariableExpression(Variable(pred))
+        for arg in args:
+            accum = DrtApplicationExpression(
+                accum, DrtVariableExpression(Variable(arg))
+            )
+        return accum
+
+    def _add_occur_indexing(self, base, ex):
+        if self._occur_index and ex.sent_index is not None:
+            if ex.discourse_id:
+                base += "_%s" % ex.discourse_id
+            base += "_s%s" % ex.sent_index
+            base += "_w%s" % sorted(ex.word_indices)[0]
+        return base
+
+
+class UnparseableInputException(Exception):
+    pass
+
+
+if __name__ == "__main__":
+    opts = OptionParser("usage: %prog TEXT [options]")
+    opts.add_option(
+        "--verbose",
+        "-v",
+        help="display verbose logs",
+        action="store_true",
+        default=False,
+        dest="verbose",
+    )
+    opts.add_option(
+        "--fol", "-f", help="output FOL", action="store_true", default=False, dest="fol"
+    )
+    opts.add_option(
+        "--question",
+        "-q",
+        help="input is a question",
+        action="store_true",
+        default=False,
+        dest="question",
+    )
+    opts.add_option(
+        "--occur",
+        "-o",
+        help="occurrence index",
+        action="store_true",
+        default=False,
+        dest="occur_index",
+    )
+    (options, args) = opts.parse_args()
+
+    if len(args) != 1:
+        opts.error("incorrect number of arguments")
+
+    interpreter = NltkDrtBoxerDrsInterpreter(occur_index=options.occur_index)
+    drs = Boxer(interpreter).interpret_multi(
+        args[0].split(r"\n"), question=options.question, verbose=options.verbose
+    )
+    if drs is None:
+        print(None)
+    else:
+        drs = drs.simplify().eliminate_equality()
+        if options.fol:
+            print(drs.fol().normalize())
+        else:
+            drs.pretty_print()

llmeval-env/lib/python3.10/site-packages/nltk/sem/chat80.py

@@ -0,0 +1,857 @@
+# Natural Language Toolkit: Chat-80 KB Reader
+# See https://www.w3.org/TR/swbp-skos-core-guide/
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Ewan Klein <[email protected]>,
+# URL: <https://www.nltk.org>
+# For license information, see LICENSE.TXT
+
+r"""
+Overview
+========
+
+Chat-80 was a natural language system which allowed the user to
+interrogate a Prolog knowledge base in the domain of world
+geography. It was developed in the early '80s by Warren and Pereira; see
+``https://www.aclweb.org/anthology/J82-3002.pdf`` for a description and
+``http://www.cis.upenn.edu/~pereira/oldies.html`` for the source
+files.
+
+This module contains functions to extract data from the Chat-80
+relation files ('the world database'), and convert then into a format
+that can be incorporated in the FOL models of
+``nltk.sem.evaluate``. The code assumes that the Prolog
+input files are available in the NLTK corpora directory.
+
+The Chat-80 World Database consists of the following files::
+
+    world0.pl
+    rivers.pl
+    cities.pl
+    countries.pl
+    contain.pl
+    borders.pl
+
+This module uses a slightly modified version of ``world0.pl``, in which
+a set of Prolog rules have been omitted. The modified file is named
+``world1.pl``. Currently, the file ``rivers.pl`` is not read in, since
+it uses a list rather than a string in the second field.
+
+Reading Chat-80 Files
+=====================
+
+Chat-80 relations are like tables in a relational database. The
+relation acts as the name of the table; the first argument acts as the
+'primary key'; and subsequent arguments are further fields in the
+table. In general, the name of the table provides a label for a unary
+predicate whose extension is all the primary keys. For example,
+relations in ``cities.pl`` are of the following form::
+
+   'city(athens,greece,1368).'
+
+Here, ``'athens'`` is the key, and will be mapped to a member of the
+unary predicate *city*.
+
+The fields in the table are mapped to binary predicates. The first
+argument of the predicate is the primary key, while the second
+argument is the data in the relevant field. Thus, in the above
+example, the third field is mapped to the binary predicate
+*population_of*, whose extension is a set of pairs such as
+``'(athens, 1368)'``.
+
+An exception to this general framework is required by the relations in
+the files ``borders.pl`` and ``contains.pl``. These contain facts of the
+following form::
+
+    'borders(albania,greece).'
+
+    'contains0(africa,central_africa).'
+
+We do not want to form a unary concept out the element in
+the first field of these records, and we want the label of the binary
+relation just to be ``'border'``/``'contain'`` respectively.
+
+In order to drive the extraction process, we use 'relation metadata bundles'
+which are Python dictionaries such as the following::
+
+  city = {'label': 'city',
+          'closures': [],
+          'schema': ['city', 'country', 'population'],
+          'filename': 'cities.pl'}
+
+According to this, the file ``city['filename']`` contains a list of
+relational tuples (or more accurately, the corresponding strings in
+Prolog form) whose predicate symbol is ``city['label']`` and whose
+relational schema is ``city['schema']``. The notion of a ``closure`` is
+discussed in the next section.
+
+Concepts
+========
+In order to encapsulate the results of the extraction, a class of
+``Concept`` objects is introduced.  A ``Concept`` object has a number of
+attributes, in particular a ``prefLabel`` and ``extension``, which make
+it easier to inspect the output of the extraction. In addition, the
+``extension`` can be further processed: in the case of the ``'border'``
+relation, we check that the relation is symmetric, and in the case
+of the ``'contain'`` relation, we carry out the transitive
+closure. The closure properties associated with a concept is
+indicated in the relation metadata, as indicated earlier.
+
+The ``extension`` of a ``Concept`` object is then incorporated into a
+``Valuation`` object.
+
+Persistence
+===========
+The functions ``val_dump`` and ``val_load`` are provided to allow a
+valuation to be stored in a persistent database and re-loaded, rather
+than having to be re-computed each time.
+
+Individuals and Lexical Items
+=============================
+As well as deriving relations from the Chat-80 data, we also create a
+set of individual constants, one for each entity in the domain. The
+individual constants are string-identical to the entities. For
+example, given a data item such as ``'zloty'``, we add to the valuation
+a pair ``('zloty', 'zloty')``. In order to parse English sentences that
+refer to these entities, we also create a lexical item such as the
+following for each individual constant::
+
+   PropN[num=sg, sem=<\P.(P zloty)>] -> 'Zloty'
+
+The set of rules is written to the file ``chat_pnames.cfg`` in the
+current directory.
+
+"""
+
+import os
+import re
+import shelve
+import sys
+
+import nltk.data
+
+###########################################################################
+# Chat-80 relation metadata bundles needed to build the valuation
+###########################################################################
+
+borders = {
+    "rel_name": "borders",
+    "closures": ["symmetric"],
+    "schema": ["region", "border"],
+    "filename": "borders.pl",
+}
+
+contains = {
+    "rel_name": "contains0",
+    "closures": ["transitive"],
+    "schema": ["region", "contain"],
+    "filename": "contain.pl",
+}
+
+city = {
+    "rel_name": "city",
+    "closures": [],
+    "schema": ["city", "country", "population"],
+    "filename": "cities.pl",
+}
+
+country = {
+    "rel_name": "country",
+    "closures": [],
+    "schema": [
+        "country",
+        "region",
+        "latitude",
+        "longitude",
+        "area",
+        "population",
+        "capital",
+        "currency",
+    ],
+    "filename": "countries.pl",
+}
+
+circle_of_lat = {
+    "rel_name": "circle_of_latitude",
+    "closures": [],
+    "schema": ["circle_of_latitude", "degrees"],
+    "filename": "world1.pl",
+}
+
+circle_of_long = {
+    "rel_name": "circle_of_longitude",
+    "closures": [],
+    "schema": ["circle_of_longitude", "degrees"],
+    "filename": "world1.pl",
+}
+
+continent = {
+    "rel_name": "continent",
+    "closures": [],
+    "schema": ["continent"],
+    "filename": "world1.pl",
+}
+
+region = {
+    "rel_name": "in_continent",
+    "closures": [],
+    "schema": ["region", "continent"],
+    "filename": "world1.pl",
+}
+
+ocean = {
+    "rel_name": "ocean",
+    "closures": [],
+    "schema": ["ocean"],
+    "filename": "world1.pl",
+}
+
+sea = {"rel_name": "sea", "closures": [], "schema": ["sea"], "filename": "world1.pl"}
+
+
+items = [
+    "borders",
+    "contains",
+    "city",
+    "country",
+    "circle_of_lat",
+    "circle_of_long",
+    "continent",
+    "region",
+    "ocean",
+    "sea",
+]
+items = tuple(sorted(items))
+
+item_metadata = {
+    "borders": borders,
+    "contains": contains,
+    "city": city,
+    "country": country,
+    "circle_of_lat": circle_of_lat,
+    "circle_of_long": circle_of_long,
+    "continent": continent,
+    "region": region,
+    "ocean": ocean,
+    "sea": sea,
+}
+
+rels = item_metadata.values()
+
+not_unary = ["borders.pl", "contain.pl"]
+
+###########################################################################
+
+
+class Concept:
+    """
+    A Concept class, loosely based on SKOS
+    (https://www.w3.org/TR/swbp-skos-core-guide/).
+    """
+
+    def __init__(self, prefLabel, arity, altLabels=[], closures=[], extension=set()):
+        """
+        :param prefLabel: the preferred label for the concept
+        :type prefLabel: str
+        :param arity: the arity of the concept
+        :type arity: int
+        :param altLabels: other (related) labels
+        :type altLabels: list
+        :param closures: closure properties of the extension
+            (list items can be ``symmetric``, ``reflexive``, ``transitive``)
+        :type closures: list
+        :param extension: the extensional value of the concept
+        :type extension: set
+        """
+        self.prefLabel = prefLabel
+        self.arity = arity
+        self.altLabels = altLabels
+        self.closures = closures
+        # keep _extension internally as a set
+        self._extension = extension
+        # public access is via a list (for slicing)
+        self.extension = sorted(list(extension))
+
+    def __str__(self):
+        # _extension = ''
+        # for element in sorted(self.extension):
+        # if isinstance(element, tuple):
+        # element = '(%s, %s)' % (element)
+        # _extension += element + ', '
+        # _extension = _extension[:-1]
+
+        return "Label = '{}'\nArity = {}\nExtension = {}".format(
+            self.prefLabel,
+            self.arity,
+            self.extension,
+        )
+
+    def __repr__(self):
+        return "Concept('%s')" % self.prefLabel
+
+    def augment(self, data):
+        """
+        Add more data to the ``Concept``'s extension set.
+
+        :param data: a new semantic value
+        :type data: string or pair of strings
+        :rtype: set
+
+        """
+        self._extension.add(data)
+        self.extension = sorted(list(self._extension))
+        return self._extension
+
+    def _make_graph(self, s):
+        """
+        Convert a set of pairs into an adjacency linked list encoding of a graph.
+        """
+        g = {}
+        for (x, y) in s:
+            if x in g:
+                g[x].append(y)
+            else:
+                g[x] = [y]
+        return g
+
+    def _transclose(self, g):
+        """
+        Compute the transitive closure of a graph represented as a linked list.
+        """
+        for x in g:
+            for adjacent in g[x]:
+                # check that adjacent is a key
+                if adjacent in g:
+                    for y in g[adjacent]:
+                        if y not in g[x]:
+                            g[x].append(y)
+        return g
+
+    def _make_pairs(self, g):
+        """
+        Convert an adjacency linked list back into a set of pairs.
+        """
+        pairs = []
+        for node in g:
+            for adjacent in g[node]:
+                pairs.append((node, adjacent))
+        return set(pairs)
+
+    def close(self):
+        """
+        Close a binary relation in the ``Concept``'s extension set.
+
+        :return: a new extension for the ``Concept`` in which the
+                 relation is closed under a given property
+        """
+        from nltk.sem import is_rel
+
+        assert is_rel(self._extension)
+        if "symmetric" in self.closures:
+            pairs = []
+            for (x, y) in self._extension:
+                pairs.append((y, x))
+            sym = set(pairs)
+            self._extension = self._extension.union(sym)
+        if "transitive" in self.closures:
+            all = self._make_graph(self._extension)
+            closed = self._transclose(all)
+            trans = self._make_pairs(closed)
+            self._extension = self._extension.union(trans)
+        self.extension = sorted(list(self._extension))
+
+
+def clause2concepts(filename, rel_name, schema, closures=[]):
+    """
+    Convert a file of Prolog clauses into a list of ``Concept`` objects.
+
+    :param filename: filename containing the relations
+    :type filename: str
+    :param rel_name: name of the relation
+    :type rel_name: str
+    :param schema: the schema used in a set of relational tuples
+    :type schema: list
+    :param closures: closure properties for the extension of the concept
+    :type closures: list
+    :return: a list of ``Concept`` objects
+    :rtype: list
+    """
+    concepts = []
+    # position of the subject of a binary relation
+    subj = 0
+    # label of the 'primary key'
+    pkey = schema[0]
+    # fields other than the primary key
+    fields = schema[1:]
+
+    # convert a file into a list of lists
+    records = _str2records(filename, rel_name)
+
+    # add a unary concept corresponding to the set of entities
+    # in the primary key position
+    # relations in 'not_unary' are more like ordinary binary relations
+    if not filename in not_unary:
+        concepts.append(unary_concept(pkey, subj, records))
+
+    # add a binary concept for each non-key field
+    for field in fields:
+        obj = schema.index(field)
+        concepts.append(binary_concept(field, closures, subj, obj, records))
+
+    return concepts
+
+
+def cities2table(filename, rel_name, dbname, verbose=False, setup=False):
+    """
+    Convert a file of Prolog clauses into a database table.
+
+    This is not generic, since it doesn't allow arbitrary
+    schemas to be set as a parameter.
+
+    Intended usage::
+
+        cities2table('cities.pl', 'city', 'city.db', verbose=True, setup=True)
+
+    :param filename: filename containing the relations
+    :type filename: str
+    :param rel_name: name of the relation
+    :type rel_name: str
+    :param dbname: filename of persistent store
+    :type schema: str
+    """
+    import sqlite3
+
+    records = _str2records(filename, rel_name)
+    connection = sqlite3.connect(dbname)
+    cur = connection.cursor()
+    if setup:
+        cur.execute(
+            """CREATE TABLE city_table
+        (City text, Country text, Population int)"""
+        )
+
+    table_name = "city_table"
+    for t in records:
+        cur.execute("insert into %s values (?,?,?)" % table_name, t)
+        if verbose:
+            print("inserting values into %s: " % table_name, t)
+    connection.commit()
+    if verbose:
+        print("Committing update to %s" % dbname)
+    cur.close()
+
+
+def sql_query(dbname, query):
+    """
+    Execute an SQL query over a database.
+    :param dbname: filename of persistent store
+    :type schema: str
+    :param query: SQL query
+    :type rel_name: str
+    """
+    import sqlite3
+
+    try:
+        path = nltk.data.find(dbname)
+        connection = sqlite3.connect(str(path))
+        cur = connection.cursor()
+        return cur.execute(query)
+    except (ValueError, sqlite3.OperationalError):
+        import warnings
+
+        warnings.warn(
+            "Make sure the database file %s is installed and uncompressed." % dbname
+        )
+        raise
+
+
+def _str2records(filename, rel):
+    """
+    Read a file into memory and convert each relation clause into a list.
+    """
+    recs = []
+    contents = nltk.data.load("corpora/chat80/%s" % filename, format="text")
+    for line in contents.splitlines():
+        if line.startswith(rel):
+            line = re.sub(rel + r"\(", "", line)
+            line = re.sub(r"\)\.$", "", line)
+            record = line.split(",")
+            recs.append(record)
+    return recs
+
+
+def unary_concept(label, subj, records):
+    """
+    Make a unary concept out of the primary key in a record.
+
+    A record is a list of entities in some relation, such as
+    ``['france', 'paris']``, where ``'france'`` is acting as the primary
+    key.
+
+    :param label: the preferred label for the concept
+    :type label: string
+    :param subj: position in the record of the subject of the predicate
+    :type subj: int
+    :param records: a list of records
+    :type records: list of lists
+    :return: ``Concept`` of arity 1
+    :rtype: Concept
+    """
+    c = Concept(label, arity=1, extension=set())
+    for record in records:
+        c.augment(record[subj])
+    return c
+
+
+def binary_concept(label, closures, subj, obj, records):
+    """
+    Make a binary concept out of the primary key and another field in a record.
+
+    A record is a list of entities in some relation, such as
+    ``['france', 'paris']``, where ``'france'`` is acting as the primary
+    key, and ``'paris'`` stands in the ``'capital_of'`` relation to
+    ``'france'``.
+
+    More generally, given a record such as ``['a', 'b', 'c']``, where
+    label is bound to ``'B'``, and ``obj`` bound to 1, the derived
+    binary concept will have label ``'B_of'``, and its extension will
+    be a set of pairs such as ``('a', 'b')``.
+
+
+    :param label: the base part of the preferred label for the concept
+    :type label: str
+    :param closures: closure properties for the extension of the concept
+    :type closures: list
+    :param subj: position in the record of the subject of the predicate
+    :type subj: int
+    :param obj: position in the record of the object of the predicate
+    :type obj: int
+    :param records: a list of records
+    :type records: list of lists
+    :return: ``Concept`` of arity 2
+    :rtype: Concept
+    """
+    if not label == "border" and not label == "contain":
+        label = label + "_of"
+    c = Concept(label, arity=2, closures=closures, extension=set())
+    for record in records:
+        c.augment((record[subj], record[obj]))
+    # close the concept's extension according to the properties in closures
+    c.close()
+    return c
+
+
+def process_bundle(rels):
+    """
+    Given a list of relation metadata bundles, make a corresponding
+    dictionary of concepts, indexed by the relation name.
+
+    :param rels: bundle of metadata needed for constructing a concept
+    :type rels: list(dict)
+    :return: a dictionary of concepts, indexed by the relation name.
+    :rtype: dict(str): Concept
+    """
+    concepts = {}
+    for rel in rels:
+        rel_name = rel["rel_name"]
+        closures = rel["closures"]
+        schema = rel["schema"]
+        filename = rel["filename"]
+
+        concept_list = clause2concepts(filename, rel_name, schema, closures)
+        for c in concept_list:
+            label = c.prefLabel
+            if label in concepts:
+                for data in c.extension:
+                    concepts[label].augment(data)
+                concepts[label].close()
+            else:
+                concepts[label] = c
+    return concepts
+
+
+def make_valuation(concepts, read=False, lexicon=False):
+    """
+    Convert a list of ``Concept`` objects into a list of (label, extension) pairs;
+    optionally create a ``Valuation`` object.
+
+    :param concepts: concepts
+    :type concepts: list(Concept)
+    :param read: if ``True``, ``(symbol, set)`` pairs are read into a ``Valuation``
+    :type read: bool
+    :rtype: list or Valuation
+    """
+    vals = []
+
+    for c in concepts:
+        vals.append((c.prefLabel, c.extension))
+    if lexicon:
+        read = True
+    if read:
+        from nltk.sem import Valuation
+
+        val = Valuation({})
+        val.update(vals)
+        # add labels for individuals
+        val = label_indivs(val, lexicon=lexicon)
+        return val
+    else:
+        return vals
+
+
+def val_dump(rels, db):
+    """
+    Make a ``Valuation`` from a list of relation metadata bundles and dump to
+    persistent database.
+
+    :param rels: bundle of metadata needed for constructing a concept
+    :type rels: list of dict
+    :param db: name of file to which data is written.
+               The suffix '.db' will be automatically appended.
+    :type db: str
+    """
+    concepts = process_bundle(rels).values()
+    valuation = make_valuation(concepts, read=True)
+    db_out = shelve.open(db, "n")
+
+    db_out.update(valuation)
+
+    db_out.close()
+
+
+def val_load(db):
+    """
+    Load a ``Valuation`` from a persistent database.
+
+    :param db: name of file from which data is read.
+               The suffix '.db' should be omitted from the name.
+    :type db: str
+    """
+    dbname = db + ".db"
+
+    if not os.access(dbname, os.R_OK):
+        sys.exit("Cannot read file: %s" % dbname)
+    else:
+        db_in = shelve.open(db)
+        from nltk.sem import Valuation
+
+        val = Valuation(db_in)
+        #        val.read(db_in.items())
+        return val
+
+
+# def alpha(str):
+# """
+# Utility to filter out non-alphabetic constants.
+
+#:param str: candidate constant
+#:type str: string
+#:rtype: bool
+# """
+# try:
+# int(str)
+# return False
+# except ValueError:
+## some unknown values in records are labeled '?'
+# if not str == '?':
+# return True
+
+
+def label_indivs(valuation, lexicon=False):
+    """
+    Assign individual constants to the individuals in the domain of a ``Valuation``.
+
+    Given a valuation with an entry of the form ``{'rel': {'a': True}}``,
+    add a new entry ``{'a': 'a'}``.
+
+    :type valuation: Valuation
+    :rtype: Valuation
+    """
+    # collect all the individuals into a domain
+    domain = valuation.domain
+    # convert the domain into a sorted list of alphabetic terms
+    # use the same string as a label
+    pairs = [(e, e) for e in domain]
+    if lexicon:
+        lex = make_lex(domain)
+        with open("chat_pnames.cfg", "w") as outfile:
+            outfile.writelines(lex)
+    # read the pairs into the valuation
+    valuation.update(pairs)
+    return valuation
+
+
+def make_lex(symbols):
+    """
+    Create lexical CFG rules for each individual symbol.
+
+    Given a valuation with an entry of the form ``{'zloty': 'zloty'}``,
+    create a lexical rule for the proper name 'Zloty'.
+
+    :param symbols: a list of individual constants in the semantic representation
+    :type symbols: sequence -- set(str)
+    :rtype: list(str)
+    """
+    lex = []
+    header = """
+##################################################################
+# Lexical rules automatically generated by running 'chat80.py -x'.
+##################################################################
+
+"""
+    lex.append(header)
+    template = r"PropN[num=sg, sem=<\P.(P %s)>] -> '%s'\n"
+
+    for s in symbols:
+        parts = s.split("_")
+        caps = [p.capitalize() for p in parts]
+        pname = "_".join(caps)
+        rule = template % (s, pname)
+        lex.append(rule)
+    return lex
+
+
+###########################################################################
+# Interface function to emulate other corpus readers
+###########################################################################
+
+
+def concepts(items=items):
+    """
+    Build a list of concepts corresponding to the relation names in ``items``.
+
+    :param items: names of the Chat-80 relations to extract
+    :type items: list(str)
+    :return: the ``Concept`` objects which are extracted from the relations
+    :rtype: list(Concept)
+    """
+    if isinstance(items, str):
+        items = (items,)
+
+    rels = [item_metadata[r] for r in items]
+
+    concept_map = process_bundle(rels)
+    return concept_map.values()
+
+
+###########################################################################
+
+
+def main():
+    import sys
+    from optparse import OptionParser
+
+    description = """
+Extract data from the Chat-80 Prolog files and convert them into a
+Valuation object for use in the NLTK semantics package.
+    """
+
+    opts = OptionParser(description=description)
+    opts.set_defaults(verbose=True, lex=False, vocab=False)
+    opts.add_option(
+        "-s", "--store", dest="outdb", help="store a valuation in DB", metavar="DB"
+    )
+    opts.add_option(
+        "-l",
+        "--load",
+        dest="indb",
+        help="load a stored valuation from DB",
+        metavar="DB",
+    )
+    opts.add_option(
+        "-c",
+        "--concepts",
+        action="store_true",
+        help="print concepts instead of a valuation",
+    )
+    opts.add_option(
+        "-r",
+        "--relation",
+        dest="label",
+        help="print concept with label REL (check possible labels with '-v' option)",
+        metavar="REL",
+    )
+    opts.add_option(
+        "-q",
+        "--quiet",
+        action="store_false",
+        dest="verbose",
+        help="don't print out progress info",
+    )
+    opts.add_option(
+        "-x",
+        "--lex",
+        action="store_true",
+        dest="lex",
+        help="write a file of lexical entries for country names, then exit",
+    )
+    opts.add_option(
+        "-v",
+        "--vocab",
+        action="store_true",
+        dest="vocab",
+        help="print out the vocabulary of concept labels and their arity, then exit",
+    )
+
+    (options, args) = opts.parse_args()
+    if options.outdb and options.indb:
+        opts.error("Options --store and --load are mutually exclusive")
+
+    if options.outdb:
+        # write the valuation to a persistent database
+        if options.verbose:
+            outdb = options.outdb + ".db"
+            print("Dumping a valuation to %s" % outdb)
+        val_dump(rels, options.outdb)
+        sys.exit(0)
+    else:
+        # try to read in a valuation from a database
+        if options.indb is not None:
+            dbname = options.indb + ".db"
+            if not os.access(dbname, os.R_OK):
+                sys.exit("Cannot read file: %s" % dbname)
+            else:
+                valuation = val_load(options.indb)
+        # we need to create the valuation from scratch
+        else:
+            # build some concepts
+            concept_map = process_bundle(rels)
+            concepts = concept_map.values()
+            # just print out the vocabulary
+            if options.vocab:
+                items = sorted((c.arity, c.prefLabel) for c in concepts)
+                for (arity, label) in items:
+                    print(label, arity)
+                sys.exit(0)
+            # show all the concepts
+            if options.concepts:
+                for c in concepts:
+                    print(c)
+                    print()
+            if options.label:
+                print(concept_map[options.label])
+                sys.exit(0)
+            else:
+                # turn the concepts into a Valuation
+                if options.lex:
+                    if options.verbose:
+                        print("Writing out lexical rules")
+                    make_valuation(concepts, lexicon=True)
+                else:
+                    valuation = make_valuation(concepts, read=True)
+                    print(valuation)
+
+
+def sql_demo():
+    """
+    Print out every row from the 'city.db' database.
+    """
+    print()
+    print("Using SQL to extract rows from 'city.db' RDB.")
+    for row in sql_query("corpora/city_database/city.db", "SELECT * FROM city_table"):
+        print(row)
+
+
+if __name__ == "__main__":
+    main()
+    sql_demo()

llmeval-env/lib/python3.10/site-packages/nltk/sem/cooper_storage.py

@@ -0,0 +1,124 @@
+# Natural Language Toolkit: Cooper storage for Quantifier Ambiguity
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Ewan Klein <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+from nltk.parse import load_parser
+from nltk.parse.featurechart import InstantiateVarsChart
+from nltk.sem.logic import ApplicationExpression, LambdaExpression, Variable
+
+
+class CooperStore:
+    """
+    A container for handling quantifier ambiguity via Cooper storage.
+    """
+
+    def __init__(self, featstruct):
+        """
+        :param featstruct: The value of the ``sem`` node in a tree from
+            ``parse_with_bindops()``
+        :type featstruct: FeatStruct (with features ``core`` and ``store``)
+
+        """
+        self.featstruct = featstruct
+        self.readings = []
+        try:
+            self.core = featstruct["CORE"]
+            self.store = featstruct["STORE"]
+        except KeyError:
+            print("%s is not a Cooper storage structure" % featstruct)
+
+    def _permute(self, lst):
+        """
+        :return: An iterator over the permutations of the input list
+        :type lst: list
+        :rtype: iter
+        """
+        remove = lambda lst0, index: lst0[:index] + lst0[index + 1 :]
+        if lst:
+            for index, x in enumerate(lst):
+                for y in self._permute(remove(lst, index)):
+                    yield (x,) + y
+        else:
+            yield ()
+
+    def s_retrieve(self, trace=False):
+        r"""
+        Carry out S-Retrieval of binding operators in store. If hack=True,
+        serialize the bindop and core as strings and reparse. Ugh.
+
+        Each permutation of the store (i.e. list of binding operators) is
+        taken to be a possible scoping of quantifiers. We iterate through the
+        binding operators in each permutation, and successively apply them to
+        the current term, starting with the core semantic representation,
+        working from the inside out.
+
+        Binding operators are of the form::
+
+             bo(\P.all x.(man(x) -> P(x)),z1)
+        """
+        for perm, store_perm in enumerate(self._permute(self.store)):
+            if trace:
+                print("Permutation %s" % (perm + 1))
+            term = self.core
+            for bindop in store_perm:
+                # we just want the arguments that are wrapped by the 'bo' predicate
+                quant, varex = tuple(bindop.args)
+                # use var to make an abstraction over the current term and then
+                # apply the quantifier to it
+                term = ApplicationExpression(
+                    quant, LambdaExpression(varex.variable, term)
+                )
+                if trace:
+                    print("  ", term)
+                term = term.simplify()
+            self.readings.append(term)
+
+
+def parse_with_bindops(sentence, grammar=None, trace=0):
+    """
+    Use a grammar with Binding Operators to parse a sentence.
+    """
+    if not grammar:
+        grammar = "grammars/book_grammars/storage.fcfg"
+    parser = load_parser(grammar, trace=trace, chart_class=InstantiateVarsChart)
+    # Parse the sentence.
+    tokens = sentence.split()
+    return list(parser.parse(tokens))
+
+
+def demo():
+    from nltk.sem import cooper_storage as cs
+
+    sentence = "every girl chases a dog"
+    # sentence = "a man gives a bone to every dog"
+    print()
+    print("Analysis of sentence '%s'" % sentence)
+    print("=" * 50)
+    trees = cs.parse_with_bindops(sentence, trace=0)
+    for tree in trees:
+        semrep = cs.CooperStore(tree.label()["SEM"])
+        print()
+        print("Binding operators:")
+        print("-" * 15)
+        for s in semrep.store:
+            print(s)
+        print()
+        print("Core:")
+        print("-" * 15)
+        print(semrep.core)
+        print()
+        print("S-Retrieval:")
+        print("-" * 15)
+        semrep.s_retrieve(trace=True)
+        print("Readings:")
+        print("-" * 15)
+
+        for i, reading in enumerate(semrep.readings):
+            print(f"{i + 1}: {reading}")
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/sem/drt.py

@@ -0,0 +1,1460 @@
+# Natural Language Toolkit: Discourse Representation Theory (DRT)
+#
+# Author: Dan Garrette <[email protected]>
+#
+# Copyright (C) 2001-2023 NLTK Project
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import operator
+from functools import reduce
+from itertools import chain
+
+from nltk.sem.logic import (
+    APP,
+    AbstractVariableExpression,
+    AllExpression,
+    AndExpression,
+    ApplicationExpression,
+    BinaryExpression,
+    BooleanExpression,
+    ConstantExpression,
+    EqualityExpression,
+    EventVariableExpression,
+    ExistsExpression,
+    Expression,
+    FunctionVariableExpression,
+    ImpExpression,
+    IndividualVariableExpression,
+    LambdaExpression,
+    LogicParser,
+    NegatedExpression,
+    OrExpression,
+    Tokens,
+    Variable,
+    is_eventvar,
+    is_funcvar,
+    is_indvar,
+    unique_variable,
+)
+
+# Import Tkinter-based modules if they are available
+try:
+    from tkinter import Canvas, Tk
+    from tkinter.font import Font
+
+    from nltk.util import in_idle
+
+except ImportError:
+    # No need to print a warning here, nltk.draw has already printed one.
+    pass
+
+
+class DrtTokens(Tokens):
+    DRS = "DRS"
+    DRS_CONC = "+"
+    PRONOUN = "PRO"
+    OPEN_BRACKET = "["
+    CLOSE_BRACKET = "]"
+    COLON = ":"
+
+    PUNCT = [DRS_CONC, OPEN_BRACKET, CLOSE_BRACKET, COLON]
+
+    SYMBOLS = Tokens.SYMBOLS + PUNCT
+
+    TOKENS = Tokens.TOKENS + [DRS] + PUNCT
+
+
+class DrtParser(LogicParser):
+    """A lambda calculus expression parser."""
+
+    def __init__(self):
+        LogicParser.__init__(self)
+
+        self.operator_precedence = dict(
+            [(x, 1) for x in DrtTokens.LAMBDA_LIST]
+            + [(x, 2) for x in DrtTokens.NOT_LIST]
+            + [(APP, 3)]
+            + [(x, 4) for x in DrtTokens.EQ_LIST + Tokens.NEQ_LIST]
+            + [(DrtTokens.COLON, 5)]
+            + [(DrtTokens.DRS_CONC, 6)]
+            + [(x, 7) for x in DrtTokens.OR_LIST]
+            + [(x, 8) for x in DrtTokens.IMP_LIST]
+            + [(None, 9)]
+        )
+
+    def get_all_symbols(self):
+        """This method exists to be overridden"""
+        return DrtTokens.SYMBOLS
+
+    def isvariable(self, tok):
+        return tok not in DrtTokens.TOKENS
+
+    def handle(self, tok, context):
+        """This method is intended to be overridden for logics that
+        use different operators or expressions"""
+        if tok in DrtTokens.NOT_LIST:
+            return self.handle_negation(tok, context)
+
+        elif tok in DrtTokens.LAMBDA_LIST:
+            return self.handle_lambda(tok, context)
+
+        elif tok == DrtTokens.OPEN:
+            if self.inRange(0) and self.token(0) == DrtTokens.OPEN_BRACKET:
+                return self.handle_DRS(tok, context)
+            else:
+                return self.handle_open(tok, context)
+
+        elif tok.upper() == DrtTokens.DRS:
+            self.assertNextToken(DrtTokens.OPEN)
+            return self.handle_DRS(tok, context)
+
+        elif self.isvariable(tok):
+            if self.inRange(0) and self.token(0) == DrtTokens.COLON:
+                return self.handle_prop(tok, context)
+            else:
+                return self.handle_variable(tok, context)
+
+    def make_NegatedExpression(self, expression):
+        return DrtNegatedExpression(expression)
+
+    def handle_DRS(self, tok, context):
+        # a DRS
+        refs = self.handle_refs()
+        if (
+            self.inRange(0) and self.token(0) == DrtTokens.COMMA
+        ):  # if there is a comma (it's optional)
+            self.token()  # swallow the comma
+        conds = self.handle_conds(context)
+        self.assertNextToken(DrtTokens.CLOSE)
+        return DRS(refs, conds, None)
+
+    def handle_refs(self):
+        self.assertNextToken(DrtTokens.OPEN_BRACKET)
+        refs = []
+        while self.inRange(0) and self.token(0) != DrtTokens.CLOSE_BRACKET:
+            # Support expressions like: DRS([x y],C) == DRS([x,y],C)
+            if refs and self.token(0) == DrtTokens.COMMA:
+                self.token()  # swallow the comma
+            refs.append(self.get_next_token_variable("quantified"))
+        self.assertNextToken(DrtTokens.CLOSE_BRACKET)
+        return refs
+
+    def handle_conds(self, context):
+        self.assertNextToken(DrtTokens.OPEN_BRACKET)
+        conds = []
+        while self.inRange(0) and self.token(0) != DrtTokens.CLOSE_BRACKET:
+            # Support expressions like: DRS([x y],C) == DRS([x, y],C)
+            if conds and self.token(0) == DrtTokens.COMMA:
+                self.token()  # swallow the comma
+            conds.append(self.process_next_expression(context))
+        self.assertNextToken(DrtTokens.CLOSE_BRACKET)
+        return conds
+
+    def handle_prop(self, tok, context):
+        variable = self.make_VariableExpression(tok)
+        self.assertNextToken(":")
+        drs = self.process_next_expression(DrtTokens.COLON)
+        return DrtProposition(variable, drs)
+
+    def make_EqualityExpression(self, first, second):
+        """This method serves as a hook for other logic parsers that
+        have different equality expression classes"""
+        return DrtEqualityExpression(first, second)
+
+    def get_BooleanExpression_factory(self, tok):
+        """This method serves as a hook for other logic parsers that
+        have different boolean operators"""
+        if tok == DrtTokens.DRS_CONC:
+            return lambda first, second: DrtConcatenation(first, second, None)
+        elif tok in DrtTokens.OR_LIST:
+            return DrtOrExpression
+        elif tok in DrtTokens.IMP_LIST:
+
+            def make_imp_expression(first, second):
+                if isinstance(first, DRS):
+                    return DRS(first.refs, first.conds, second)
+                if isinstance(first, DrtConcatenation):
+                    return DrtConcatenation(first.first, first.second, second)
+                raise Exception("Antecedent of implication must be a DRS")
+
+            return make_imp_expression
+        else:
+            return None
+
+    def make_BooleanExpression(self, factory, first, second):
+        return factory(first, second)
+
+    def make_ApplicationExpression(self, function, argument):
+        return DrtApplicationExpression(function, argument)
+
+    def make_VariableExpression(self, name):
+        return DrtVariableExpression(Variable(name))
+
+    def make_LambdaExpression(self, variables, term):
+        return DrtLambdaExpression(variables, term)
+
+
+class DrtExpression:
+    """
+    This is the base abstract DRT Expression from which every DRT
+    Expression extends.
+    """
+
+    _drt_parser = DrtParser()
+
+    @classmethod
+    def fromstring(cls, s):
+        return cls._drt_parser.parse(s)
+
+    def applyto(self, other):
+        return DrtApplicationExpression(self, other)
+
+    def __neg__(self):
+        return DrtNegatedExpression(self)
+
+    def __and__(self, other):
+        return NotImplemented
+
+    def __or__(self, other):
+        assert isinstance(other, DrtExpression)
+        return DrtOrExpression(self, other)
+
+    def __gt__(self, other):
+        assert isinstance(other, DrtExpression)
+        if isinstance(self, DRS):
+            return DRS(self.refs, self.conds, other)
+        if isinstance(self, DrtConcatenation):
+            return DrtConcatenation(self.first, self.second, other)
+        raise Exception("Antecedent of implication must be a DRS")
+
+    def equiv(self, other, prover=None):
+        """
+        Check for logical equivalence.
+        Pass the expression (self <-> other) to the theorem prover.
+        If the prover says it is valid, then the self and other are equal.
+
+        :param other: an ``DrtExpression`` to check equality against
+        :param prover: a ``nltk.inference.api.Prover``
+        """
+        assert isinstance(other, DrtExpression)
+
+        f1 = self.simplify().fol()
+        f2 = other.simplify().fol()
+        return f1.equiv(f2, prover)
+
+    @property
+    def type(self):
+        raise AttributeError(
+            "'%s' object has no attribute 'type'" % self.__class__.__name__
+        )
+
+    def typecheck(self, signature=None):
+        raise NotImplementedError()
+
+    def __add__(self, other):
+        return DrtConcatenation(self, other, None)
+
+    def get_refs(self, recursive=False):
+        """
+        Return the set of discourse referents in this DRS.
+        :param recursive: bool Also find discourse referents in subterms?
+        :return: list of ``Variable`` objects
+        """
+        raise NotImplementedError()
+
+    def is_pronoun_function(self):
+        """Is self of the form "PRO(x)"?"""
+        return (
+            isinstance(self, DrtApplicationExpression)
+            and isinstance(self.function, DrtAbstractVariableExpression)
+            and self.function.variable.name == DrtTokens.PRONOUN
+            and isinstance(self.argument, DrtIndividualVariableExpression)
+        )
+
+    def make_EqualityExpression(self, first, second):
+        return DrtEqualityExpression(first, second)
+
+    def make_VariableExpression(self, variable):
+        return DrtVariableExpression(variable)
+
+    def resolve_anaphora(self):
+        return resolve_anaphora(self)
+
+    def eliminate_equality(self):
+        return self.visit_structured(lambda e: e.eliminate_equality(), self.__class__)
+
+    def pretty_format(self):
+        """
+        Draw the DRS
+        :return: the pretty print string
+        """
+        return "\n".join(self._pretty())
+
+    def pretty_print(self):
+        print(self.pretty_format())
+
+    def draw(self):
+        DrsDrawer(self).draw()
+
+
+class DRS(DrtExpression, Expression):
+    """A Discourse Representation Structure."""
+
+    def __init__(self, refs, conds, consequent=None):
+        """
+        :param refs: list of ``DrtIndividualVariableExpression`` for the
+            discourse referents
+        :param conds: list of ``Expression`` for the conditions
+        """
+        self.refs = refs
+        self.conds = conds
+        self.consequent = consequent
+
+    def replace(self, variable, expression, replace_bound=False, alpha_convert=True):
+        """Replace all instances of variable v with expression E in self,
+        where v is free in self."""
+        if variable in self.refs:
+            # if a bound variable is the thing being replaced
+            if not replace_bound:
+                return self
+            else:
+                i = self.refs.index(variable)
+                if self.consequent:
+                    consequent = self.consequent.replace(
+                        variable, expression, True, alpha_convert
+                    )
+                else:
+                    consequent = None
+                return DRS(
+                    self.refs[:i] + [expression.variable] + self.refs[i + 1 :],
+                    [
+                        cond.replace(variable, expression, True, alpha_convert)
+                        for cond in self.conds
+                    ],
+                    consequent,
+                )
+        else:
+            if alpha_convert:
+                # any bound variable that appears in the expression must
+                # be alpha converted to avoid a conflict
+                for ref in set(self.refs) & expression.free():
+                    newvar = unique_variable(ref)
+                    newvarex = DrtVariableExpression(newvar)
+                    i = self.refs.index(ref)
+                    if self.consequent:
+                        consequent = self.consequent.replace(
+                            ref, newvarex, True, alpha_convert
+                        )
+                    else:
+                        consequent = None
+                    self = DRS(
+                        self.refs[:i] + [newvar] + self.refs[i + 1 :],
+                        [
+                            cond.replace(ref, newvarex, True, alpha_convert)
+                            for cond in self.conds
+                        ],
+                        consequent,
+                    )
+
+            # replace in the conditions
+            if self.consequent:
+                consequent = self.consequent.replace(
+                    variable, expression, replace_bound, alpha_convert
+                )
+            else:
+                consequent = None
+            return DRS(
+                self.refs,
+                [
+                    cond.replace(variable, expression, replace_bound, alpha_convert)
+                    for cond in self.conds
+                ],
+                consequent,
+            )
+
+    def free(self):
+        """:see: Expression.free()"""
+        conds_free = reduce(operator.or_, [c.free() for c in self.conds], set())
+        if self.consequent:
+            conds_free.update(self.consequent.free())
+        return conds_free - set(self.refs)
+
+    def get_refs(self, recursive=False):
+        """:see: AbstractExpression.get_refs()"""
+        if recursive:
+            conds_refs = self.refs + list(
+                chain.from_iterable(c.get_refs(True) for c in self.conds)
+            )
+            if self.consequent:
+                conds_refs.extend(self.consequent.get_refs(True))
+            return conds_refs
+        else:
+            return self.refs
+
+    def visit(self, function, combinator):
+        """:see: Expression.visit()"""
+        parts = list(map(function, self.conds))
+        if self.consequent:
+            parts.append(function(self.consequent))
+        return combinator(parts)
+
+    def visit_structured(self, function, combinator):
+        """:see: Expression.visit_structured()"""
+        consequent = function(self.consequent) if self.consequent else None
+        return combinator(self.refs, list(map(function, self.conds)), consequent)
+
+    def eliminate_equality(self):
+        drs = self
+        i = 0
+        while i < len(drs.conds):
+            cond = drs.conds[i]
+            if (
+                isinstance(cond, EqualityExpression)
+                and isinstance(cond.first, AbstractVariableExpression)
+                and isinstance(cond.second, AbstractVariableExpression)
+            ):
+                drs = DRS(
+                    list(set(drs.refs) - {cond.second.variable}),
+                    drs.conds[:i] + drs.conds[i + 1 :],
+                    drs.consequent,
+                )
+                if cond.second.variable != cond.first.variable:
+                    drs = drs.replace(cond.second.variable, cond.first, False, False)
+                    i = 0
+                i -= 1
+            i += 1
+
+        conds = []
+        for cond in drs.conds:
+            new_cond = cond.eliminate_equality()
+            new_cond_simp = new_cond.simplify()
+            if (
+                not isinstance(new_cond_simp, DRS)
+                or new_cond_simp.refs
+                or new_cond_simp.conds
+                or new_cond_simp.consequent
+            ):
+                conds.append(new_cond)
+
+        consequent = drs.consequent.eliminate_equality() if drs.consequent else None
+        return DRS(drs.refs, conds, consequent)
+
+    def fol(self):
+        if self.consequent:
+            accum = None
+            if self.conds:
+                accum = reduce(AndExpression, [c.fol() for c in self.conds])
+
+            if accum:
+                accum = ImpExpression(accum, self.consequent.fol())
+            else:
+                accum = self.consequent.fol()
+
+            for ref in self.refs[::-1]:
+                accum = AllExpression(ref, accum)
+
+            return accum
+
+        else:
+            if not self.conds:
+                raise Exception("Cannot convert DRS with no conditions to FOL.")
+            accum = reduce(AndExpression, [c.fol() for c in self.conds])
+            for ref in map(Variable, self._order_ref_strings(self.refs)[::-1]):
+                accum = ExistsExpression(ref, accum)
+            return accum
+
+    def _pretty(self):
+        refs_line = " ".join(self._order_ref_strings(self.refs))
+
+        cond_lines = [
+            cond
+            for cond_line in [
+                filter(lambda s: s.strip(), cond._pretty()) for cond in self.conds
+            ]
+            for cond in cond_line
+        ]
+        length = max([len(refs_line)] + list(map(len, cond_lines)))
+        drs = (
+            [
+                " _" + "_" * length + "_ ",
+                "| " + refs_line.ljust(length) + " |",
+                "|-" + "-" * length + "-|",
+            ]
+            + ["| " + line.ljust(length) + " |" for line in cond_lines]
+            + ["|_" + "_" * length + "_|"]
+        )
+        if self.consequent:
+            return DrtBinaryExpression._assemble_pretty(
+                drs, DrtTokens.IMP, self.consequent._pretty()
+            )
+        return drs
+
+    def _order_ref_strings(self, refs):
+        strings = ["%s" % ref for ref in refs]
+        ind_vars = []
+        func_vars = []
+        event_vars = []
+        other_vars = []
+        for s in strings:
+            if is_indvar(s):
+                ind_vars.append(s)
+            elif is_funcvar(s):
+                func_vars.append(s)
+            elif is_eventvar(s):
+                event_vars.append(s)
+            else:
+                other_vars.append(s)
+        return (
+            sorted(other_vars)
+            + sorted(event_vars, key=lambda v: int([v[2:], -1][len(v[2:]) == 0]))
+            + sorted(func_vars, key=lambda v: (v[0], int([v[1:], -1][len(v[1:]) == 0])))
+            + sorted(ind_vars, key=lambda v: (v[0], int([v[1:], -1][len(v[1:]) == 0])))
+        )
+
+    def __eq__(self, other):
+        r"""Defines equality modulo alphabetic variance.
+        If we are comparing \x.M  and \y.N, then check equality of M and N[x/y]."""
+        if isinstance(other, DRS):
+            if len(self.refs) == len(other.refs):
+                converted_other = other
+                for (r1, r2) in zip(self.refs, converted_other.refs):
+                    varex = self.make_VariableExpression(r1)
+                    converted_other = converted_other.replace(r2, varex, True)
+                if self.consequent == converted_other.consequent and len(
+                    self.conds
+                ) == len(converted_other.conds):
+                    for c1, c2 in zip(self.conds, converted_other.conds):
+                        if not (c1 == c2):
+                            return False
+                    return True
+        return False
+
+    def __ne__(self, other):
+        return not self == other
+
+    __hash__ = Expression.__hash__
+
+    def __str__(self):
+        drs = "([{}],[{}])".format(
+            ",".join(self._order_ref_strings(self.refs)),
+            ", ".join("%s" % cond for cond in self.conds),
+        )  # map(str, self.conds)))
+        if self.consequent:
+            return (
+                DrtTokens.OPEN
+                + drs
+                + " "
+                + DrtTokens.IMP
+                + " "
+                + "%s" % self.consequent
+                + DrtTokens.CLOSE
+            )
+        return drs
+
+
+def DrtVariableExpression(variable):
+    """
+    This is a factory method that instantiates and returns a subtype of
+    ``DrtAbstractVariableExpression`` appropriate for the given variable.
+    """
+    if is_indvar(variable.name):
+        return DrtIndividualVariableExpression(variable)
+    elif is_funcvar(variable.name):
+        return DrtFunctionVariableExpression(variable)
+    elif is_eventvar(variable.name):
+        return DrtEventVariableExpression(variable)
+    else:
+        return DrtConstantExpression(variable)
+
+
+class DrtAbstractVariableExpression(DrtExpression, AbstractVariableExpression):
+    def fol(self):
+        return self
+
+    def get_refs(self, recursive=False):
+        """:see: AbstractExpression.get_refs()"""
+        return []
+
+    def _pretty(self):
+        s = "%s" % self
+        blank = " " * len(s)
+        return [blank, blank, s, blank]
+
+    def eliminate_equality(self):
+        return self
+
+
+class DrtIndividualVariableExpression(
+    DrtAbstractVariableExpression, IndividualVariableExpression
+):
+    pass
+
+
+class DrtFunctionVariableExpression(
+    DrtAbstractVariableExpression, FunctionVariableExpression
+):
+    pass
+
+
+class DrtEventVariableExpression(
+    DrtIndividualVariableExpression, EventVariableExpression
+):
+    pass
+
+
+class DrtConstantExpression(DrtAbstractVariableExpression, ConstantExpression):
+    pass
+
+
+class DrtProposition(DrtExpression, Expression):
+    def __init__(self, variable, drs):
+        self.variable = variable
+        self.drs = drs
+
+    def replace(self, variable, expression, replace_bound=False, alpha_convert=True):
+        if self.variable == variable:
+            assert isinstance(
+                expression, DrtAbstractVariableExpression
+            ), "Can only replace a proposition label with a variable"
+            return DrtProposition(
+                expression.variable,
+                self.drs.replace(variable, expression, replace_bound, alpha_convert),
+            )
+        else:
+            return DrtProposition(
+                self.variable,
+                self.drs.replace(variable, expression, replace_bound, alpha_convert),
+            )
+
+    def eliminate_equality(self):
+        return DrtProposition(self.variable, self.drs.eliminate_equality())
+
+    def get_refs(self, recursive=False):
+        return self.drs.get_refs(True) if recursive else []
+
+    def __eq__(self, other):
+        return (
+            self.__class__ == other.__class__
+            and self.variable == other.variable
+            and self.drs == other.drs
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    __hash__ = Expression.__hash__
+
+    def fol(self):
+        return self.drs.fol()
+
+    def _pretty(self):
+        drs_s = self.drs._pretty()
+        blank = " " * len("%s" % self.variable)
+        return (
+            [blank + " " + line for line in drs_s[:1]]
+            + ["%s" % self.variable + ":" + line for line in drs_s[1:2]]
+            + [blank + " " + line for line in drs_s[2:]]
+        )
+
+    def visit(self, function, combinator):
+        """:see: Expression.visit()"""
+        return combinator([function(self.drs)])
+
+    def visit_structured(self, function, combinator):
+        """:see: Expression.visit_structured()"""
+        return combinator(self.variable, function(self.drs))
+
+    def __str__(self):
+        return f"prop({self.variable}, {self.drs})"
+
+
+class DrtNegatedExpression(DrtExpression, NegatedExpression):
+    def fol(self):
+        return NegatedExpression(self.term.fol())
+
+    def get_refs(self, recursive=False):
+        """:see: AbstractExpression.get_refs()"""
+        return self.term.get_refs(recursive)
+
+    def _pretty(self):
+        term_lines = self.term._pretty()
+        return (
+            ["    " + line for line in term_lines[:2]]
+            + ["__  " + line for line in term_lines[2:3]]
+            + ["  | " + line for line in term_lines[3:4]]
+            + ["    " + line for line in term_lines[4:]]
+        )
+
+
+class DrtLambdaExpression(DrtExpression, LambdaExpression):
+    def alpha_convert(self, newvar):
+        """Rename all occurrences of the variable introduced by this variable
+        binder in the expression to ``newvar``.
+        :param newvar: ``Variable``, for the new variable
+        """
+        return self.__class__(
+            newvar,
+            self.term.replace(self.variable, DrtVariableExpression(newvar), True),
+        )
+
+    def fol(self):
+        return LambdaExpression(self.variable, self.term.fol())
+
+    def _pretty(self):
+        variables = [self.variable]
+        term = self.term
+        while term.__class__ == self.__class__:
+            variables.append(term.variable)
+            term = term.term
+        var_string = " ".join("%s" % v for v in variables) + DrtTokens.DOT
+        term_lines = term._pretty()
+        blank = " " * len(var_string)
+        return (
+            ["    " + blank + line for line in term_lines[:1]]
+            + [r" \  " + blank + line for line in term_lines[1:2]]
+            + [r" /\ " + var_string + line for line in term_lines[2:3]]
+            + ["    " + blank + line for line in term_lines[3:]]
+        )
+
+    def get_refs(self, recursive=False):
+        """:see: AbstractExpression.get_refs()"""
+        return (
+            [self.variable] + self.term.get_refs(True) if recursive else [self.variable]
+        )
+
+
+class DrtBinaryExpression(DrtExpression, BinaryExpression):
+    def get_refs(self, recursive=False):
+        """:see: AbstractExpression.get_refs()"""
+        return (
+            self.first.get_refs(True) + self.second.get_refs(True) if recursive else []
+        )
+
+    def _pretty(self):
+        return DrtBinaryExpression._assemble_pretty(
+            self._pretty_subex(self.first),
+            self.getOp(),
+            self._pretty_subex(self.second),
+        )
+
+    @staticmethod
+    def _assemble_pretty(first_lines, op, second_lines):
+        max_lines = max(len(first_lines), len(second_lines))
+        first_lines = _pad_vertically(first_lines, max_lines)
+        second_lines = _pad_vertically(second_lines, max_lines)
+        blank = " " * len(op)
+        first_second_lines = list(zip(first_lines, second_lines))
+        return (
+            [
+                " " + first_line + " " + blank + " " + second_line + " "
+                for first_line, second_line in first_second_lines[:2]
+            ]
+            + [
+                "(" + first_line + " " + op + " " + second_line + ")"
+                for first_line, second_line in first_second_lines[2:3]
+            ]
+            + [
+                " " + first_line + " " + blank + " " + second_line + " "
+                for first_line, second_line in first_second_lines[3:]
+            ]
+        )
+
+    def _pretty_subex(self, subex):
+        return subex._pretty()
+
+
+class DrtBooleanExpression(DrtBinaryExpression, BooleanExpression):
+    pass
+
+
+class DrtOrExpression(DrtBooleanExpression, OrExpression):
+    def fol(self):
+        return OrExpression(self.first.fol(), self.second.fol())
+
+    def _pretty_subex(self, subex):
+        if isinstance(subex, DrtOrExpression):
+            return [line[1:-1] for line in subex._pretty()]
+        return DrtBooleanExpression._pretty_subex(self, subex)
+
+
+class DrtEqualityExpression(DrtBinaryExpression, EqualityExpression):
+    def fol(self):
+        return EqualityExpression(self.first.fol(), self.second.fol())
+
+
+class DrtConcatenation(DrtBooleanExpression):
+    """DRS of the form '(DRS + DRS)'"""
+
+    def __init__(self, first, second, consequent=None):
+        DrtBooleanExpression.__init__(self, first, second)
+        self.consequent = consequent
+
+    def replace(self, variable, expression, replace_bound=False, alpha_convert=True):
+        """Replace all instances of variable v with expression E in self,
+        where v is free in self."""
+        first = self.first
+        second = self.second
+        consequent = self.consequent
+
+        # If variable is bound
+        if variable in self.get_refs():
+            if replace_bound:
+                first = first.replace(
+                    variable, expression, replace_bound, alpha_convert
+                )
+                second = second.replace(
+                    variable, expression, replace_bound, alpha_convert
+                )
+                if consequent:
+                    consequent = consequent.replace(
+                        variable, expression, replace_bound, alpha_convert
+                    )
+        else:
+            if alpha_convert:
+                # alpha convert every ref that is free in 'expression'
+                for ref in set(self.get_refs(True)) & expression.free():
+                    v = DrtVariableExpression(unique_variable(ref))
+                    first = first.replace(ref, v, True, alpha_convert)
+                    second = second.replace(ref, v, True, alpha_convert)
+                    if consequent:
+                        consequent = consequent.replace(ref, v, True, alpha_convert)
+
+            first = first.replace(variable, expression, replace_bound, alpha_convert)
+            second = second.replace(variable, expression, replace_bound, alpha_convert)
+            if consequent:
+                consequent = consequent.replace(
+                    variable, expression, replace_bound, alpha_convert
+                )
+
+        return self.__class__(first, second, consequent)
+
+    def eliminate_equality(self):
+        # TODO: at some point.  for now, simplify.
+        drs = self.simplify()
+        assert not isinstance(drs, DrtConcatenation)
+        return drs.eliminate_equality()
+
+    def simplify(self):
+        first = self.first.simplify()
+        second = self.second.simplify()
+        consequent = self.consequent.simplify() if self.consequent else None
+
+        if isinstance(first, DRS) and isinstance(second, DRS):
+            # For any ref that is in both 'first' and 'second'
+            for ref in set(first.get_refs(True)) & set(second.get_refs(True)):
+                # alpha convert the ref in 'second' to prevent collision
+                newvar = DrtVariableExpression(unique_variable(ref))
+                second = second.replace(ref, newvar, True)
+
+            return DRS(first.refs + second.refs, first.conds + second.conds, consequent)
+        else:
+            return self.__class__(first, second, consequent)
+
+    def get_refs(self, recursive=False):
+        """:see: AbstractExpression.get_refs()"""
+        refs = self.first.get_refs(recursive) + self.second.get_refs(recursive)
+        if self.consequent and recursive:
+            refs.extend(self.consequent.get_refs(True))
+        return refs
+
+    def getOp(self):
+        return DrtTokens.DRS_CONC
+
+    def __eq__(self, other):
+        r"""Defines equality modulo alphabetic variance.
+        If we are comparing \x.M  and \y.N, then check equality of M and N[x/y]."""
+        if isinstance(other, DrtConcatenation):
+            self_refs = self.get_refs()
+            other_refs = other.get_refs()
+            if len(self_refs) == len(other_refs):
+                converted_other = other
+                for (r1, r2) in zip(self_refs, other_refs):
+                    varex = self.make_VariableExpression(r1)
+                    converted_other = converted_other.replace(r2, varex, True)
+                return (
+                    self.first == converted_other.first
+                    and self.second == converted_other.second
+                    and self.consequent == converted_other.consequent
+                )
+        return False
+
+    def __ne__(self, other):
+        return not self == other
+
+    __hash__ = DrtBooleanExpression.__hash__
+
+    def fol(self):
+        e = AndExpression(self.first.fol(), self.second.fol())
+        if self.consequent:
+            e = ImpExpression(e, self.consequent.fol())
+        return e
+
+    def _pretty(self):
+        drs = DrtBinaryExpression._assemble_pretty(
+            self._pretty_subex(self.first),
+            self.getOp(),
+            self._pretty_subex(self.second),
+        )
+        if self.consequent:
+            drs = DrtBinaryExpression._assemble_pretty(
+                drs, DrtTokens.IMP, self.consequent._pretty()
+            )
+        return drs
+
+    def _pretty_subex(self, subex):
+        if isinstance(subex, DrtConcatenation):
+            return [line[1:-1] for line in subex._pretty()]
+        return DrtBooleanExpression._pretty_subex(self, subex)
+
+    def visit(self, function, combinator):
+        """:see: Expression.visit()"""
+        if self.consequent:
+            return combinator(
+                [function(self.first), function(self.second), function(self.consequent)]
+            )
+        else:
+            return combinator([function(self.first), function(self.second)])
+
+    def __str__(self):
+        first = self._str_subex(self.first)
+        second = self._str_subex(self.second)
+        drs = Tokens.OPEN + first + " " + self.getOp() + " " + second + Tokens.CLOSE
+        if self.consequent:
+            return (
+                DrtTokens.OPEN
+                + drs
+                + " "
+                + DrtTokens.IMP
+                + " "
+                + "%s" % self.consequent
+                + DrtTokens.CLOSE
+            )
+        return drs
+
+    def _str_subex(self, subex):
+        s = "%s" % subex
+        if isinstance(subex, DrtConcatenation) and subex.consequent is None:
+            return s[1:-1]
+        return s
+
+
+class DrtApplicationExpression(DrtExpression, ApplicationExpression):
+    def fol(self):
+        return ApplicationExpression(self.function.fol(), self.argument.fol())
+
+    def get_refs(self, recursive=False):
+        """:see: AbstractExpression.get_refs()"""
+        return (
+            self.function.get_refs(True) + self.argument.get_refs(True)
+            if recursive
+            else []
+        )
+
+    def _pretty(self):
+        function, args = self.uncurry()
+        function_lines = function._pretty()
+        args_lines = [arg._pretty() for arg in args]
+        max_lines = max(map(len, [function_lines] + args_lines))
+        function_lines = _pad_vertically(function_lines, max_lines)
+        args_lines = [_pad_vertically(arg_lines, max_lines) for arg_lines in args_lines]
+        func_args_lines = list(zip(function_lines, list(zip(*args_lines))))
+        return (
+            [
+                func_line + " " + " ".join(args_line) + " "
+                for func_line, args_line in func_args_lines[:2]
+            ]
+            + [
+                func_line + "(" + ",".join(args_line) + ")"
+                for func_line, args_line in func_args_lines[2:3]
+            ]
+            + [
+                func_line + " " + " ".join(args_line) + " "
+                for func_line, args_line in func_args_lines[3:]
+            ]
+        )
+
+
+def _pad_vertically(lines, max_lines):
+    pad_line = [" " * len(lines[0])]
+    return lines + pad_line * (max_lines - len(lines))
+
+
+class PossibleAntecedents(list, DrtExpression, Expression):
+    def free(self):
+        """Set of free variables."""
+        return set(self)
+
+    def replace(self, variable, expression, replace_bound=False, alpha_convert=True):
+        """Replace all instances of variable v with expression E in self,
+        where v is free in self."""
+        result = PossibleAntecedents()
+        for item in self:
+            if item == variable:
+                self.append(expression)
+            else:
+                self.append(item)
+        return result
+
+    def _pretty(self):
+        s = "%s" % self
+        blank = " " * len(s)
+        return [blank, blank, s]
+
+    def __str__(self):
+        return "[" + ",".join("%s" % it for it in self) + "]"
+
+
+class AnaphoraResolutionException(Exception):
+    pass
+
+
+def resolve_anaphora(expression, trail=[]):
+    if isinstance(expression, ApplicationExpression):
+        if expression.is_pronoun_function():
+            possible_antecedents = PossibleAntecedents()
+            for ancestor in trail:
+                for ref in ancestor.get_refs():
+                    refex = expression.make_VariableExpression(ref)
+
+                    # ==========================================================
+                    # Don't allow resolution to itself or other types
+                    # ==========================================================
+                    if refex.__class__ == expression.argument.__class__ and not (
+                        refex == expression.argument
+                    ):
+                        possible_antecedents.append(refex)
+
+            if len(possible_antecedents) == 1:
+                resolution = possible_antecedents[0]
+            else:
+                resolution = possible_antecedents
+            return expression.make_EqualityExpression(expression.argument, resolution)
+        else:
+            r_function = resolve_anaphora(expression.function, trail + [expression])
+            r_argument = resolve_anaphora(expression.argument, trail + [expression])
+            return expression.__class__(r_function, r_argument)
+
+    elif isinstance(expression, DRS):
+        r_conds = []
+        for cond in expression.conds:
+            r_cond = resolve_anaphora(cond, trail + [expression])
+
+            # if the condition is of the form '(x = [])' then raise exception
+            if isinstance(r_cond, EqualityExpression):
+                if isinstance(r_cond.first, PossibleAntecedents):
+                    # Reverse the order so that the variable is on the left
+                    temp = r_cond.first
+                    r_cond.first = r_cond.second
+                    r_cond.second = temp
+                if isinstance(r_cond.second, PossibleAntecedents):
+                    if not r_cond.second:
+                        raise AnaphoraResolutionException(
+                            "Variable '%s' does not "
+                            "resolve to anything." % r_cond.first
+                        )
+
+            r_conds.append(r_cond)
+        if expression.consequent:
+            consequent = resolve_anaphora(expression.consequent, trail + [expression])
+        else:
+            consequent = None
+        return expression.__class__(expression.refs, r_conds, consequent)
+
+    elif isinstance(expression, AbstractVariableExpression):
+        return expression
+
+    elif isinstance(expression, NegatedExpression):
+        return expression.__class__(
+            resolve_anaphora(expression.term, trail + [expression])
+        )
+
+    elif isinstance(expression, DrtConcatenation):
+        if expression.consequent:
+            consequent = resolve_anaphora(expression.consequent, trail + [expression])
+        else:
+            consequent = None
+        return expression.__class__(
+            resolve_anaphora(expression.first, trail + [expression]),
+            resolve_anaphora(expression.second, trail + [expression]),
+            consequent,
+        )
+
+    elif isinstance(expression, BinaryExpression):
+        return expression.__class__(
+            resolve_anaphora(expression.first, trail + [expression]),
+            resolve_anaphora(expression.second, trail + [expression]),
+        )
+
+    elif isinstance(expression, LambdaExpression):
+        return expression.__class__(
+            expression.variable, resolve_anaphora(expression.term, trail + [expression])
+        )
+
+
+class DrsDrawer:
+    BUFFER = 3  # Space between elements
+    TOPSPACE = 10  # Space above whole DRS
+    OUTERSPACE = 6  # Space to the left, right, and bottom of the while DRS
+
+    def __init__(self, drs, size_canvas=True, canvas=None):
+        """
+        :param drs: ``DrtExpression``, The DRS to be drawn
+        :param size_canvas: bool, True if the canvas size should be the exact size of the DRS
+        :param canvas: ``Canvas`` The canvas on which to draw the DRS.  If none is given, create a new canvas.
+        """
+        master = None
+        if not canvas:
+            master = Tk()
+            master.title("DRT")
+
+            font = Font(family="helvetica", size=12)
+
+            if size_canvas:
+                canvas = Canvas(master, width=0, height=0)
+                canvas.font = font
+                self.canvas = canvas
+                (right, bottom) = self._visit(drs, self.OUTERSPACE, self.TOPSPACE)
+
+                width = max(right + self.OUTERSPACE, 100)
+                height = bottom + self.OUTERSPACE
+                canvas = Canvas(master, width=width, height=height)  # , bg='white')
+            else:
+                canvas = Canvas(master, width=300, height=300)
+
+            canvas.pack()
+            canvas.font = font
+
+        self.canvas = canvas
+        self.drs = drs
+        self.master = master
+
+    def _get_text_height(self):
+        """Get the height of a line of text"""
+        return self.canvas.font.metrics("linespace")
+
+    def draw(self, x=OUTERSPACE, y=TOPSPACE):
+        """Draw the DRS"""
+        self._handle(self.drs, self._draw_command, x, y)
+
+        if self.master and not in_idle():
+            self.master.mainloop()
+        else:
+            return self._visit(self.drs, x, y)
+
+    def _visit(self, expression, x, y):
+        """
+        Return the bottom-rightmost point without actually drawing the item
+
+        :param expression: the item to visit
+        :param x: the top of the current drawing area
+        :param y: the left side of the current drawing area
+        :return: the bottom-rightmost point
+        """
+        return self._handle(expression, self._visit_command, x, y)
+
+    def _draw_command(self, item, x, y):
+        """
+        Draw the given item at the given location
+
+        :param item: the item to draw
+        :param x: the top of the current drawing area
+        :param y: the left side of the current drawing area
+        :return: the bottom-rightmost point
+        """
+        if isinstance(item, str):
+            self.canvas.create_text(x, y, anchor="nw", font=self.canvas.font, text=item)
+        elif isinstance(item, tuple):
+            # item is the lower-right of a box
+            (right, bottom) = item
+            self.canvas.create_rectangle(x, y, right, bottom)
+            horiz_line_y = (
+                y + self._get_text_height() + (self.BUFFER * 2)
+            )  # the line separating refs from conds
+            self.canvas.create_line(x, horiz_line_y, right, horiz_line_y)
+
+        return self._visit_command(item, x, y)
+
+    def _visit_command(self, item, x, y):
+        """
+        Return the bottom-rightmost point without actually drawing the item
+
+        :param item: the item to visit
+        :param x: the top of the current drawing area
+        :param y: the left side of the current drawing area
+        :return: the bottom-rightmost point
+        """
+        if isinstance(item, str):
+            return (x + self.canvas.font.measure(item), y + self._get_text_height())
+        elif isinstance(item, tuple):
+            return item
+
+    def _handle(self, expression, command, x=0, y=0):
+        """
+        :param expression: the expression to handle
+        :param command: the function to apply, either _draw_command or _visit_command
+        :param x: the top of the current drawing area
+        :param y: the left side of the current drawing area
+        :return: the bottom-rightmost point
+        """
+        if command == self._visit_command:
+            # if we don't need to draw the item, then we can use the cached values
+            try:
+                # attempt to retrieve cached values
+                right = expression._drawing_width + x
+                bottom = expression._drawing_height + y
+                return (right, bottom)
+            except AttributeError:
+                # the values have not been cached yet, so compute them
+                pass
+
+        if isinstance(expression, DrtAbstractVariableExpression):
+            factory = self._handle_VariableExpression
+        elif isinstance(expression, DRS):
+            factory = self._handle_DRS
+        elif isinstance(expression, DrtNegatedExpression):
+            factory = self._handle_NegatedExpression
+        elif isinstance(expression, DrtLambdaExpression):
+            factory = self._handle_LambdaExpression
+        elif isinstance(expression, BinaryExpression):
+            factory = self._handle_BinaryExpression
+        elif isinstance(expression, DrtApplicationExpression):
+            factory = self._handle_ApplicationExpression
+        elif isinstance(expression, PossibleAntecedents):
+            factory = self._handle_VariableExpression
+        elif isinstance(expression, DrtProposition):
+            factory = self._handle_DrtProposition
+        else:
+            raise Exception(expression.__class__.__name__)
+
+        (right, bottom) = factory(expression, command, x, y)
+
+        # cache the values
+        expression._drawing_width = right - x
+        expression._drawing_height = bottom - y
+
+        return (right, bottom)
+
+    def _handle_VariableExpression(self, expression, command, x, y):
+        return command("%s" % expression, x, y)
+
+    def _handle_NegatedExpression(self, expression, command, x, y):
+        # Find the width of the negation symbol
+        right = self._visit_command(DrtTokens.NOT, x, y)[0]
+
+        # Handle term
+        (right, bottom) = self._handle(expression.term, command, right, y)
+
+        # Handle variables now that we know the y-coordinate
+        command(
+            DrtTokens.NOT,
+            x,
+            self._get_centered_top(y, bottom - y, self._get_text_height()),
+        )
+
+        return (right, bottom)
+
+    def _handle_DRS(self, expression, command, x, y):
+        left = x + self.BUFFER  # indent the left side
+        bottom = y + self.BUFFER  # indent the top
+
+        # Handle Discourse Referents
+        if expression.refs:
+            refs = " ".join("%s" % r for r in expression.refs)
+        else:
+            refs = "     "
+        (max_right, bottom) = command(refs, left, bottom)
+        bottom += self.BUFFER * 2
+
+        # Handle Conditions
+        if expression.conds:
+            for cond in expression.conds:
+                (right, bottom) = self._handle(cond, command, left, bottom)
+                max_right = max(max_right, right)
+                bottom += self.BUFFER
+        else:
+            bottom += self._get_text_height() + self.BUFFER
+
+        # Handle Box
+        max_right += self.BUFFER
+        return command((max_right, bottom), x, y)
+
+    def _handle_ApplicationExpression(self, expression, command, x, y):
+        function, args = expression.uncurry()
+        if not isinstance(function, DrtAbstractVariableExpression):
+            # It's not a predicate expression ("P(x,y)"), so leave arguments curried
+            function = expression.function
+            args = [expression.argument]
+
+        # Get the max bottom of any element on the line
+        function_bottom = self._visit(function, x, y)[1]
+        max_bottom = max(
+            [function_bottom] + [self._visit(arg, x, y)[1] for arg in args]
+        )
+
+        line_height = max_bottom - y
+
+        # Handle 'function'
+        function_drawing_top = self._get_centered_top(
+            y, line_height, function._drawing_height
+        )
+        right = self._handle(function, command, x, function_drawing_top)[0]
+
+        # Handle open paren
+        centred_string_top = self._get_centered_top(
+            y, line_height, self._get_text_height()
+        )
+        right = command(DrtTokens.OPEN, right, centred_string_top)[0]
+
+        # Handle each arg
+        for (i, arg) in enumerate(args):
+            arg_drawing_top = self._get_centered_top(
+                y, line_height, arg._drawing_height
+            )
+            right = self._handle(arg, command, right, arg_drawing_top)[0]
+
+            if i + 1 < len(args):
+                # since it's not the last arg, add a comma
+                right = command(DrtTokens.COMMA + " ", right, centred_string_top)[0]
+
+        # Handle close paren
+        right = command(DrtTokens.CLOSE, right, centred_string_top)[0]
+
+        return (right, max_bottom)
+
+    def _handle_LambdaExpression(self, expression, command, x, y):
+        # Find the width of the lambda symbol and abstracted variables
+        variables = DrtTokens.LAMBDA + "%s" % expression.variable + DrtTokens.DOT
+        right = self._visit_command(variables, x, y)[0]
+
+        # Handle term
+        (right, bottom) = self._handle(expression.term, command, right, y)
+
+        # Handle variables now that we know the y-coordinate
+        command(
+            variables, x, self._get_centered_top(y, bottom - y, self._get_text_height())
+        )
+
+        return (right, bottom)
+
+    def _handle_BinaryExpression(self, expression, command, x, y):
+        # Get the full height of the line, based on the operands
+        first_height = self._visit(expression.first, 0, 0)[1]
+        second_height = self._visit(expression.second, 0, 0)[1]
+        line_height = max(first_height, second_height)
+
+        # Handle open paren
+        centred_string_top = self._get_centered_top(
+            y, line_height, self._get_text_height()
+        )
+        right = command(DrtTokens.OPEN, x, centred_string_top)[0]
+
+        # Handle the first operand
+        first_height = expression.first._drawing_height
+        (right, first_bottom) = self._handle(
+            expression.first,
+            command,
+            right,
+            self._get_centered_top(y, line_height, first_height),
+        )
+
+        # Handle the operator
+        right = command(" %s " % expression.getOp(), right, centred_string_top)[0]
+
+        # Handle the second operand
+        second_height = expression.second._drawing_height
+        (right, second_bottom) = self._handle(
+            expression.second,
+            command,
+            right,
+            self._get_centered_top(y, line_height, second_height),
+        )
+
+        # Handle close paren
+        right = command(DrtTokens.CLOSE, right, centred_string_top)[0]
+
+        return (right, max(first_bottom, second_bottom))
+
+    def _handle_DrtProposition(self, expression, command, x, y):
+        # Find the width of the negation symbol
+        right = command(expression.variable, x, y)[0]
+
+        # Handle term
+        (right, bottom) = self._handle(expression.term, command, right, y)
+
+        return (right, bottom)
+
+    def _get_centered_top(self, top, full_height, item_height):
+        """Get the y-coordinate of the point that a figure should start at if
+        its height is 'item_height' and it needs to be centered in an area that
+        starts at 'top' and is 'full_height' tall."""
+        return top + (full_height - item_height) / 2
+
+
+def demo():
+    print("=" * 20 + "TEST PARSE" + "=" * 20)
+    dexpr = DrtExpression.fromstring
+    print(dexpr(r"([x,y],[sees(x,y)])"))
+    print(dexpr(r"([x],[man(x), walks(x)])"))
+    print(dexpr(r"\x.\y.([],[sees(x,y)])"))
+    print(dexpr(r"\x.([],[walks(x)])(john)"))
+    print(dexpr(r"(([x],[walks(x)]) + ([y],[runs(y)]))"))
+    print(dexpr(r"(([],[walks(x)]) -> ([],[runs(x)]))"))
+    print(dexpr(r"([x],[PRO(x), sees(John,x)])"))
+    print(dexpr(r"([x],[man(x), -([],[walks(x)])])"))
+    print(dexpr(r"([],[(([x],[man(x)]) -> ([],[walks(x)]))])"))
+
+    print("=" * 20 + "Test fol()" + "=" * 20)
+    print(dexpr(r"([x,y],[sees(x,y)])").fol())
+
+    print("=" * 20 + "Test alpha conversion and lambda expression equality" + "=" * 20)
+    e1 = dexpr(r"\x.([],[P(x)])")
+    print(e1)
+    e2 = e1.alpha_convert(Variable("z"))
+    print(e2)
+    print(e1 == e2)
+
+    print("=" * 20 + "Test resolve_anaphora()" + "=" * 20)
+    print(resolve_anaphora(dexpr(r"([x,y,z],[dog(x), cat(y), walks(z), PRO(z)])")))
+    print(
+        resolve_anaphora(dexpr(r"([],[(([x],[dog(x)]) -> ([y],[walks(y), PRO(y)]))])"))
+    )
+    print(resolve_anaphora(dexpr(r"(([x,y],[]) + ([],[PRO(x)]))")))
+
+    print("=" * 20 + "Test pretty_print()" + "=" * 20)
+    dexpr(r"([],[])").pretty_print()
+    dexpr(
+        r"([],[([x],[big(x), dog(x)]) -> ([],[bark(x)]) -([x],[walk(x)])])"
+    ).pretty_print()
+    dexpr(r"([x,y],[x=y]) + ([z],[dog(z), walk(z)])").pretty_print()
+    dexpr(r"([],[([x],[]) | ([y],[]) | ([z],[dog(z), walk(z)])])").pretty_print()
+    dexpr(r"\P.\Q.(([x],[]) + P(x) + Q(x))(\x.([],[dog(x)]))").pretty_print()
+
+
+def test_draw():
+    try:
+        from tkinter import Tk
+    except ImportError as e:
+        raise ValueError("tkinter is required, but it's not available.")
+
+    expressions = [
+        r"x",
+        r"([],[])",
+        r"([x],[])",
+        r"([x],[man(x)])",
+        r"([x,y],[sees(x,y)])",
+        r"([x],[man(x), walks(x)])",
+        r"\x.([],[man(x), walks(x)])",
+        r"\x y.([],[sees(x,y)])",
+        r"([],[(([],[walks(x)]) + ([],[runs(x)]))])",
+        r"([x],[man(x), -([],[walks(x)])])",
+        r"([],[(([x],[man(x)]) -> ([],[walks(x)]))])",
+    ]
+
+    for e in expressions:
+        d = DrtExpression.fromstring(e)
+        d.draw()
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/sem/drt_glue_demo.py

@@ -0,0 +1,553 @@
+# Natural Language Toolkit: GUI Demo for Glue Semantics with Discourse
+#                           Representation Theory (DRT) as meaning language
+#
+# Author: Dan Garrette <[email protected]>
+#
+# Copyright (C) 2001-2023 NLTK Project
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+try:
+    from tkinter import Button, Frame, IntVar, Label, Listbox, Menu, Scrollbar, Tk
+    from tkinter.font import Font
+
+    from nltk.draw.util import CanvasFrame, ShowText
+
+except ImportError:
+    """Ignore ImportError because tkinter might not be available."""
+
+from nltk.parse import MaltParser
+from nltk.sem.drt import DrsDrawer, DrtVariableExpression
+from nltk.sem.glue import DrtGlue
+from nltk.sem.logic import Variable
+from nltk.tag import RegexpTagger
+from nltk.util import in_idle
+
+
+class DrtGlueDemo:
+    def __init__(self, examples):
+        # Set up the main window.
+        self._top = Tk()
+        self._top.title("DRT Glue Demo")
+
+        # Set up key bindings.
+        self._init_bindings()
+
+        # Initialize the fonts.self._error = None
+        self._init_fonts(self._top)
+
+        self._examples = examples
+        self._readingCache = [None for example in examples]
+
+        # The user can hide the grammar.
+        self._show_grammar = IntVar(self._top)
+        self._show_grammar.set(1)
+
+        # Set the data to None
+        self._curExample = -1
+        self._readings = []
+        self._drs = None
+        self._drsWidget = None
+        self._error = None
+
+        self._init_glue()
+
+        # Create the basic frames.
+        self._init_menubar(self._top)
+        self._init_buttons(self._top)
+        self._init_exampleListbox(self._top)
+        self._init_readingListbox(self._top)
+        self._init_canvas(self._top)
+
+        # Resize callback
+        self._canvas.bind("<Configure>", self._configure)
+
+    #########################################
+    ##  Initialization Helpers
+    #########################################
+
+    def _init_glue(self):
+        tagger = RegexpTagger(
+            [
+                ("^(David|Mary|John)$", "NNP"),
+                (
+                    "^(walks|sees|eats|chases|believes|gives|sleeps|chases|persuades|tries|seems|leaves)$",
+                    "VB",
+                ),
+                ("^(go|order|vanish|find|approach)$", "VB"),
+                ("^(a)$", "ex_quant"),
+                ("^(every)$", "univ_quant"),
+                ("^(sandwich|man|dog|pizza|unicorn|cat|senator)$", "NN"),
+                ("^(big|gray|former)$", "JJ"),
+                ("^(him|himself)$", "PRP"),
+            ]
+        )
+
+        depparser = MaltParser(tagger=tagger)
+        self._glue = DrtGlue(depparser=depparser, remove_duplicates=False)
+
+    def _init_fonts(self, root):
+        # See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
+        self._sysfont = Font(font=Button()["font"])
+        root.option_add("*Font", self._sysfont)
+
+        # TWhat's our font size (default=same as sysfont)
+        self._size = IntVar(root)
+        self._size.set(self._sysfont.cget("size"))
+
+        self._boldfont = Font(family="helvetica", weight="bold", size=self._size.get())
+        self._font = Font(family="helvetica", size=self._size.get())
+        if self._size.get() < 0:
+            big = self._size.get() - 2
+        else:
+            big = self._size.get() + 2
+        self._bigfont = Font(family="helvetica", weight="bold", size=big)
+
+    def _init_exampleListbox(self, parent):
+        self._exampleFrame = listframe = Frame(parent)
+        self._exampleFrame.pack(fill="both", side="left", padx=2)
+        self._exampleList_label = Label(
+            self._exampleFrame, font=self._boldfont, text="Examples"
+        )
+        self._exampleList_label.pack()
+        self._exampleList = Listbox(
+            self._exampleFrame,
+            selectmode="single",
+            relief="groove",
+            background="white",
+            foreground="#909090",
+            font=self._font,
+            selectforeground="#004040",
+            selectbackground="#c0f0c0",
+        )
+
+        self._exampleList.pack(side="right", fill="both", expand=1)
+
+        for example in self._examples:
+            self._exampleList.insert("end", ("  %s" % example))
+        self._exampleList.config(height=min(len(self._examples), 25), width=40)
+
+        # Add a scrollbar if there are more than 25 examples.
+        if len(self._examples) > 25:
+            listscroll = Scrollbar(self._exampleFrame, orient="vertical")
+            self._exampleList.config(yscrollcommand=listscroll.set)
+            listscroll.config(command=self._exampleList.yview)
+            listscroll.pack(side="left", fill="y")
+
+        # If they select a example, apply it.
+        self._exampleList.bind("<<ListboxSelect>>", self._exampleList_select)
+
+    def _init_readingListbox(self, parent):
+        self._readingFrame = listframe = Frame(parent)
+        self._readingFrame.pack(fill="both", side="left", padx=2)
+        self._readingList_label = Label(
+            self._readingFrame, font=self._boldfont, text="Readings"
+        )
+        self._readingList_label.pack()
+        self._readingList = Listbox(
+            self._readingFrame,
+            selectmode="single",
+            relief="groove",
+            background="white",
+            foreground="#909090",
+            font=self._font,
+            selectforeground="#004040",
+            selectbackground="#c0f0c0",
+        )
+
+        self._readingList.pack(side="right", fill="both", expand=1)
+
+        # Add a scrollbar if there are more than 25 examples.
+        listscroll = Scrollbar(self._readingFrame, orient="vertical")
+        self._readingList.config(yscrollcommand=listscroll.set)
+        listscroll.config(command=self._readingList.yview)
+        listscroll.pack(side="right", fill="y")
+
+        self._populate_readingListbox()
+
+    def _populate_readingListbox(self):
+        # Populate the listbox with integers
+        self._readingList.delete(0, "end")
+        for i in range(len(self._readings)):
+            self._readingList.insert("end", ("  %s" % (i + 1)))
+        self._readingList.config(height=min(len(self._readings), 25), width=5)
+
+        # If they select a example, apply it.
+        self._readingList.bind("<<ListboxSelect>>", self._readingList_select)
+
+    def _init_bindings(self):
+        # Key bindings are a good thing.
+        self._top.bind("<Control-q>", self.destroy)
+        self._top.bind("<Control-x>", self.destroy)
+        self._top.bind("<Escape>", self.destroy)
+        self._top.bind("n", self.next)
+        self._top.bind("<space>", self.next)
+        self._top.bind("p", self.prev)
+        self._top.bind("<BackSpace>", self.prev)
+
+    def _init_buttons(self, parent):
+        # Set up the frames.
+        self._buttonframe = buttonframe = Frame(parent)
+        buttonframe.pack(fill="none", side="bottom", padx=3, pady=2)
+        Button(
+            buttonframe,
+            text="Prev",
+            background="#90c0d0",
+            foreground="black",
+            command=self.prev,
+        ).pack(side="left")
+        Button(
+            buttonframe,
+            text="Next",
+            background="#90c0d0",
+            foreground="black",
+            command=self.next,
+        ).pack(side="left")
+
+    def _configure(self, event):
+        self._autostep = 0
+        (x1, y1, x2, y2) = self._cframe.scrollregion()
+        y2 = event.height - 6
+        self._canvas["scrollregion"] = "%d %d %d %d" % (x1, y1, x2, y2)
+        self._redraw()
+
+    def _init_canvas(self, parent):
+        self._cframe = CanvasFrame(
+            parent,
+            background="white",
+            # width=525, height=250,
+            closeenough=10,
+            border=2,
+            relief="sunken",
+        )
+        self._cframe.pack(expand=1, fill="both", side="top", pady=2)
+        canvas = self._canvas = self._cframe.canvas()
+
+        # Initially, there's no tree or text
+        self._tree = None
+        self._textwidgets = []
+        self._textline = None
+
+    def _init_menubar(self, parent):
+        menubar = Menu(parent)
+
+        filemenu = Menu(menubar, tearoff=0)
+        filemenu.add_command(
+            label="Exit", underline=1, command=self.destroy, accelerator="q"
+        )
+        menubar.add_cascade(label="File", underline=0, menu=filemenu)
+
+        actionmenu = Menu(menubar, tearoff=0)
+        actionmenu.add_command(
+            label="Next", underline=0, command=self.next, accelerator="n, Space"
+        )
+        actionmenu.add_command(
+            label="Previous", underline=0, command=self.prev, accelerator="p, Backspace"
+        )
+        menubar.add_cascade(label="Action", underline=0, menu=actionmenu)
+
+        optionmenu = Menu(menubar, tearoff=0)
+        optionmenu.add_checkbutton(
+            label="Remove Duplicates",
+            underline=0,
+            variable=self._glue.remove_duplicates,
+            command=self._toggle_remove_duplicates,
+            accelerator="r",
+        )
+        menubar.add_cascade(label="Options", underline=0, menu=optionmenu)
+
+        viewmenu = Menu(menubar, tearoff=0)
+        viewmenu.add_radiobutton(
+            label="Tiny",
+            variable=self._size,
+            underline=0,
+            value=10,
+            command=self.resize,
+        )
+        viewmenu.add_radiobutton(
+            label="Small",
+            variable=self._size,
+            underline=0,
+            value=12,
+            command=self.resize,
+        )
+        viewmenu.add_radiobutton(
+            label="Medium",
+            variable=self._size,
+            underline=0,
+            value=14,
+            command=self.resize,
+        )
+        viewmenu.add_radiobutton(
+            label="Large",
+            variable=self._size,
+            underline=0,
+            value=18,
+            command=self.resize,
+        )
+        viewmenu.add_radiobutton(
+            label="Huge",
+            variable=self._size,
+            underline=0,
+            value=24,
+            command=self.resize,
+        )
+        menubar.add_cascade(label="View", underline=0, menu=viewmenu)
+
+        helpmenu = Menu(menubar, tearoff=0)
+        helpmenu.add_command(label="About", underline=0, command=self.about)
+        menubar.add_cascade(label="Help", underline=0, menu=helpmenu)
+
+        parent.config(menu=menubar)
+
+    #########################################
+    ##  Main draw procedure
+    #########################################
+
+    def _redraw(self):
+        canvas = self._canvas
+
+        # Delete the old DRS, widgets, etc.
+        if self._drsWidget is not None:
+            self._drsWidget.clear()
+
+        if self._drs:
+            self._drsWidget = DrsWidget(self._canvas, self._drs)
+            self._drsWidget.draw()
+
+        if self._error:
+            self._drsWidget = DrsWidget(self._canvas, self._error)
+            self._drsWidget.draw()
+
+    #########################################
+    ##  Button Callbacks
+    #########################################
+
+    def destroy(self, *e):
+        self._autostep = 0
+        if self._top is None:
+            return
+        self._top.destroy()
+        self._top = None
+
+    def prev(self, *e):
+        selection = self._readingList.curselection()
+        readingListSize = self._readingList.size()
+
+        # there are readings
+        if readingListSize > 0:
+            # if one reading is currently selected
+            if len(selection) == 1:
+                index = int(selection[0])
+
+                # if it's on (or before) the first item
+                if index <= 0:
+                    self._select_previous_example()
+                else:
+                    self._readingList_store_selection(index - 1)
+
+            else:
+                # select its first reading
+                self._readingList_store_selection(readingListSize - 1)
+
+        else:
+            self._select_previous_example()
+
+    def _select_previous_example(self):
+        # if the current example is not the first example
+        if self._curExample > 0:
+            self._exampleList_store_selection(self._curExample - 1)
+        else:
+            # go to the last example
+            self._exampleList_store_selection(len(self._examples) - 1)
+
+    def next(self, *e):
+        selection = self._readingList.curselection()
+        readingListSize = self._readingList.size()
+
+        # if there are readings
+        if readingListSize > 0:
+            # if one reading is currently selected
+            if len(selection) == 1:
+                index = int(selection[0])
+
+                # if it's on (or past) the last item
+                if index >= (readingListSize - 1):
+                    self._select_next_example()
+                else:
+                    self._readingList_store_selection(index + 1)
+
+            else:
+                # select its first reading
+                self._readingList_store_selection(0)
+
+        else:
+            self._select_next_example()
+
+    def _select_next_example(self):
+        # if the current example is not the last example
+        if self._curExample < len(self._examples) - 1:
+            self._exampleList_store_selection(self._curExample + 1)
+        else:
+            # go to the first example
+            self._exampleList_store_selection(0)
+
+    def about(self, *e):
+        ABOUT = (
+            "NLTK Discourse Representation Theory (DRT) Glue Semantics Demo\n"
+            + "Written by Daniel H. Garrette"
+        )
+        TITLE = "About: NLTK DRT Glue Demo"
+        try:
+            from tkinter.messagebox import Message
+
+            Message(message=ABOUT, title=TITLE).show()
+        except:
+            ShowText(self._top, TITLE, ABOUT)
+
+    def postscript(self, *e):
+        self._autostep = 0
+        self._cframe.print_to_file()
+
+    def mainloop(self, *args, **kwargs):
+        """
+        Enter the Tkinter mainloop.  This function must be called if
+        this demo is created from a non-interactive program (e.g.
+        from a secript); otherwise, the demo will close as soon as
+        the script completes.
+        """
+        if in_idle():
+            return
+        self._top.mainloop(*args, **kwargs)
+
+    def resize(self, size=None):
+        if size is not None:
+            self._size.set(size)
+        size = self._size.get()
+        self._font.configure(size=-(abs(size)))
+        self._boldfont.configure(size=-(abs(size)))
+        self._sysfont.configure(size=-(abs(size)))
+        self._bigfont.configure(size=-(abs(size + 2)))
+        self._redraw()
+
+    def _toggle_remove_duplicates(self):
+        self._glue.remove_duplicates = not self._glue.remove_duplicates
+
+        self._exampleList.selection_clear(0, "end")
+        self._readings = []
+        self._populate_readingListbox()
+        self._readingCache = [None for ex in self._examples]
+        self._curExample = -1
+        self._error = None
+
+        self._drs = None
+        self._redraw()
+
+    def _exampleList_select(self, event):
+        selection = self._exampleList.curselection()
+        if len(selection) != 1:
+            return
+        self._exampleList_store_selection(int(selection[0]))
+
+    def _exampleList_store_selection(self, index):
+        self._curExample = index
+        example = self._examples[index]
+
+        self._exampleList.selection_clear(0, "end")
+        if example:
+            cache = self._readingCache[index]
+            if cache:
+                if isinstance(cache, list):
+                    self._readings = cache
+                    self._error = None
+                else:
+                    self._readings = []
+                    self._error = cache
+            else:
+                try:
+                    self._readings = self._glue.parse_to_meaning(example)
+                    self._error = None
+                    self._readingCache[index] = self._readings
+                except Exception as e:
+                    self._readings = []
+                    self._error = DrtVariableExpression(Variable("Error: " + str(e)))
+                    self._readingCache[index] = self._error
+
+                    # add a star to the end of the example
+                    self._exampleList.delete(index)
+                    self._exampleList.insert(index, ("  %s *" % example))
+                    self._exampleList.config(
+                        height=min(len(self._examples), 25), width=40
+                    )
+
+            self._populate_readingListbox()
+
+            self._exampleList.selection_set(index)
+
+            self._drs = None
+            self._redraw()
+
+    def _readingList_select(self, event):
+        selection = self._readingList.curselection()
+        if len(selection) != 1:
+            return
+        self._readingList_store_selection(int(selection[0]))
+
+    def _readingList_store_selection(self, index):
+        reading = self._readings[index]
+
+        self._readingList.selection_clear(0, "end")
+        if reading:
+            self._readingList.selection_set(index)
+
+            self._drs = reading.simplify().normalize().resolve_anaphora()
+
+            self._redraw()
+
+
+class DrsWidget:
+    def __init__(self, canvas, drs, **attribs):
+        self._drs = drs
+        self._canvas = canvas
+        canvas.font = Font(
+            font=canvas.itemcget(canvas.create_text(0, 0, text=""), "font")
+        )
+        canvas._BUFFER = 3
+        self.bbox = (0, 0, 0, 0)
+
+    def draw(self):
+        (right, bottom) = DrsDrawer(self._drs, canvas=self._canvas).draw()
+        self.bbox = (0, 0, right + 1, bottom + 1)
+
+    def clear(self):
+        self._canvas.create_rectangle(self.bbox, fill="white", width="0")
+
+
+def demo():
+    examples = [
+        "John walks",
+        "David sees Mary",
+        "David eats a sandwich",
+        "every man chases a dog",
+        #                'every man believes a dog yawns',
+        #                'John gives David a sandwich',
+        "John chases himself",
+        #                'John persuades David to order a pizza',
+        #                'John tries to go',
+        #                'John tries to find a unicorn',
+        #                'John seems to vanish',
+        #                'a unicorn seems to approach',
+        #                'every big cat leaves',
+        #                'every gray cat leaves',
+        #                'every big gray cat leaves',
+        #                'a former senator leaves',
+        #                'John likes a cat',
+        #                'John likes every cat',
+        #                'he walks',
+        #                'John walks and he leaves'
+    ]
+    DrtGlueDemo(examples).mainloop()
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/sem/evaluate.py

@@ -0,0 +1,829 @@
+# Natural Language Toolkit: Models for first-order languages with lambda
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Ewan Klein <[email protected]>,
+# URL: <https://www.nltk.org>
+# For license information, see LICENSE.TXT
+
+# TODO:
+# - fix tracing
+# - fix iterator-based approach to existentials
+
+"""
+This module provides data structures for representing first-order
+models.
+"""
+
+import inspect
+import re
+import sys
+import textwrap
+from pprint import pformat
+
+from nltk.decorators import decorator  # this used in code that is commented out
+from nltk.sem.logic import (
+    AbstractVariableExpression,
+    AllExpression,
+    AndExpression,
+    ApplicationExpression,
+    EqualityExpression,
+    ExistsExpression,
+    Expression,
+    IffExpression,
+    ImpExpression,
+    IndividualVariableExpression,
+    IotaExpression,
+    LambdaExpression,
+    NegatedExpression,
+    OrExpression,
+    Variable,
+    is_indvar,
+)
+
+
+class Error(Exception):
+    pass
+
+
+class Undefined(Error):
+    pass
+
+
+def trace(f, *args, **kw):
+    argspec = inspect.getfullargspec(f)
+    d = dict(zip(argspec[0], args))
+    if d.pop("trace", None):
+        print()
+        for item in d.items():
+            print("%s => %s" % item)
+    return f(*args, **kw)
+
+
+def is_rel(s):
+    """
+    Check whether a set represents a relation (of any arity).
+
+    :param s: a set containing tuples of str elements
+    :type s: set
+    :rtype: bool
+    """
+    # we have the empty relation, i.e. set()
+    if len(s) == 0:
+        return True
+    # all the elements are tuples of the same length
+    elif all(isinstance(el, tuple) for el in s) and len(max(s)) == len(min(s)):
+        return True
+    else:
+        raise ValueError("Set %r contains sequences of different lengths" % s)
+
+
+def set2rel(s):
+    """
+    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
+    """
+    new = set()
+    for elem in s:
+        if isinstance(elem, str):
+            new.add((elem,))
+        elif isinstance(elem, int):
+            new.add(str(elem))
+        else:
+            new.add(elem)
+    return new
+
+
+def arity(rel):
+    """
+    Check the arity of a relation.
+    :type rel: set of tuples
+    :rtype: int of tuple of str
+    """
+    if len(rel) == 0:
+        return 0
+    return len(list(rel)[0])
+
+
+class Valuation(dict):
+    """
+    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.
+    """
+
+    def __init__(self, xs):
+        """
+        :param xs: a list of (symbol, value) pairs.
+        """
+        super().__init__()
+        for (sym, val) in xs:
+            if isinstance(val, str) or isinstance(val, bool):
+                self[sym] = val
+            elif isinstance(val, set):
+                self[sym] = set2rel(val)
+            else:
+                msg = textwrap.fill(
+                    "Error in initializing Valuation. "
+                    "Unrecognized value for symbol '%s':\n%s" % (sym, val),
+                    width=66,
+                )
+
+                raise ValueError(msg)
+
+    def __getitem__(self, key):
+        if key in self:
+            return dict.__getitem__(self, key)
+        else:
+            raise Undefined("Unknown expression: '%s'" % key)
+
+    def __str__(self):
+        return pformat(self)
+
+    @property
+    def domain(self):
+        """Set-theoretic domain of the value-space of a Valuation."""
+        dom = []
+        for val in self.values():
+            if isinstance(val, str):
+                dom.append(val)
+            elif not isinstance(val, bool):
+                dom.extend(
+                    [elem for tuple_ in val for elem in tuple_ if elem is not None]
+                )
+        return set(dom)
+
+    @property
+    def symbols(self):
+        """The non-logical constants which the Valuation recognizes."""
+        return sorted(self.keys())
+
+    @classmethod
+    def fromstring(cls, s):
+        return read_valuation(s)
+
+
+##########################################
+# REs used by the _read_valuation function
+##########################################
+_VAL_SPLIT_RE = re.compile(r"\s*=+>\s*")
+_ELEMENT_SPLIT_RE = re.compile(r"\s*,\s*")
+_TUPLES_RE = re.compile(
+    r"""\s*
+                                (\([^)]+\))  # tuple-expression
+                                \s*""",
+    re.VERBOSE,
+)
+
+
+def _read_valuation_line(s):
+    """
+    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
+    """
+    pieces = _VAL_SPLIT_RE.split(s)
+    symbol = pieces[0]
+    value = pieces[1]
+    # check whether the value is meant to be a set
+    if value.startswith("{"):
+        value = value[1:-1]
+        tuple_strings = _TUPLES_RE.findall(value)
+        # are the set elements tuples?
+        if tuple_strings:
+            set_elements = []
+            for ts in tuple_strings:
+                ts = ts[1:-1]
+                element = tuple(_ELEMENT_SPLIT_RE.split(ts))
+                set_elements.append(element)
+        else:
+            set_elements = _ELEMENT_SPLIT_RE.split(value)
+        value = set(set_elements)
+    return symbol, value
+
+
+def read_valuation(s, encoding=None):
+    """
+    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
+    """
+    if encoding is not None:
+        s = s.decode(encoding)
+    statements = []
+    for linenum, line in enumerate(s.splitlines()):
+        line = line.strip()
+        if line.startswith("#") or line == "":
+            continue
+        try:
+            statements.append(_read_valuation_line(line))
+        except ValueError as e:
+            raise ValueError(f"Unable to parse line {linenum}: {line}") from e
+    return Valuation(statements)
+
+
+class Assignment(dict):
+    r"""
+    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
+    """
+
+    def __init__(self, domain, assign=None):
+        super().__init__()
+        self.domain = domain
+        if assign:
+            for (var, val) in assign:
+                assert val in self.domain, "'{}' is not in the domain: {}".format(
+                    val,
+                    self.domain,
+                )
+                assert is_indvar(var), (
+                    "Wrong format for an Individual Variable: '%s'" % var
+                )
+                self[var] = val
+        self.variant = None
+        self._addvariant()
+
+    def __getitem__(self, key):
+        if key in self:
+            return dict.__getitem__(self, key)
+        else:
+            raise Undefined("Not recognized as a variable: '%s'" % key)
+
+    def copy(self):
+        new = Assignment(self.domain)
+        new.update(self)
+        return new
+
+    def purge(self, var=None):
+        """
+        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.
+        """
+        if var:
+            del self[var]
+        else:
+            self.clear()
+        self._addvariant()
+        return None
+
+    def __str__(self):
+        """
+        Pretty printing for assignments. {'x', 'u'} appears as 'g[u/x]'
+        """
+        gstring = "g"
+        # Deterministic output for unit testing.
+        variant = sorted(self.variant)
+        for (val, var) in variant:
+            gstring += f"[{val}/{var}]"
+        return gstring
+
+    def _addvariant(self):
+        """
+        Create a more pretty-printable version of the assignment.
+        """
+        list_ = []
+        for item in self.items():
+            pair = (item[1], item[0])
+            list_.append(pair)
+        self.variant = list_
+        return None
+
+    def add(self, var, val):
+        """
+        Add a new variable-value pair to the assignment, and update
+        ``self.variant``.
+
+        """
+        assert val in self.domain, f"{val} is not in the domain {self.domain}"
+        assert is_indvar(var), "Wrong format for an Individual Variable: '%s'" % var
+        self[var] = val
+        self._addvariant()
+        return self
+
+
+class Model:
+    """
+    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*.
+    """
+
+    def __init__(self, domain, valuation):
+        assert isinstance(domain, set)
+        self.domain = domain
+        self.valuation = valuation
+        if not domain.issuperset(valuation.domain):
+            raise Error(
+                "The valuation domain, %s, must be a subset of the model's domain, %s"
+                % (valuation.domain, domain)
+            )
+
+    def __repr__(self):
+        return f"({self.domain!r}, {self.valuation!r})"
+
+    def __str__(self):
+        return f"Domain = {self.domain},\nValuation = \n{self.valuation}"
+
+    def evaluate(self, expr, g, trace=None):
+        """
+        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'
+        """
+        try:
+            parsed = Expression.fromstring(expr)
+            value = self.satisfy(parsed, g, trace=trace)
+            if trace:
+                print()
+                print(f"'{expr}' evaluates to {value} under M, {g}")
+            return value
+        except Undefined:
+            if trace:
+                print()
+                print(f"'{expr}' is undefined under M, {g}")
+            return "Undefined"
+
+    def satisfy(self, parsed, g, trace=None):
+        """
+        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.
+        """
+
+        if isinstance(parsed, ApplicationExpression):
+            function, arguments = parsed.uncurry()
+            if isinstance(function, AbstractVariableExpression):
+                # It's a predicate expression ("P(x,y)"), so used uncurried arguments
+                funval = self.satisfy(function, g)
+                argvals = tuple(self.satisfy(arg, g) for arg in arguments)
+                return argvals in funval
+            else:
+                # It must be a lambda expression, so use curried form
+                funval = self.satisfy(parsed.function, g)
+                argval = self.satisfy(parsed.argument, g)
+                return funval[argval]
+        elif isinstance(parsed, NegatedExpression):
+            return not self.satisfy(parsed.term, g)
+        elif isinstance(parsed, AndExpression):
+            return self.satisfy(parsed.first, g) and self.satisfy(parsed.second, g)
+        elif isinstance(parsed, OrExpression):
+            return self.satisfy(parsed.first, g) or self.satisfy(parsed.second, g)
+        elif isinstance(parsed, ImpExpression):
+            return (not self.satisfy(parsed.first, g)) or self.satisfy(parsed.second, g)
+        elif isinstance(parsed, IffExpression):
+            return self.satisfy(parsed.first, g) == self.satisfy(parsed.second, g)
+        elif isinstance(parsed, EqualityExpression):
+            return self.satisfy(parsed.first, g) == self.satisfy(parsed.second, g)
+        elif isinstance(parsed, AllExpression):
+            new_g = g.copy()
+            for u in self.domain:
+                new_g.add(parsed.variable.name, u)
+                if not self.satisfy(parsed.term, new_g):
+                    return False
+            return True
+        elif isinstance(parsed, ExistsExpression):
+            new_g = g.copy()
+            for u in self.domain:
+                new_g.add(parsed.variable.name, u)
+                if self.satisfy(parsed.term, new_g):
+                    return True
+            return False
+        elif isinstance(parsed, IotaExpression):
+            new_g = g.copy()
+            for u in self.domain:
+                new_g.add(parsed.variable.name, u)
+                if self.satisfy(parsed.term, new_g):
+                    return True
+            return False
+        elif isinstance(parsed, LambdaExpression):
+            cf = {}
+            var = parsed.variable.name
+            for u in self.domain:
+                val = self.satisfy(parsed.term, g.add(var, u))
+                # NB the dict would be a lot smaller if we do this:
+                # if val: cf[u] = val
+                # But then need to deal with cases where f(a) should yield
+                # a function rather than just False.
+                cf[u] = val
+            return cf
+        else:
+            return self.i(parsed, g, trace)
+
+    # @decorator(trace_eval)
+    def i(self, parsed, g, trace=False):
+        """
+        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
+        """
+        # If parsed is a propositional letter 'p', 'q', etc, it could be in valuation.symbols
+        # and also be an IndividualVariableExpression. We want to catch this first case.
+        # So there is a procedural consequence to the ordering of clauses here:
+        if parsed.variable.name in self.valuation.symbols:
+            return self.valuation[parsed.variable.name]
+        elif isinstance(parsed, IndividualVariableExpression):
+            return g[parsed.variable.name]
+
+        else:
+            raise Undefined("Can't find a value for %s" % parsed)
+
+    def satisfiers(self, parsed, varex, g, trace=None, nesting=0):
+        """
+        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``.
+        """
+
+        spacer = "   "
+        indent = spacer + (spacer * nesting)
+        candidates = []
+
+        if isinstance(varex, str):
+            var = Variable(varex)
+        else:
+            var = varex
+
+        if var in parsed.free():
+            if trace:
+                print()
+                print(
+                    (spacer * nesting)
+                    + f"Open formula is '{parsed}' with assignment {g}"
+                )
+            for u in self.domain:
+                new_g = g.copy()
+                new_g.add(var.name, u)
+                if trace and trace > 1:
+                    lowtrace = trace - 1
+                else:
+                    lowtrace = 0
+                value = self.satisfy(parsed, new_g, lowtrace)
+
+                if trace:
+                    print(indent + "(trying assignment %s)" % new_g)
+
+                # parsed == False under g[u/var]?
+                if value == False:
+                    if trace:
+                        print(indent + f"value of '{parsed}' under {new_g} is False")
+
+                # so g[u/var] is a satisfying assignment
+                else:
+                    candidates.append(u)
+                    if trace:
+                        print(indent + f"value of '{parsed}' under {new_g} is {value}")
+
+            result = {c for c in candidates}
+        # var isn't free in parsed
+        else:
+            raise Undefined(f"{var.name} is not free in {parsed}")
+
+        return result
+
+
+# //////////////////////////////////////////////////////////////////////
+# Demo..
+# //////////////////////////////////////////////////////////////////////
+# number of spacer chars
+mult = 30
+
+# Demo 1: Propositional Logic
+#################
+def propdemo(trace=None):
+    """Example of a propositional model."""
+
+    global val1, dom1, m1, g1
+    val1 = Valuation([("P", True), ("Q", True), ("R", False)])
+    dom1 = set()
+    m1 = Model(dom1, val1)
+    g1 = Assignment(dom1)
+
+    print()
+    print("*" * mult)
+    print("Propositional Formulas Demo")
+    print("*" * mult)
+    print("(Propositional constants treated as nullary predicates)")
+    print()
+    print("Model m1:\n", m1)
+    print("*" * mult)
+    sentences = [
+        "(P & Q)",
+        "(P & R)",
+        "- P",
+        "- R",
+        "- - P",
+        "- (P & R)",
+        "(P | R)",
+        "(R | P)",
+        "(R | R)",
+        "(- P | R)",
+        "(P | - P)",
+        "(P -> Q)",
+        "(P -> R)",
+        "(R -> P)",
+        "(P <-> P)",
+        "(R <-> R)",
+        "(P <-> R)",
+    ]
+
+    for sent in sentences:
+        if trace:
+            print()
+            m1.evaluate(sent, g1, trace)
+        else:
+            print(f"The value of '{sent}' is: {m1.evaluate(sent, g1)}")
+
+
+# Demo 2: FOL Model
+#############
+
+
+def folmodel(quiet=False, trace=None):
+    """Example of a first-order model."""
+
+    global val2, v2, dom2, m2, g2
+
+    v2 = [
+        ("adam", "b1"),
+        ("betty", "g1"),
+        ("fido", "d1"),
+        ("girl", {"g1", "g2"}),
+        ("boy", {"b1", "b2"}),
+        ("dog", {"d1"}),
+        ("love", {("b1", "g1"), ("b2", "g2"), ("g1", "b1"), ("g2", "b1")}),
+    ]
+    val2 = Valuation(v2)
+    dom2 = val2.domain
+    m2 = Model(dom2, val2)
+    g2 = Assignment(dom2, [("x", "b1"), ("y", "g2")])
+
+    if not quiet:
+        print()
+        print("*" * mult)
+        print("Models Demo")
+        print("*" * mult)
+        print("Model m2:\n", "-" * 14, "\n", m2)
+        print("Variable assignment = ", g2)
+
+        exprs = ["adam", "boy", "love", "walks", "x", "y", "z"]
+        parsed_exprs = [Expression.fromstring(e) for e in exprs]
+
+        print()
+        for parsed in parsed_exprs:
+            try:
+                print(
+                    "The interpretation of '%s' in m2 is %s"
+                    % (parsed, m2.i(parsed, g2))
+                )
+            except Undefined:
+                print("The interpretation of '%s' in m2 is Undefined" % parsed)
+
+        applications = [
+            ("boy", ("adam")),
+            ("walks", ("adam",)),
+            ("love", ("adam", "y")),
+            ("love", ("y", "adam")),
+        ]
+
+        for (fun, args) in applications:
+            try:
+                funval = m2.i(Expression.fromstring(fun), g2)
+                argsval = tuple(m2.i(Expression.fromstring(arg), g2) for arg in args)
+                print(f"{fun}({args}) evaluates to {argsval in funval}")
+            except Undefined:
+                print(f"{fun}({args}) evaluates to Undefined")
+
+
+# Demo 3: FOL
+#########
+
+
+def foldemo(trace=None):
+    """
+    Interpretation of closed expressions in a first-order model.
+    """
+    folmodel(quiet=True)
+
+    print()
+    print("*" * mult)
+    print("FOL Formulas Demo")
+    print("*" * mult)
+
+    formulas = [
+        "love (adam, betty)",
+        "(adam = mia)",
+        "\\x. (boy(x) | girl(x))",
+        "\\x. boy(x)(adam)",
+        "\\x y. love(x, y)",
+        "\\x y. love(x, y)(adam)(betty)",
+        "\\x y. love(x, y)(adam, betty)",
+        "\\x y. (boy(x) & love(x, y))",
+        "\\x. exists y. (boy(x) & love(x, y))",
+        "exists z1. boy(z1)",
+        "exists x. (boy(x) &  -(x = adam))",
+        "exists x. (boy(x) & all y. love(y, x))",
+        "all x. (boy(x) | girl(x))",
+        "all x. (girl(x) -> exists y. boy(y) & love(x, y))",  # Every girl loves exists boy.
+        "exists x. (boy(x) & all y. (girl(y) -> love(y, x)))",  # There is exists boy that every girl loves.
+        "exists x. (boy(x) & all y. (girl(y) -> love(x, y)))",  # exists boy loves every girl.
+        "all x. (dog(x) -> - girl(x))",
+        "exists x. exists y. (love(x, y) & love(x, y))",
+    ]
+
+    for fmla in formulas:
+        g2.purge()
+        if trace:
+            m2.evaluate(fmla, g2, trace)
+        else:
+            print(f"The value of '{fmla}' is: {m2.evaluate(fmla, g2)}")
+
+
+# Demo 3: Satisfaction
+#############
+
+
+def satdemo(trace=None):
+    """Satisfiers of an open formula in a first order model."""
+
+    print()
+    print("*" * mult)
+    print("Satisfiers Demo")
+    print("*" * mult)
+
+    folmodel(quiet=True)
+
+    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))",
+    ]
+
+    if trace:
+        print(m2)
+
+    for fmla in formulas:
+        print(fmla)
+        Expression.fromstring(fmla)
+
+    parsed = [Expression.fromstring(fmla) for fmla in formulas]
+
+    for p in parsed:
+        g2.purge()
+        print(
+            "The satisfiers of '{}' are: {}".format(p, m2.satisfiers(p, "x", g2, trace))
+        )
+
+
+def demo(num=0, trace=None):
+    """
+    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
+    """
+    demos = {1: propdemo, 2: folmodel, 3: foldemo, 4: satdemo}
+
+    try:
+        demos[num](trace=trace)
+    except KeyError:
+        for num in demos:
+            demos[num](trace=trace)
+
+
+if __name__ == "__main__":
+    demo(2, trace=0)

llmeval-env/lib/python3.10/site-packages/nltk/sem/glue.py

@@ -0,0 +1,835 @@
+# Natural Language Toolkit: Glue Semantics
+#
+# Author: Dan Garrette <[email protected]>
+#
+# Copyright (C) 2001-2023 NLTK Project
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import os
+from itertools import chain
+
+import nltk
+from nltk.internals import Counter
+from nltk.sem import drt, linearlogic
+from nltk.sem.logic import (
+    AbstractVariableExpression,
+    Expression,
+    LambdaExpression,
+    Variable,
+    VariableExpression,
+)
+from nltk.tag import BigramTagger, RegexpTagger, TrigramTagger, UnigramTagger
+
+SPEC_SEMTYPES = {
+    "a": "ex_quant",
+    "an": "ex_quant",
+    "every": "univ_quant",
+    "the": "def_art",
+    "no": "no_quant",
+    "default": "ex_quant",
+}
+
+OPTIONAL_RELATIONSHIPS = ["nmod", "vmod", "punct"]
+
+
+class GlueFormula:
+    def __init__(self, meaning, glue, indices=None):
+        if not indices:
+            indices = set()
+
+        if isinstance(meaning, str):
+            self.meaning = Expression.fromstring(meaning)
+        elif isinstance(meaning, Expression):
+            self.meaning = meaning
+        else:
+            raise RuntimeError(
+                "Meaning term neither string or expression: %s, %s"
+                % (meaning, meaning.__class__)
+            )
+
+        if isinstance(glue, str):
+            self.glue = linearlogic.LinearLogicParser().parse(glue)
+        elif isinstance(glue, linearlogic.Expression):
+            self.glue = glue
+        else:
+            raise RuntimeError(
+                "Glue term neither string or expression: %s, %s"
+                % (glue, glue.__class__)
+            )
+
+        self.indices = indices
+
+    def applyto(self, arg):
+        """self = (\\x.(walk x), (subj -o f))
+        arg  = (john        ,  subj)
+        returns ((walk john),          f)
+        """
+        if self.indices & arg.indices:  # if the sets are NOT disjoint
+            raise linearlogic.LinearLogicApplicationException(
+                f"'{self}' applied to '{arg}'.  Indices are not disjoint."
+            )
+        else:  # if the sets ARE disjoint
+            return_indices = self.indices | arg.indices
+
+        try:
+            return_glue = linearlogic.ApplicationExpression(
+                self.glue, arg.glue, arg.indices
+            )
+        except linearlogic.LinearLogicApplicationException as e:
+            raise linearlogic.LinearLogicApplicationException(
+                f"'{self.simplify()}' applied to '{arg.simplify()}'"
+            ) from e
+
+        arg_meaning_abstracted = arg.meaning
+        if return_indices:
+            for dep in self.glue.simplify().antecedent.dependencies[
+                ::-1
+            ]:  # if self.glue is (A -o B), dep is in A.dependencies
+                arg_meaning_abstracted = self.make_LambdaExpression(
+                    Variable("v%s" % dep), arg_meaning_abstracted
+                )
+        return_meaning = self.meaning.applyto(arg_meaning_abstracted)
+
+        return self.__class__(return_meaning, return_glue, return_indices)
+
+    def make_VariableExpression(self, name):
+        return VariableExpression(name)
+
+    def make_LambdaExpression(self, variable, term):
+        return LambdaExpression(variable, term)
+
+    def lambda_abstract(self, other):
+        assert isinstance(other, GlueFormula)
+        assert isinstance(other.meaning, AbstractVariableExpression)
+        return self.__class__(
+            self.make_LambdaExpression(other.meaning.variable, self.meaning),
+            linearlogic.ImpExpression(other.glue, self.glue),
+        )
+
+    def compile(self, counter=None):
+        """From Iddo Lev's PhD Dissertation p108-109"""
+        if not counter:
+            counter = Counter()
+        (compiled_glue, new_forms) = self.glue.simplify().compile_pos(
+            counter, self.__class__
+        )
+        return new_forms + [
+            self.__class__(self.meaning, compiled_glue, {counter.get()})
+        ]
+
+    def simplify(self):
+        return self.__class__(
+            self.meaning.simplify(), self.glue.simplify(), self.indices
+        )
+
+    def __eq__(self, other):
+        return (
+            self.__class__ == other.__class__
+            and self.meaning == other.meaning
+            and self.glue == other.glue
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    # sorting for use in doctests which must be deterministic
+    def __lt__(self, other):
+        return str(self) < str(other)
+
+    def __str__(self):
+        assert isinstance(self.indices, set)
+        accum = f"{self.meaning} : {self.glue}"
+        if self.indices:
+            accum += (
+                " : {" + ", ".join(str(index) for index in sorted(self.indices)) + "}"
+            )
+        return accum
+
+    def __repr__(self):
+        return "%s" % self
+
+
+class GlueDict(dict):
+    def __init__(self, filename, encoding=None):
+        self.filename = filename
+        self.file_encoding = encoding
+        self.read_file()
+
+    def read_file(self, empty_first=True):
+        if empty_first:
+            self.clear()
+
+        try:
+            contents = nltk.data.load(
+                self.filename, format="text", encoding=self.file_encoding
+            )
+            # TODO: the above can't handle zip files, but this should anyway be fixed in nltk.data.load()
+        except LookupError as e:
+            try:
+                contents = nltk.data.load(
+                    "file:" + self.filename, format="text", encoding=self.file_encoding
+                )
+            except LookupError:
+                raise e
+        lines = contents.splitlines()
+
+        for line in lines:  # example: 'n : (\\x.(<word> x), (v-or))'
+            #     lambdacalc -^  linear logic -^
+            line = line.strip()  # remove trailing newline
+            if not len(line):
+                continue  # skip empty lines
+            if line[0] == "#":
+                continue  # skip commented out lines
+
+            parts = line.split(
+                " : ", 2
+            )  # ['verb', '(\\x.(<word> x), ( subj -o f ))', '[subj]']
+
+            glue_formulas = []
+            paren_count = 0
+            tuple_start = 0
+            tuple_comma = 0
+
+            relationships = None
+
+            if len(parts) > 1:
+                for (i, c) in enumerate(parts[1]):
+                    if c == "(":
+                        if paren_count == 0:  # if it's the first '(' of a tuple
+                            tuple_start = i + 1  # then save the index
+                        paren_count += 1
+                    elif c == ")":
+                        paren_count -= 1
+                        if paren_count == 0:  # if it's the last ')' of a tuple
+                            meaning_term = parts[1][
+                                tuple_start:tuple_comma
+                            ]  # '\\x.(<word> x)'
+                            glue_term = parts[1][tuple_comma + 1 : i]  # '(v-r)'
+                            glue_formulas.append(
+                                [meaning_term, glue_term]
+                            )  # add the GlueFormula to the list
+                    elif c == ",":
+                        if (
+                            paren_count == 1
+                        ):  # if it's a comma separating the parts of the tuple
+                            tuple_comma = i  # then save the index
+                    elif c == "#":  # skip comments at the ends of lines
+                        if (
+                            paren_count != 0
+                        ):  # if the line hasn't parsed correctly so far
+                            raise RuntimeError(
+                                "Formula syntax is incorrect for entry " + line
+                            )
+                        break  # break to the next line
+
+            if len(parts) > 2:  # if there is a relationship entry at the end
+                rel_start = parts[2].index("[") + 1
+                rel_end = parts[2].index("]")
+                if rel_start == rel_end:
+                    relationships = frozenset()
+                else:
+                    relationships = frozenset(
+                        r.strip() for r in parts[2][rel_start:rel_end].split(",")
+                    )
+
+            try:
+                start_inheritance = parts[0].index("(")
+                end_inheritance = parts[0].index(")")
+                sem = parts[0][:start_inheritance].strip()
+                supertype = parts[0][start_inheritance + 1 : end_inheritance]
+            except:
+                sem = parts[0].strip()
+                supertype = None
+
+            if sem not in self:
+                self[sem] = {}
+
+            if (
+                relationships is None
+            ):  # if not specified for a specific relationship set
+                # add all relationship entries for parents
+                if supertype:
+                    for rels in self[supertype]:
+                        if rels not in self[sem]:
+                            self[sem][rels] = []
+                        glue = self[supertype][rels]
+                        self[sem][rels].extend(glue)
+                        self[sem][rels].extend(
+                            glue_formulas
+                        )  # add the glue formulas to every rel entry
+                else:
+                    if None not in self[sem]:
+                        self[sem][None] = []
+                    self[sem][None].extend(
+                        glue_formulas
+                    )  # add the glue formulas to every rel entry
+            else:
+                if relationships not in self[sem]:
+                    self[sem][relationships] = []
+                if supertype:
+                    self[sem][relationships].extend(self[supertype][relationships])
+                self[sem][relationships].extend(
+                    glue_formulas
+                )  # add the glue entry to the dictionary
+
+    def __str__(self):
+        accum = ""
+        for pos in self:
+            str_pos = "%s" % pos
+            for relset in self[pos]:
+                i = 1
+                for gf in self[pos][relset]:
+                    if i == 1:
+                        accum += str_pos + ": "
+                    else:
+                        accum += " " * (len(str_pos) + 2)
+                    accum += "%s" % gf
+                    if relset and i == len(self[pos][relset]):
+                        accum += " : %s" % relset
+                    accum += "\n"
+                    i += 1
+        return accum
+
+    def to_glueformula_list(self, depgraph, node=None, counter=None, verbose=False):
+        if node is None:
+            # TODO: should it be depgraph.root? Is this code tested?
+            top = depgraph.nodes[0]
+            depList = list(chain.from_iterable(top["deps"].values()))
+            root = depgraph.nodes[depList[0]]
+
+            return self.to_glueformula_list(depgraph, root, Counter(), verbose)
+
+        glueformulas = self.lookup(node, depgraph, counter)
+        for dep_idx in chain.from_iterable(node["deps"].values()):
+            dep = depgraph.nodes[dep_idx]
+            glueformulas.extend(
+                self.to_glueformula_list(depgraph, dep, counter, verbose)
+            )
+        return glueformulas
+
+    def lookup(self, node, depgraph, counter):
+        semtype_names = self.get_semtypes(node)
+
+        semtype = None
+        for name in semtype_names:
+            if name in self:
+                semtype = self[name]
+                break
+        if semtype is None:
+            # raise KeyError, "There is no GlueDict entry for sem type '%s' (for '%s')" % (sem, word)
+            return []
+
+        self.add_missing_dependencies(node, depgraph)
+
+        lookup = self._lookup_semtype_option(semtype, node, depgraph)
+
+        if not len(lookup):
+            raise KeyError(
+                "There is no GlueDict entry for sem type of '%s' "
+                "with tag '%s', and rel '%s'" % (node["word"], node["tag"], node["rel"])
+            )
+
+        return self.get_glueformulas_from_semtype_entry(
+            lookup, node["word"], node, depgraph, counter
+        )
+
+    def add_missing_dependencies(self, node, depgraph):
+        rel = node["rel"].lower()
+
+        if rel == "main":
+            headnode = depgraph.nodes[node["head"]]
+            subj = self.lookup_unique("subj", headnode, depgraph)
+            relation = subj["rel"]
+            node["deps"].setdefault(relation, [])
+            node["deps"][relation].append(subj["address"])
+            # node['deps'].append(subj['address'])
+
+    def _lookup_semtype_option(self, semtype, node, depgraph):
+        relationships = frozenset(
+            depgraph.nodes[dep]["rel"].lower()
+            for dep in chain.from_iterable(node["deps"].values())
+            if depgraph.nodes[dep]["rel"].lower() not in OPTIONAL_RELATIONSHIPS
+        )
+
+        try:
+            lookup = semtype[relationships]
+        except KeyError:
+            # An exact match is not found, so find the best match where
+            # 'best' is defined as the glue entry whose relationship set has the
+            # most relations of any possible relationship set that is a subset
+            # of the actual depgraph
+            best_match = frozenset()
+            for relset_option in set(semtype) - {None}:
+                if (
+                    len(relset_option) > len(best_match)
+                    and relset_option < relationships
+                ):
+                    best_match = relset_option
+            if not best_match:
+                if None in semtype:
+                    best_match = None
+                else:
+                    return None
+            lookup = semtype[best_match]
+
+        return lookup
+
+    def get_semtypes(self, node):
+        """
+        Based on the node, return a list of plausible semtypes in order of
+        plausibility.
+        """
+        rel = node["rel"].lower()
+        word = node["word"].lower()
+
+        if rel == "spec":
+            if word in SPEC_SEMTYPES:
+                return [SPEC_SEMTYPES[word]]
+            else:
+                return [SPEC_SEMTYPES["default"]]
+        elif rel in ["nmod", "vmod"]:
+            return [node["tag"], rel]
+        else:
+            return [node["tag"]]
+
+    def get_glueformulas_from_semtype_entry(
+        self, lookup, word, node, depgraph, counter
+    ):
+        glueformulas = []
+
+        glueFormulaFactory = self.get_GlueFormula_factory()
+        for meaning, glue in lookup:
+            gf = glueFormulaFactory(self.get_meaning_formula(meaning, word), glue)
+            if not len(glueformulas):
+                gf.word = word
+            else:
+                gf.word = f"{word}{len(glueformulas) + 1}"
+
+            gf.glue = self.initialize_labels(gf.glue, node, depgraph, counter.get())
+
+            glueformulas.append(gf)
+        return glueformulas
+
+    def get_meaning_formula(self, generic, word):
+        """
+        :param generic: A meaning formula string containing the
+            parameter "<word>"
+        :param word: The actual word to be replace "<word>"
+        """
+        word = word.replace(".", "")
+        return generic.replace("<word>", word)
+
+    def initialize_labels(self, expr, node, depgraph, unique_index):
+        if isinstance(expr, linearlogic.AtomicExpression):
+            name = self.find_label_name(expr.name.lower(), node, depgraph, unique_index)
+            if name[0].isupper():
+                return linearlogic.VariableExpression(name)
+            else:
+                return linearlogic.ConstantExpression(name)
+        else:
+            return linearlogic.ImpExpression(
+                self.initialize_labels(expr.antecedent, node, depgraph, unique_index),
+                self.initialize_labels(expr.consequent, node, depgraph, unique_index),
+            )
+
+    def find_label_name(self, name, node, depgraph, unique_index):
+        try:
+            dot = name.index(".")
+
+            before_dot = name[:dot]
+            after_dot = name[dot + 1 :]
+            if before_dot == "super":
+                return self.find_label_name(
+                    after_dot, depgraph.nodes[node["head"]], depgraph, unique_index
+                )
+            else:
+                return self.find_label_name(
+                    after_dot,
+                    self.lookup_unique(before_dot, node, depgraph),
+                    depgraph,
+                    unique_index,
+                )
+        except ValueError:
+            lbl = self.get_label(node)
+            if name == "f":
+                return lbl
+            elif name == "v":
+                return "%sv" % lbl
+            elif name == "r":
+                return "%sr" % lbl
+            elif name == "super":
+                return self.get_label(depgraph.nodes[node["head"]])
+            elif name == "var":
+                return f"{lbl.upper()}{unique_index}"
+            elif name == "a":
+                return self.get_label(self.lookup_unique("conja", node, depgraph))
+            elif name == "b":
+                return self.get_label(self.lookup_unique("conjb", node, depgraph))
+            else:
+                return self.get_label(self.lookup_unique(name, node, depgraph))
+
+    def get_label(self, node):
+        """
+        Pick an alphabetic character as identifier for an entity in the model.
+
+        :param value: where to index into the list of characters
+        :type value: int
+        """
+        value = node["address"]
+
+        letter = [
+            "f",
+            "g",
+            "h",
+            "i",
+            "j",
+            "k",
+            "l",
+            "m",
+            "n",
+            "o",
+            "p",
+            "q",
+            "r",
+            "s",
+            "t",
+            "u",
+            "v",
+            "w",
+            "x",
+            "y",
+            "z",
+            "a",
+            "b",
+            "c",
+            "d",
+            "e",
+        ][value - 1]
+        num = int(value) // 26
+        if num > 0:
+            return letter + str(num)
+        else:
+            return letter
+
+    def lookup_unique(self, rel, node, depgraph):
+        """
+        Lookup 'key'. There should be exactly one item in the associated relation.
+        """
+        deps = [
+            depgraph.nodes[dep]
+            for dep in chain.from_iterable(node["deps"].values())
+            if depgraph.nodes[dep]["rel"].lower() == rel.lower()
+        ]
+
+        if len(deps) == 0:
+            raise KeyError(
+                "'{}' doesn't contain a feature '{}'".format(node["word"], rel)
+            )
+        elif len(deps) > 1:
+            raise KeyError(
+                "'{}' should only have one feature '{}'".format(node["word"], rel)
+            )
+        else:
+            return deps[0]
+
+    def get_GlueFormula_factory(self):
+        return GlueFormula
+
+
+class Glue:
+    def __init__(
+        self, semtype_file=None, remove_duplicates=False, depparser=None, verbose=False
+    ):
+        self.verbose = verbose
+        self.remove_duplicates = remove_duplicates
+        self.depparser = depparser
+
+        from nltk import Prover9
+
+        self.prover = Prover9()
+
+        if semtype_file:
+            self.semtype_file = semtype_file
+        else:
+            self.semtype_file = os.path.join(
+                "grammars", "sample_grammars", "glue.semtype"
+            )
+
+    def train_depparser(self, depgraphs=None):
+        if depgraphs:
+            self.depparser.train(depgraphs)
+        else:
+            self.depparser.train_from_file(
+                nltk.data.find(
+                    os.path.join("grammars", "sample_grammars", "glue_train.conll")
+                )
+            )
+
+    def parse_to_meaning(self, sentence):
+        readings = []
+        for agenda in self.parse_to_compiled(sentence):
+            readings.extend(self.get_readings(agenda))
+        return readings
+
+    def get_readings(self, agenda):
+        readings = []
+        agenda_length = len(agenda)
+        atomics = dict()
+        nonatomics = dict()
+        while agenda:  # is not empty
+            cur = agenda.pop()
+            glue_simp = cur.glue.simplify()
+            if isinstance(
+                glue_simp, linearlogic.ImpExpression
+            ):  # if cur.glue is non-atomic
+                for key in atomics:
+                    try:
+                        if isinstance(cur.glue, linearlogic.ApplicationExpression):
+                            bindings = cur.glue.bindings
+                        else:
+                            bindings = linearlogic.BindingDict()
+                        glue_simp.antecedent.unify(key, bindings)
+                        for atomic in atomics[key]:
+                            if not (
+                                cur.indices & atomic.indices
+                            ):  # if the sets of indices are disjoint
+                                try:
+                                    agenda.append(cur.applyto(atomic))
+                                except linearlogic.LinearLogicApplicationException:
+                                    pass
+                    except linearlogic.UnificationException:
+                        pass
+                try:
+                    nonatomics[glue_simp.antecedent].append(cur)
+                except KeyError:
+                    nonatomics[glue_simp.antecedent] = [cur]
+
+            else:  # else cur.glue is atomic
+                for key in nonatomics:
+                    for nonatomic in nonatomics[key]:
+                        try:
+                            if isinstance(
+                                nonatomic.glue, linearlogic.ApplicationExpression
+                            ):
+                                bindings = nonatomic.glue.bindings
+                            else:
+                                bindings = linearlogic.BindingDict()
+                            glue_simp.unify(key, bindings)
+                            if not (
+                                cur.indices & nonatomic.indices
+                            ):  # if the sets of indices are disjoint
+                                try:
+                                    agenda.append(nonatomic.applyto(cur))
+                                except linearlogic.LinearLogicApplicationException:
+                                    pass
+                        except linearlogic.UnificationException:
+                            pass
+                try:
+                    atomics[glue_simp].append(cur)
+                except KeyError:
+                    atomics[glue_simp] = [cur]
+
+        for entry in atomics:
+            for gf in atomics[entry]:
+                if len(gf.indices) == agenda_length:
+                    self._add_to_reading_list(gf, readings)
+        for entry in nonatomics:
+            for gf in nonatomics[entry]:
+                if len(gf.indices) == agenda_length:
+                    self._add_to_reading_list(gf, readings)
+        return readings
+
+    def _add_to_reading_list(self, glueformula, reading_list):
+        add_reading = True
+        if self.remove_duplicates:
+            for reading in reading_list:
+                try:
+                    if reading.equiv(glueformula.meaning, self.prover):
+                        add_reading = False
+                        break
+                except Exception as e:
+                    # if there is an exception, the syntax of the formula
+                    # may not be understandable by the prover, so don't
+                    # throw out the reading.
+                    print("Error when checking logical equality of statements", e)
+
+        if add_reading:
+            reading_list.append(glueformula.meaning)
+
+    def parse_to_compiled(self, sentence):
+        gfls = [self.depgraph_to_glue(dg) for dg in self.dep_parse(sentence)]
+        return [self.gfl_to_compiled(gfl) for gfl in gfls]
+
+    def dep_parse(self, sentence):
+        """
+        Return a dependency graph for the sentence.
+
+        :param sentence: the sentence to be parsed
+        :type sentence: list(str)
+        :rtype: DependencyGraph
+        """
+
+        # Lazy-initialize the depparser
+        if self.depparser is None:
+            from nltk.parse import MaltParser
+
+            self.depparser = MaltParser(tagger=self.get_pos_tagger())
+        if not self.depparser._trained:
+            self.train_depparser()
+        return self.depparser.parse(sentence, verbose=self.verbose)
+
+    def depgraph_to_glue(self, depgraph):
+        return self.get_glue_dict().to_glueformula_list(depgraph)
+
+    def get_glue_dict(self):
+        return GlueDict(self.semtype_file)
+
+    def gfl_to_compiled(self, gfl):
+        index_counter = Counter()
+        return_list = []
+        for gf in gfl:
+            return_list.extend(gf.compile(index_counter))
+
+        if self.verbose:
+            print("Compiled Glue Premises:")
+            for cgf in return_list:
+                print(cgf)
+
+        return return_list
+
+    def get_pos_tagger(self):
+        from nltk.corpus import brown
+
+        regexp_tagger = RegexpTagger(
+            [
+                (r"^-?[0-9]+(\.[0-9]+)?$", "CD"),  # cardinal numbers
+                (r"(The|the|A|a|An|an)$", "AT"),  # articles
+                (r".*able$", "JJ"),  # adjectives
+                (r".*ness$", "NN"),  # nouns formed from adjectives
+                (r".*ly$", "RB"),  # adverbs
+                (r".*s$", "NNS"),  # plural nouns
+                (r".*ing$", "VBG"),  # gerunds
+                (r".*ed$", "VBD"),  # past tense verbs
+                (r".*", "NN"),  # nouns (default)
+            ]
+        )
+        brown_train = brown.tagged_sents(categories="news")
+        unigram_tagger = UnigramTagger(brown_train, backoff=regexp_tagger)
+        bigram_tagger = BigramTagger(brown_train, backoff=unigram_tagger)
+        trigram_tagger = TrigramTagger(brown_train, backoff=bigram_tagger)
+
+        # Override particular words
+        main_tagger = RegexpTagger(
+            [(r"(A|a|An|an)$", "ex_quant"), (r"(Every|every|All|all)$", "univ_quant")],
+            backoff=trigram_tagger,
+        )
+
+        return main_tagger
+
+
+class DrtGlueFormula(GlueFormula):
+    def __init__(self, meaning, glue, indices=None):
+        if not indices:
+            indices = set()
+
+        if isinstance(meaning, str):
+            self.meaning = drt.DrtExpression.fromstring(meaning)
+        elif isinstance(meaning, drt.DrtExpression):
+            self.meaning = meaning
+        else:
+            raise RuntimeError(
+                "Meaning term neither string or expression: %s, %s"
+                % (meaning, meaning.__class__)
+            )
+
+        if isinstance(glue, str):
+            self.glue = linearlogic.LinearLogicParser().parse(glue)
+        elif isinstance(glue, linearlogic.Expression):
+            self.glue = glue
+        else:
+            raise RuntimeError(
+                "Glue term neither string or expression: %s, %s"
+                % (glue, glue.__class__)
+            )
+
+        self.indices = indices
+
+    def make_VariableExpression(self, name):
+        return drt.DrtVariableExpression(name)
+
+    def make_LambdaExpression(self, variable, term):
+        return drt.DrtLambdaExpression(variable, term)
+
+
+class DrtGlueDict(GlueDict):
+    def get_GlueFormula_factory(self):
+        return DrtGlueFormula
+
+
+class DrtGlue(Glue):
+    def __init__(
+        self, semtype_file=None, remove_duplicates=False, depparser=None, verbose=False
+    ):
+        if not semtype_file:
+            semtype_file = os.path.join(
+                "grammars", "sample_grammars", "drt_glue.semtype"
+            )
+        Glue.__init__(self, semtype_file, remove_duplicates, depparser, verbose)
+
+    def get_glue_dict(self):
+        return DrtGlueDict(self.semtype_file)
+
+
+def demo(show_example=-1):
+    from nltk.parse import MaltParser
+
+    examples = [
+        "David sees Mary",
+        "David eats a sandwich",
+        "every man chases a dog",
+        "every man believes a dog sleeps",
+        "John gives David a sandwich",
+        "John chases himself",
+    ]
+    #                'John persuades David to order a pizza',
+    #                'John tries to go',
+    #                'John tries to find a unicorn',
+    #                'John seems to vanish',
+    #                'a unicorn seems to approach',
+    #                'every big cat leaves',
+    #                'every gray cat leaves',
+    #                'every big gray cat leaves',
+    #                'a former senator leaves',
+
+    print("============== DEMO ==============")
+
+    tagger = RegexpTagger(
+        [
+            ("^(David|Mary|John)$", "NNP"),
+            (
+                "^(sees|eats|chases|believes|gives|sleeps|chases|persuades|tries|seems|leaves)$",
+                "VB",
+            ),
+            ("^(go|order|vanish|find|approach)$", "VB"),
+            ("^(a)$", "ex_quant"),
+            ("^(every)$", "univ_quant"),
+            ("^(sandwich|man|dog|pizza|unicorn|cat|senator)$", "NN"),
+            ("^(big|gray|former)$", "JJ"),
+            ("^(him|himself)$", "PRP"),
+        ]
+    )
+
+    depparser = MaltParser(tagger=tagger)
+    glue = Glue(depparser=depparser, verbose=False)
+
+    for (i, sentence) in enumerate(examples):
+        if i == show_example or show_example == -1:
+            print(f"[[[Example {i}]]]  {sentence}")
+            for reading in glue.parse_to_meaning(sentence.split()):
+                print(reading.simplify())
+            print("")
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/sem/hole.py

@@ -0,0 +1,395 @@
+# Natural Language Toolkit: Logic
+#
+# Author:     Peter Wang
+# Updated by: Dan Garrette <[email protected]>
+#
+# Copyright (C) 2001-2023 NLTK Project
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+An implementation of the Hole Semantics model, following Blackburn and Bos,
+Representation and Inference for Natural Language (CSLI, 2005).
+
+The semantic representations are built by the grammar hole.fcfg.
+This module contains driver code to read in sentences and parse them
+according to a hole semantics grammar.
+
+After parsing, the semantic representation is in the form of an underspecified
+representation that is not easy to read.  We use a "plugging" algorithm to
+convert that representation into first-order logic formulas.
+"""
+
+from functools import reduce
+
+from nltk.parse import load_parser
+from nltk.sem.logic import (
+    AllExpression,
+    AndExpression,
+    ApplicationExpression,
+    ExistsExpression,
+    IffExpression,
+    ImpExpression,
+    LambdaExpression,
+    NegatedExpression,
+    OrExpression,
+)
+from nltk.sem.skolemize import skolemize
+
+# Note that in this code there may be multiple types of trees being referred to:
+#
+# 1. parse trees
+# 2. the underspecified representation
+# 3. first-order logic formula trees
+# 4. the search space when plugging (search tree)
+#
+
+
+class Constants:
+    ALL = "ALL"
+    EXISTS = "EXISTS"
+    NOT = "NOT"
+    AND = "AND"
+    OR = "OR"
+    IMP = "IMP"
+    IFF = "IFF"
+    PRED = "PRED"
+    LEQ = "LEQ"
+    HOLE = "HOLE"
+    LABEL = "LABEL"
+
+    MAP = {
+        ALL: lambda v, e: AllExpression(v.variable, e),
+        EXISTS: lambda v, e: ExistsExpression(v.variable, e),
+        NOT: NegatedExpression,
+        AND: AndExpression,
+        OR: OrExpression,
+        IMP: ImpExpression,
+        IFF: IffExpression,
+        PRED: ApplicationExpression,
+    }
+
+
+class HoleSemantics:
+    """
+    This class holds the broken-down components of a hole semantics, i.e. it
+    extracts the holes, labels, logic formula fragments and constraints out of
+    a big conjunction of such as produced by the hole semantics grammar.  It
+    then provides some operations on the semantics dealing with holes, labels
+    and finding legal ways to plug holes with labels.
+    """
+
+    def __init__(self, usr):
+        """
+        Constructor.  `usr' is a ``sem.Expression`` representing an
+        Underspecified Representation Structure (USR).  A USR has the following
+        special predicates:
+        ALL(l,v,n),
+        EXISTS(l,v,n),
+        AND(l,n,n),
+        OR(l,n,n),
+        IMP(l,n,n),
+        IFF(l,n,n),
+        PRED(l,v,n,v[,v]*) where the brackets and star indicate zero or more repetitions,
+        LEQ(n,n),
+        HOLE(n),
+        LABEL(n)
+        where l is the label of the node described by the predicate, n is either
+        a label or a hole, and v is a variable.
+        """
+        self.holes = set()
+        self.labels = set()
+        self.fragments = {}  # mapping of label -> formula fragment
+        self.constraints = set()  # set of Constraints
+        self._break_down(usr)
+        self.top_most_labels = self._find_top_most_labels()
+        self.top_hole = self._find_top_hole()
+
+    def is_node(self, x):
+        """
+        Return true if x is a node (label or hole) in this semantic
+        representation.
+        """
+        return x in (self.labels | self.holes)
+
+    def _break_down(self, usr):
+        """
+        Extract holes, labels, formula fragments and constraints from the hole
+        semantics underspecified representation (USR).
+        """
+        if isinstance(usr, AndExpression):
+            self._break_down(usr.first)
+            self._break_down(usr.second)
+        elif isinstance(usr, ApplicationExpression):
+            func, args = usr.uncurry()
+            if func.variable.name == Constants.LEQ:
+                self.constraints.add(Constraint(args[0], args[1]))
+            elif func.variable.name == Constants.HOLE:
+                self.holes.add(args[0])
+            elif func.variable.name == Constants.LABEL:
+                self.labels.add(args[0])
+            else:
+                label = args[0]
+                assert label not in self.fragments
+                self.fragments[label] = (func, args[1:])
+        else:
+            raise ValueError(usr.label())
+
+    def _find_top_nodes(self, node_list):
+        top_nodes = node_list.copy()
+        for f in self.fragments.values():
+            # the label is the first argument of the predicate
+            args = f[1]
+            for arg in args:
+                if arg in node_list:
+                    top_nodes.discard(arg)
+        return top_nodes
+
+    def _find_top_most_labels(self):
+        """
+        Return the set of labels which are not referenced directly as part of
+        another formula fragment.  These will be the top-most labels for the
+        subtree that they are part of.
+        """
+        return self._find_top_nodes(self.labels)
+
+    def _find_top_hole(self):
+        """
+        Return the hole that will be the top of the formula tree.
+        """
+        top_holes = self._find_top_nodes(self.holes)
+        assert len(top_holes) == 1  # it must be unique
+        return top_holes.pop()
+
+    def pluggings(self):
+        """
+        Calculate and return all the legal pluggings (mappings of labels to
+        holes) of this semantics given the constraints.
+        """
+        record = []
+        self._plug_nodes([(self.top_hole, [])], self.top_most_labels, {}, record)
+        return record
+
+    def _plug_nodes(self, queue, potential_labels, plug_acc, record):
+        """
+        Plug the nodes in `queue' with the labels in `potential_labels'.
+
+        Each element of `queue' is a tuple of the node to plug and the list of
+        ancestor holes from the root of the graph to that node.
+
+        `potential_labels' is a set of the labels which are still available for
+        plugging.
+
+        `plug_acc' is the incomplete mapping of holes to labels made on the
+        current branch of the search tree so far.
+
+        `record' is a list of all the complete pluggings that we have found in
+        total so far.  It is the only parameter that is destructively updated.
+        """
+        if queue != []:
+            (node, ancestors) = queue[0]
+            if node in self.holes:
+                # The node is a hole, try to plug it.
+                self._plug_hole(
+                    node, ancestors, queue[1:], potential_labels, plug_acc, record
+                )
+            else:
+                assert node in self.labels
+                # The node is a label.  Replace it in the queue by the holes and
+                # labels in the formula fragment named by that label.
+                args = self.fragments[node][1]
+                head = [(a, ancestors) for a in args if self.is_node(a)]
+                self._plug_nodes(head + queue[1:], potential_labels, plug_acc, record)
+        else:
+            raise Exception("queue empty")
+
+    def _plug_hole(self, hole, ancestors0, queue, potential_labels0, plug_acc0, record):
+        """
+        Try all possible ways of plugging a single hole.
+        See _plug_nodes for the meanings of the parameters.
+        """
+        # Add the current hole we're trying to plug into the list of ancestors.
+        assert hole not in ancestors0
+        ancestors = [hole] + ancestors0
+
+        # Try each potential label in this hole in turn.
+        for l in potential_labels0:
+            # Is the label valid in this hole?
+            if self._violates_constraints(l, ancestors):
+                continue
+
+            plug_acc = plug_acc0.copy()
+            plug_acc[hole] = l
+            potential_labels = potential_labels0.copy()
+            potential_labels.remove(l)
+
+            if len(potential_labels) == 0:
+                # No more potential labels.  That must mean all the holes have
+                # been filled so we have found a legal plugging so remember it.
+                #
+                # Note that the queue might not be empty because there might
+                # be labels on there that point to formula fragments with
+                # no holes in them.  _sanity_check_plugging will make sure
+                # all holes are filled.
+                self._sanity_check_plugging(plug_acc, self.top_hole, [])
+                record.append(plug_acc)
+            else:
+                # Recursively try to fill in the rest of the holes in the
+                # queue.  The label we just plugged into the hole could have
+                # holes of its own so at the end of the queue.  Putting it on
+                # the end of the queue gives us a breadth-first search, so that
+                # all the holes at level i of the formula tree are filled
+                # before filling level i+1.
+                # A depth-first search would work as well since the trees must
+                # be finite but the bookkeeping would be harder.
+                self._plug_nodes(
+                    queue + [(l, ancestors)], potential_labels, plug_acc, record
+                )
+
+    def _violates_constraints(self, label, ancestors):
+        """
+        Return True if the `label' cannot be placed underneath the holes given
+        by the set `ancestors' because it would violate the constraints imposed
+        on it.
+        """
+        for c in self.constraints:
+            if c.lhs == label:
+                if c.rhs not in ancestors:
+                    return True
+        return False
+
+    def _sanity_check_plugging(self, plugging, node, ancestors):
+        """
+        Make sure that a given plugging is legal.  We recursively go through
+        each node and make sure that no constraints are violated.
+        We also check that all holes have been filled.
+        """
+        if node in self.holes:
+            ancestors = [node] + ancestors
+            label = plugging[node]
+        else:
+            label = node
+        assert label in self.labels
+        for c in self.constraints:
+            if c.lhs == label:
+                assert c.rhs in ancestors
+        args = self.fragments[label][1]
+        for arg in args:
+            if self.is_node(arg):
+                self._sanity_check_plugging(plugging, arg, [label] + ancestors)
+
+    def formula_tree(self, plugging):
+        """
+        Return the first-order logic formula tree for this underspecified
+        representation using the plugging given.
+        """
+        return self._formula_tree(plugging, self.top_hole)
+
+    def _formula_tree(self, plugging, node):
+        if node in plugging:
+            return self._formula_tree(plugging, plugging[node])
+        elif node in self.fragments:
+            pred, args = self.fragments[node]
+            children = [self._formula_tree(plugging, arg) for arg in args]
+            return reduce(Constants.MAP[pred.variable.name], children)
+        else:
+            return node
+
+
+class Constraint:
+    """
+    This class represents a constraint of the form (L =< N),
+    where L is a label and N is a node (a label or a hole).
+    """
+
+    def __init__(self, lhs, rhs):
+        self.lhs = lhs
+        self.rhs = rhs
+
+    def __eq__(self, other):
+        if self.__class__ == other.__class__:
+            return self.lhs == other.lhs and self.rhs == other.rhs
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def __repr__(self):
+        return f"({self.lhs} < {self.rhs})"
+
+
+def hole_readings(sentence, grammar_filename=None, verbose=False):
+    if not grammar_filename:
+        grammar_filename = "grammars/sample_grammars/hole.fcfg"
+
+    if verbose:
+        print("Reading grammar file", grammar_filename)
+
+    parser = load_parser(grammar_filename)
+
+    # Parse the sentence.
+    tokens = sentence.split()
+    trees = list(parser.parse(tokens))
+    if verbose:
+        print("Got %d different parses" % len(trees))
+
+    all_readings = []
+    for tree in trees:
+        # Get the semantic feature from the top of the parse tree.
+        sem = tree.label()["SEM"].simplify()
+
+        # Print the raw semantic representation.
+        if verbose:
+            print("Raw:       ", sem)
+
+        # Skolemize away all quantifiers.  All variables become unique.
+        while isinstance(sem, LambdaExpression):
+            sem = sem.term
+        skolemized = skolemize(sem)
+
+        if verbose:
+            print("Skolemized:", skolemized)
+
+        # Break the hole semantics representation down into its components
+        # i.e. holes, labels, formula fragments and constraints.
+        hole_sem = HoleSemantics(skolemized)
+
+        # Maybe show the details of the semantic representation.
+        if verbose:
+            print("Holes:       ", hole_sem.holes)
+            print("Labels:      ", hole_sem.labels)
+            print("Constraints: ", hole_sem.constraints)
+            print("Top hole:    ", hole_sem.top_hole)
+            print("Top labels:  ", hole_sem.top_most_labels)
+            print("Fragments:")
+            for l, f in hole_sem.fragments.items():
+                print(f"\t{l}: {f}")
+
+        # Find all the possible ways to plug the formulas together.
+        pluggings = hole_sem.pluggings()
+
+        # Build FOL formula trees using the pluggings.
+        readings = list(map(hole_sem.formula_tree, pluggings))
+
+        # Print out the formulas in a textual format.
+        if verbose:
+            for i, r in enumerate(readings):
+                print()
+                print("%d. %s" % (i, r))
+            print()
+
+        all_readings.extend(readings)
+
+    return all_readings
+
+
+if __name__ == "__main__":
+    for r in hole_readings("a dog barks"):
+        print(r)
+    print()
+    for r in hole_readings("every girl chases a dog"):
+        print(r)

llmeval-env/lib/python3.10/site-packages/nltk/sem/lfg.py

@@ -0,0 +1,261 @@
+# Natural Language Toolkit: Lexical Functional Grammar
+#
+# Author: Dan Garrette <[email protected]>
+#
+# Copyright (C) 2001-2023 NLTK Project
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+from itertools import chain
+
+from nltk.internals import Counter
+
+
+class FStructure(dict):
+    def safeappend(self, key, item):
+        """
+        Append 'item' to the list at 'key'.  If no list exists for 'key', then
+        construct one.
+        """
+        if key not in self:
+            self[key] = []
+        self[key].append(item)
+
+    def __setitem__(self, key, value):
+        dict.__setitem__(self, key.lower(), value)
+
+    def __getitem__(self, key):
+        return dict.__getitem__(self, key.lower())
+
+    def __contains__(self, key):
+        return dict.__contains__(self, key.lower())
+
+    def to_glueformula_list(self, glue_dict):
+        depgraph = self.to_depgraph()
+        return glue_dict.to_glueformula_list(depgraph)
+
+    def to_depgraph(self, rel=None):
+        from nltk.parse.dependencygraph import DependencyGraph
+
+        depgraph = DependencyGraph()
+        nodes = depgraph.nodes
+
+        self._to_depgraph(nodes, 0, "ROOT")
+
+        # Add all the dependencies for all the nodes
+        for address, node in nodes.items():
+            for n2 in (n for n in nodes.values() if n["rel"] != "TOP"):
+                if n2["head"] == address:
+                    relation = n2["rel"]
+                    node["deps"].setdefault(relation, [])
+                    node["deps"][relation].append(n2["address"])
+
+        depgraph.root = nodes[1]
+
+        return depgraph
+
+    def _to_depgraph(self, nodes, head, rel):
+        index = len(nodes)
+
+        nodes[index].update(
+            {
+                "address": index,
+                "word": self.pred[0],
+                "tag": self.pred[1],
+                "head": head,
+                "rel": rel,
+            }
+        )
+
+        for feature in sorted(self):
+            for item in sorted(self[feature]):
+                if isinstance(item, FStructure):
+                    item._to_depgraph(nodes, index, feature)
+                elif isinstance(item, tuple):
+                    new_index = len(nodes)
+                    nodes[new_index].update(
+                        {
+                            "address": new_index,
+                            "word": item[0],
+                            "tag": item[1],
+                            "head": index,
+                            "rel": feature,
+                        }
+                    )
+                elif isinstance(item, list):
+                    for n in item:
+                        n._to_depgraph(nodes, index, feature)
+                else:
+                    raise Exception(
+                        "feature %s is not an FStruct, a list, or a tuple" % feature
+                    )
+
+    @staticmethod
+    def read_depgraph(depgraph):
+        return FStructure._read_depgraph(depgraph.root, depgraph)
+
+    @staticmethod
+    def _read_depgraph(node, depgraph, label_counter=None, parent=None):
+        if not label_counter:
+            label_counter = Counter()
+
+        if node["rel"].lower() in ["spec", "punct"]:
+            # the value of a 'spec' entry is a word, not an FStructure
+            return (node["word"], node["tag"])
+
+        else:
+            fstruct = FStructure()
+            fstruct.pred = None
+            fstruct.label = FStructure._make_label(label_counter.get())
+
+            fstruct.parent = parent
+
+            word, tag = node["word"], node["tag"]
+            if tag[:2] == "VB":
+                if tag[2:3] == "D":
+                    fstruct.safeappend("tense", ("PAST", "tense"))
+                fstruct.pred = (word, tag[:2])
+
+            if not fstruct.pred:
+                fstruct.pred = (word, tag)
+
+            children = [
+                depgraph.nodes[idx]
+                for idx in chain.from_iterable(node["deps"].values())
+            ]
+            for child in children:
+                fstruct.safeappend(
+                    child["rel"],
+                    FStructure._read_depgraph(child, depgraph, label_counter, fstruct),
+                )
+
+            return fstruct
+
+    @staticmethod
+    def _make_label(value):
+        """
+        Pick an alphabetic character as identifier for an entity in the model.
+
+        :param value: where to index into the list of characters
+        :type value: int
+        """
+        letter = [
+            "f",
+            "g",
+            "h",
+            "i",
+            "j",
+            "k",
+            "l",
+            "m",
+            "n",
+            "o",
+            "p",
+            "q",
+            "r",
+            "s",
+            "t",
+            "u",
+            "v",
+            "w",
+            "x",
+            "y",
+            "z",
+            "a",
+            "b",
+            "c",
+            "d",
+            "e",
+        ][value - 1]
+        num = int(value) // 26
+        if num > 0:
+            return letter + str(num)
+        else:
+            return letter
+
+    def __repr__(self):
+        return self.__str__().replace("\n", "")
+
+    def __str__(self):
+        return self.pretty_format()
+
+    def pretty_format(self, indent=3):
+        try:
+            accum = "%s:[" % self.label
+        except NameError:
+            accum = "["
+        try:
+            accum += "pred '%s'" % (self.pred[0])
+        except NameError:
+            pass
+
+        for feature in sorted(self):
+            for item in self[feature]:
+                if isinstance(item, FStructure):
+                    next_indent = indent + len(feature) + 3 + len(self.label)
+                    accum += "\n{}{} {}".format(
+                        " " * (indent),
+                        feature,
+                        item.pretty_format(next_indent),
+                    )
+                elif isinstance(item, tuple):
+                    accum += "\n{}{} '{}'".format(" " * (indent), feature, item[0])
+                elif isinstance(item, list):
+                    accum += "\n{}{} {{{}}}".format(
+                        " " * (indent),
+                        feature,
+                        ("\n%s" % (" " * (indent + len(feature) + 2))).join(item),
+                    )
+                else:  # ERROR
+                    raise Exception(
+                        "feature %s is not an FStruct, a list, or a tuple" % feature
+                    )
+        return accum + "]"
+
+
+def demo_read_depgraph():
+    from nltk.parse.dependencygraph import DependencyGraph
+
+    dg1 = DependencyGraph(
+        """\
+Esso       NNP     2       SUB
+said       VBD     0       ROOT
+the        DT      5       NMOD
+Whiting    NNP     5       NMOD
+field      NN      6       SUB
+started    VBD     2       VMOD
+production NN      6       OBJ
+Tuesday    NNP     6       VMOD
+"""
+    )
+    dg2 = DependencyGraph(
+        """\
+John    NNP     2       SUB
+sees    VBP     0       ROOT
+Mary    NNP     2       OBJ
+"""
+    )
+    dg3 = DependencyGraph(
+        """\
+a       DT      2       SPEC
+man     NN      3       SUBJ
+walks   VB      0       ROOT
+"""
+    )
+    dg4 = DependencyGraph(
+        """\
+every   DT      2       SPEC
+girl    NN      3       SUBJ
+chases  VB      0       ROOT
+a       DT      5       SPEC
+dog     NN      3       OBJ
+"""
+    )
+
+    depgraphs = [dg1, dg2, dg3, dg4]
+    for dg in depgraphs:
+        print(FStructure.read_depgraph(dg))
+
+
+if __name__ == "__main__":
+    demo_read_depgraph()