jupytersketcher/Lib/site-packages/nltk/test/ccg_semantics.doctest

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

==============================================
Combinatory Categorial Grammar with semantics
==============================================

-----
Chart
-----


    >>> from nltk.ccg import chart, lexicon
    >>> from nltk.ccg.chart import printCCGDerivation

No semantics
-------------------

    >>> lex = lexicon.fromstring('''
    ...     :- S, NP, N
    ...     She => NP
    ...     has => (S\\NP)/NP
    ...     books => NP
    ...     ''',
    ...     False)

    >>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
    >>> parses = list(parser.parse("She has books".split()))
    >>> print(str(len(parses)) + " parses")
    3 parses

    >>> printCCGDerivation(parses[0])
     She      has      books
     NP   ((S\NP)/NP)   NP
         -------------------->
                (S\NP)
    -------------------------<
                S

    >>> printCCGDerivation(parses[1])
     She      has      books
     NP   ((S\NP)/NP)   NP
    ----->T
    (S/(S\NP))
         -------------------->
                (S\NP)
    ------------------------->
                S


    >>> printCCGDerivation(parses[2])
     She      has      books
     NP   ((S\NP)/NP)   NP
    ----->T
    (S/(S\NP))
    ------------------>B
          (S/NP)
    ------------------------->
                S

Simple semantics
-------------------

    >>> lex = lexicon.fromstring('''
    ...     :- S, NP, N
    ...     She => NP {she}
    ...     has => (S\\NP)/NP {\\x y.have(y, x)}
    ...     a => NP/N {\\P.exists z.P(z)}
    ...     book => N {book}
    ...     ''',
    ...     True)

    >>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
    >>> parses = list(parser.parse("She has a book".split()))
    >>> print(str(len(parses)) + " parses")
    7 parses

    >>> printCCGDerivation(parses[0])
       She                 has                           a                book
     NP {she}  ((S\NP)/NP) {\x y.have(y,x)}  (NP/N) {\P.exists z.P(z)}  N {book}
                                            ------------------------------------->
                                                    NP {exists z.book(z)}
              ------------------------------------------------------------------->
                             (S\NP) {\y.have(y,exists z.book(z))}
    -----------------------------------------------------------------------------<
                           S {have(she,exists z.book(z))}

    >>> printCCGDerivation(parses[1])
       She                 has                           a                book
     NP {she}  ((S\NP)/NP) {\x y.have(y,x)}  (NP/N) {\P.exists z.P(z)}  N {book}
              --------------------------------------------------------->B
                       ((S\NP)/N) {\P y.have(y,exists z.P(z))}
              ------------------------------------------------------------------->
                             (S\NP) {\y.have(y,exists z.book(z))}
    -----------------------------------------------------------------------------<
                           S {have(she,exists z.book(z))}
    
    >>> printCCGDerivation(parses[2])
       She                 has                           a                book
     NP {she}  ((S\NP)/NP) {\x y.have(y,x)}  (NP/N) {\P.exists z.P(z)}  N {book}
    ---------->T
    (S/(S\NP)) {\F.F(she)}
                                            ------------------------------------->
                                                    NP {exists z.book(z)}
              ------------------------------------------------------------------->
                             (S\NP) {\y.have(y,exists z.book(z))}
    ----------------------------------------------------------------------------->
                           S {have(she,exists z.book(z))}

    >>> printCCGDerivation(parses[3])
       She                 has                           a                book
     NP {she}  ((S\NP)/NP) {\x y.have(y,x)}  (NP/N) {\P.exists z.P(z)}  N {book}
    ---------->T
    (S/(S\NP)) {\F.F(she)}
              --------------------------------------------------------->B
                       ((S\NP)/N) {\P y.have(y,exists z.P(z))}
              ------------------------------------------------------------------->
                             (S\NP) {\y.have(y,exists z.book(z))}
    ----------------------------------------------------------------------------->
                           S {have(she,exists z.book(z))}

    >>> printCCGDerivation(parses[4])
       She                 has                           a                book
     NP {she}  ((S\NP)/NP) {\x y.have(y,x)}  (NP/N) {\P.exists z.P(z)}  N {book}
    ---------->T
    (S/(S\NP)) {\F.F(she)}
    ---------------------------------------->B
            (S/NP) {\x.have(she,x)}
                                            ------------------------------------->
                                                    NP {exists z.book(z)}
    ----------------------------------------------------------------------------->
                           S {have(she,exists z.book(z))}

    >>> printCCGDerivation(parses[5])
       She                 has                           a                book
     NP {she}  ((S\NP)/NP) {\x y.have(y,x)}  (NP/N) {\P.exists z.P(z)}  N {book}
    ---------->T
    (S/(S\NP)) {\F.F(she)}
              --------------------------------------------------------->B
                       ((S\NP)/N) {\P y.have(y,exists z.P(z))}
    ------------------------------------------------------------------->B
                    (S/N) {\P.have(she,exists z.P(z))}
    ----------------------------------------------------------------------------->
                           S {have(she,exists z.book(z))}

    >>> printCCGDerivation(parses[6])
       She                 has                           a                book
     NP {she}  ((S\NP)/NP) {\x y.have(y,x)}  (NP/N) {\P.exists z.P(z)}  N {book}
    ---------->T
    (S/(S\NP)) {\F.F(she)}
    ---------------------------------------->B
            (S/NP) {\x.have(she,x)}
    ------------------------------------------------------------------->B
                    (S/N) {\P.have(she,exists z.P(z))}
    ----------------------------------------------------------------------------->
                           S {have(she,exists z.book(z))}

Complex semantics
-------------------

    >>> lex = lexicon.fromstring('''
    ...     :- S, NP, N
    ...     She => NP {she}
    ...     has => (S\\NP)/NP {\\x y.have(y, x)}
    ...     a => ((S\\NP)\\((S\\NP)/NP))/N {\\P R x.(exists z.P(z) & R(z,x))}
    ...     book => N {book}
    ...     ''',
    ...     True)

    >>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
    >>> parses = list(parser.parse("She has a book".split()))
    >>> print(str(len(parses)) + " parses")
    2 parses

    >>> printCCGDerivation(parses[0])
       She                 has                                           a                                 book
     NP {she}  ((S\NP)/NP) {\x y.have(y,x)}  (((S\NP)\((S\NP)/NP))/N) {\P R x.(exists z.P(z) & R(z,x))}  N {book}
                                            ---------------------------------------------------------------------->
                                                   ((S\NP)\((S\NP)/NP)) {\R x.(exists z.book(z) & R(z,x))}
              ----------------------------------------------------------------------------------------------------<
                                           (S\NP) {\x.(exists z.book(z) & have(x,z))}
    --------------------------------------------------------------------------------------------------------------<
                                         S {(exists z.book(z) & have(she,z))}

    >>> printCCGDerivation(parses[1])
       She                 has                                           a                                 book
     NP {she}  ((S\NP)/NP) {\x y.have(y,x)}  (((S\NP)\((S\NP)/NP))/N) {\P R x.(exists z.P(z) & R(z,x))}  N {book}
    ---------->T
    (S/(S\NP)) {\F.F(she)}
                                            ---------------------------------------------------------------------->
                                                   ((S\NP)\((S\NP)/NP)) {\R x.(exists z.book(z) & R(z,x))}
              ----------------------------------------------------------------------------------------------------<
                                           (S\NP) {\x.(exists z.book(z) & have(x,z))}
    -------------------------------------------------------------------------------------------------------------->
                                         S {(exists z.book(z) & have(she,z))}

Using conjunctions
---------------------

    # TODO: The semantics of "and" should have been more flexible
    >>> lex = lexicon.fromstring('''
    ...     :- S, NP, N
    ...     I => NP {I}
    ...     cook => (S\\NP)/NP {\\x y.cook(x,y)}
    ...     and => var\\.,var/.,var {\\P Q x y.(P(x,y) & Q(x,y))}
    ...     eat => (S\\NP)/NP {\\x y.eat(x,y)}
    ...     the => NP/N {\\x.the(x)}
    ...     bacon => N {bacon}
    ...     ''',
    ...     True)

    >>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
    >>> parses = list(parser.parse("I cook and eat the bacon".split()))
    >>> print(str(len(parses)) + " parses")
    7 parses

    >>> printCCGDerivation(parses[0])
       I                 cook                                       and                                        eat                     the            bacon
     NP {I}  ((S\NP)/NP) {\x y.cook(x,y)}  ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))}  ((S\NP)/NP) {\x y.eat(x,y)}  (NP/N) {\x.the(x)}  N {bacon}
                                          ------------------------------------------------------------------------------------->
                                                        (((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
            -------------------------------------------------------------------------------------------------------------------<
                                                 ((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
                                                                                                                               ------------------------------->
                                                                                                                                       NP {the(bacon)}
            -------------------------------------------------------------------------------------------------------------------------------------------------->
                                                           (S\NP) {\y.(eat(the(bacon),y) & cook(the(bacon),y))}
    ----------------------------------------------------------------------------------------------------------------------------------------------------------<
                                                           S {(eat(the(bacon),I) & cook(the(bacon),I))}

    >>> printCCGDerivation(parses[1])
       I                 cook                                       and                                        eat                     the            bacon
     NP {I}  ((S\NP)/NP) {\x y.cook(x,y)}  ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))}  ((S\NP)/NP) {\x y.eat(x,y)}  (NP/N) {\x.the(x)}  N {bacon}
                                          ------------------------------------------------------------------------------------->
                                                        (((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
            -------------------------------------------------------------------------------------------------------------------<
                                                 ((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
            --------------------------------------------------------------------------------------------------------------------------------------->B
                                                      ((S\NP)/N) {\x y.(eat(the(x),y) & cook(the(x),y))}
            -------------------------------------------------------------------------------------------------------------------------------------------------->
                                                           (S\NP) {\y.(eat(the(bacon),y) & cook(the(bacon),y))}
    ----------------------------------------------------------------------------------------------------------------------------------------------------------<
                                                           S {(eat(the(bacon),I) & cook(the(bacon),I))}

    >>> printCCGDerivation(parses[2])
       I                 cook                                       and                                        eat                     the            bacon
     NP {I}  ((S\NP)/NP) {\x y.cook(x,y)}  ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))}  ((S\NP)/NP) {\x y.eat(x,y)}  (NP/N) {\x.the(x)}  N {bacon}
    -------->T
    (S/(S\NP)) {\F.F(I)}
                                          ------------------------------------------------------------------------------------->
                                                        (((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
            -------------------------------------------------------------------------------------------------------------------<
                                                 ((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
                                                                                                                               ------------------------------->
                                                                                                                                       NP {the(bacon)}
            -------------------------------------------------------------------------------------------------------------------------------------------------->
                                                           (S\NP) {\y.(eat(the(bacon),y) & cook(the(bacon),y))}
    ---------------------------------------------------------------------------------------------------------------------------------------------------------->
                                                           S {(eat(the(bacon),I) & cook(the(bacon),I))}

    >>> printCCGDerivation(parses[3])
       I                 cook                                       and                                        eat                     the            bacon
     NP {I}  ((S\NP)/NP) {\x y.cook(x,y)}  ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))}  ((S\NP)/NP) {\x y.eat(x,y)}  (NP/N) {\x.the(x)}  N {bacon}
    -------->T
    (S/(S\NP)) {\F.F(I)}
                                          ------------------------------------------------------------------------------------->
                                                        (((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
            -------------------------------------------------------------------------------------------------------------------<
                                                 ((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
            --------------------------------------------------------------------------------------------------------------------------------------->B
                                                      ((S\NP)/N) {\x y.(eat(the(x),y) & cook(the(x),y))}
            -------------------------------------------------------------------------------------------------------------------------------------------------->
                                                           (S\NP) {\y.(eat(the(bacon),y) & cook(the(bacon),y))}
    ---------------------------------------------------------------------------------------------------------------------------------------------------------->
                                                           S {(eat(the(bacon),I) & cook(the(bacon),I))}

    >>> printCCGDerivation(parses[4])
       I                 cook                                       and                                        eat                     the            bacon
     NP {I}  ((S\NP)/NP) {\x y.cook(x,y)}  ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))}  ((S\NP)/NP) {\x y.eat(x,y)}  (NP/N) {\x.the(x)}  N {bacon}
    -------->T
    (S/(S\NP)) {\F.F(I)}
                                          ------------------------------------------------------------------------------------->
                                                        (((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
            -------------------------------------------------------------------------------------------------------------------<
                                                 ((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
    --------------------------------------------------------------------------------------------------------------------------->B
                                                (S/NP) {\x.(eat(x,I) & cook(x,I))}
                                                                                                                               ------------------------------->
                                                                                                                                       NP {the(bacon)}
    ---------------------------------------------------------------------------------------------------------------------------------------------------------->
                                                           S {(eat(the(bacon),I) & cook(the(bacon),I))}

    >>> printCCGDerivation(parses[5])
       I                 cook                                       and                                        eat                     the            bacon
     NP {I}  ((S\NP)/NP) {\x y.cook(x,y)}  ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))}  ((S\NP)/NP) {\x y.eat(x,y)}  (NP/N) {\x.the(x)}  N {bacon}
    -------->T
    (S/(S\NP)) {\F.F(I)}
                                          ------------------------------------------------------------------------------------->
                                                        (((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
            -------------------------------------------------------------------------------------------------------------------<
                                                 ((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
            --------------------------------------------------------------------------------------------------------------------------------------->B
                                                      ((S\NP)/N) {\x y.(eat(the(x),y) & cook(the(x),y))}
    ----------------------------------------------------------------------------------------------------------------------------------------------->B
                                                      (S/N) {\x.(eat(the(x),I) & cook(the(x),I))}
    ---------------------------------------------------------------------------------------------------------------------------------------------------------->
                                                           S {(eat(the(bacon),I) & cook(the(bacon),I))}

    >>> printCCGDerivation(parses[6])
       I                 cook                                       and                                        eat                     the            bacon
     NP {I}  ((S\NP)/NP) {\x y.cook(x,y)}  ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))}  ((S\NP)/NP) {\x y.eat(x,y)}  (NP/N) {\x.the(x)}  N {bacon}
    -------->T
    (S/(S\NP)) {\F.F(I)}
                                          ------------------------------------------------------------------------------------->
                                                        (((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
            -------------------------------------------------------------------------------------------------------------------<
                                                 ((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
    --------------------------------------------------------------------------------------------------------------------------->B
                                                (S/NP) {\x.(eat(x,I) & cook(x,I))}
    ----------------------------------------------------------------------------------------------------------------------------------------------->B
                                                      (S/N) {\x.(eat(the(x),I) & cook(the(x),I))}
    ---------------------------------------------------------------------------------------------------------------------------------------------------------->
                                                           S {(eat(the(bacon),I) & cook(the(bacon),I))}

Tests from published papers
------------------------------

An example from "CCGbank: A Corpus of CCG Derivations and Dependency Structures Extracted from the Penn Treebank", Hockenmaier and Steedman, 2007, Page 359, https://www.aclweb.org/anthology/J/J07/J07-3004.pdf

    >>> lex = lexicon.fromstring('''
    ...     :- S, NP
    ...     I => NP {I}
    ...     give => ((S\\NP)/NP)/NP {\\x y z.give(y,x,z)}
    ...     them => NP {them}
    ...     money => NP {money}
    ...     ''',
    ...     True)

    >>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
    >>> parses = list(parser.parse("I give them money".split()))
    >>> print(str(len(parses)) + " parses")
    3 parses

    >>> printCCGDerivation(parses[0])
       I                     give                     them       money
     NP {I}  (((S\NP)/NP)/NP) {\x y z.give(y,x,z)}  NP {them}  NP {money}
            -------------------------------------------------->
                    ((S\NP)/NP) {\y z.give(y,them,z)}
            -------------------------------------------------------------->
                            (S\NP) {\z.give(money,them,z)}
    ----------------------------------------------------------------------<
                            S {give(money,them,I)}

    >>> printCCGDerivation(parses[1])
       I                     give                     them       money
     NP {I}  (((S\NP)/NP)/NP) {\x y z.give(y,x,z)}  NP {them}  NP {money}
    -------->T
    (S/(S\NP)) {\F.F(I)}
            -------------------------------------------------->
                    ((S\NP)/NP) {\y z.give(y,them,z)}
            -------------------------------------------------------------->
                            (S\NP) {\z.give(money,them,z)}
    ---------------------------------------------------------------------->
                            S {give(money,them,I)}

    
    >>> printCCGDerivation(parses[2])
       I                     give                     them       money
     NP {I}  (((S\NP)/NP)/NP) {\x y z.give(y,x,z)}  NP {them}  NP {money}
    -------->T
    (S/(S\NP)) {\F.F(I)}
            -------------------------------------------------->
                    ((S\NP)/NP) {\y z.give(y,them,z)}
    ---------------------------------------------------------->B
                    (S/NP) {\y.give(y,them,I)}
    ---------------------------------------------------------------------->
                            S {give(money,them,I)}


An example from "CCGbank: A Corpus of CCG Derivations and Dependency Structures Extracted from the Penn Treebank", Hockenmaier and Steedman, 2007, Page 359, https://www.aclweb.org/anthology/J/J07/J07-3004.pdf

    >>> lex = lexicon.fromstring('''
    ...     :- N, NP, S
    ...     money => N {money}
    ...     that => (N\\N)/(S/NP) {\\P Q x.(P(x) & Q(x))}
    ...     I => NP {I}
    ...     give => ((S\\NP)/NP)/NP {\\x y z.give(y,x,z)}
    ...     them => NP {them}
    ...     ''',
    ...     True)

    >>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
    >>> parses = list(parser.parse("money that I give them".split()))
    >>> print(str(len(parses)) + " parses")
    3 parses

    >>> printCCGDerivation(parses[0])
       money                    that                     I                     give                     them
     N {money}  ((N\N)/(S/NP)) {\P Q x.(P(x) & Q(x))}  NP {I}  (((S\NP)/NP)/NP) {\x y z.give(y,x,z)}  NP {them}
                                                      -------->T
                                                (S/(S\NP)) {\F.F(I)}
                                                              -------------------------------------------------->
                                                                      ((S\NP)/NP) {\y z.give(y,them,z)}
                                                      ---------------------------------------------------------->B
                                                                      (S/NP) {\y.give(y,them,I)}
               ------------------------------------------------------------------------------------------------->
                                             (N\N) {\Q x.(give(x,them,I) & Q(x))}
    ------------------------------------------------------------------------------------------------------------<
                                         N {\x.(give(x,them,I) & money(x))}

    >>> printCCGDerivation(parses[1])
       money                    that                     I                     give                     them
     N {money}  ((N\N)/(S/NP)) {\P Q x.(P(x) & Q(x))}  NP {I}  (((S\NP)/NP)/NP) {\x y z.give(y,x,z)}  NP {them}
    ----------->T
    (N/(N\N)) {\F.F(money)}
                                                      -------->T
                                                (S/(S\NP)) {\F.F(I)}
                                                              -------------------------------------------------->
                                                                      ((S\NP)/NP) {\y z.give(y,them,z)}
                                                      ---------------------------------------------------------->B
                                                                      (S/NP) {\y.give(y,them,I)}
               ------------------------------------------------------------------------------------------------->
                                             (N\N) {\Q x.(give(x,them,I) & Q(x))}
    ------------------------------------------------------------------------------------------------------------>
                                         N {\x.(give(x,them,I) & money(x))}

    >>> printCCGDerivation(parses[2])
       money                    that                     I                     give                     them
     N {money}  ((N\N)/(S/NP)) {\P Q x.(P(x) & Q(x))}  NP {I}  (((S\NP)/NP)/NP) {\x y z.give(y,x,z)}  NP {them}
    ----------->T
    (N/(N\N)) {\F.F(money)}
    -------------------------------------------------->B
           (N/(S/NP)) {\P x.(P(x) & money(x))}
                                                      -------->T
                                                (S/(S\NP)) {\F.F(I)}
                                                              -------------------------------------------------->
                                                                      ((S\NP)/NP) {\y z.give(y,them,z)}
                                                      ---------------------------------------------------------->B
                                                                      (S/NP) {\y.give(y,them,I)}
    ------------------------------------------------------------------------------------------------------------>
                                         N {\x.(give(x,them,I) & money(x))}


-------
Lexicon
-------

    >>> from nltk.ccg import lexicon

Parse lexicon with semantics

    >>> print(str(lexicon.fromstring(
    ...     '''
    ...     :- S,NP
    ...
    ...     IntransVsg :: S\\NP[sg]
    ...     
    ...     sleeps => IntransVsg {\\x.sleep(x)}
    ...     eats => S\\NP[sg]/NP {\\x y.eat(x,y)}
    ...        
    ...     and => var\\var/var {\\x y.x & y}
    ...     ''',
    ...     True
    ... )))
    and => ((_var0\_var0)/_var0) {(\x y.x & y)}
    eats => ((S\NP['sg'])/NP) {\x y.eat(x,y)}
    sleeps => (S\NP['sg']) {\x.sleep(x)}

Parse lexicon without semantics

    >>> print(str(lexicon.fromstring(
    ...     '''
    ...     :- S,NP
    ...
    ...     IntransVsg :: S\\NP[sg]
    ...     
    ...     sleeps => IntransVsg
    ...     eats => S\\NP[sg]/NP {sem=\\x y.eat(x,y)}
    ...        
    ...     and => var\\var/var
    ...     ''',
    ...     False
    ... )))
    and => ((_var0\_var0)/_var0)
    eats => ((S\NP['sg'])/NP)
    sleeps => (S\NP['sg'])

Semantics are missing

    >>> print(str(lexicon.fromstring(
    ...     '''
    ...     :- S,NP
    ...     
    ...     eats => S\\NP[sg]/NP
    ...     ''',
    ...     True
    ... )))
    Traceback (most recent call last):
      ...
    AssertionError: eats => S\NP[sg]/NP must contain semantics because include_semantics is set to True


------------------------------------
CCG combinator semantics computation
------------------------------------

    >>> from nltk.sem.logic import *
    >>> from nltk.ccg.logic import *

    >>> read_expr = Expression.fromstring

Compute semantics from function application

    >>> print(str(compute_function_semantics(read_expr(r'\x.P(x)'), read_expr(r'book'))))
    P(book)

    >>> print(str(compute_function_semantics(read_expr(r'\P.P(book)'), read_expr(r'read'))))
    read(book)

    >>> print(str(compute_function_semantics(read_expr(r'\P.P(book)'), read_expr(r'\x.read(x)'))))
    read(book)

Compute semantics from composition

    >>> print(str(compute_composition_semantics(read_expr(r'\x.P(x)'), read_expr(r'\x.Q(x)'))))
    \x.P(Q(x))

    >>> print(str(compute_composition_semantics(read_expr(r'\x.P(x)'), read_expr(r'read'))))
    Traceback (most recent call last):
      ...
    AssertionError: `read` must be a lambda expression

Compute semantics from substitution

    >>> print(str(compute_substitution_semantics(read_expr(r'\x y.P(x,y)'), read_expr(r'\x.Q(x)'))))
    \x.P(x,Q(x))
    
    >>> print(str(compute_substitution_semantics(read_expr(r'\x.P(x)'), read_expr(r'read'))))
    Traceback (most recent call last):
      ...
    AssertionError: `\x.P(x)` must be a lambda expression with 2 arguments

Compute type-raise semantics

    >>> print(str(compute_type_raised_semantics(read_expr(r'\x.P(x)'))))
    \F x.F(P(x))

    >>> print(str(compute_type_raised_semantics(read_expr(r'\x.F(x)'))))
    \F1 x.F1(F(x))

    >>> print(str(compute_type_raised_semantics(read_expr(r'\x y z.P(x,y,z)'))))
    \F x y z.F(P(x,y,z))