def test_lexical_binary_two_types(self):
semantic_index = SemanticIndex(None)
semantic_rules = [SemanticRule(r'cat1', r'\P.P', {'coq_type' : 'Entity -> Prop'}),
SemanticRule(r'cat2', r'\P.P', {'coq_type' : 'Entity -> Prop -> Prop'}),
SemanticRule(r'NP', r'\P Q.(Q -> P)', {'rule' : 'lex'})]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token base="base1" pos="pos1" surf="surf1" id="t1_1"/>
<token base="base2" pos="pos2" surf="surf2" id="t1_2"/>
</tokens>
<ccg root="sp1-3">
<span terminal="t1_1" category="cat1" end="2" begin="1" id="sp1-1"/>
<span terminal="t1_2" category="cat2" end="3" begin="2" id="sp1-2"/>
<span child="sp1-1 sp1-2" rule="lex" category="NP" end="3" begin="1" id="sp1-3"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
coq_types = get_coq_types(ccg_tree)
expected_coq_types = ["Parameter _base1 : Entity -> Prop.",
"Parameter _base2 : Entity -> Prop -> Prop."]
self.assertEqual(expected_coq_types, coq_types)
def test_lexical_binary_one_type(self):
semantic_index = SemanticIndex(None)
semantic_rules = [
SemanticRule(r'cat1', r'\P.P'),
SemanticRule(r'cat2', r'\Q x.Q(x)',
{'coq_type': 'Entity -> Prop'}),
SemanticRule(r'NP', r'\P Q x.(P -> Q(x))', {'rule': 'lex'})
]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token base="base1" pos="pos1" surf="surf1" id="t1_1"/>
<token base="base2" pos="pos2" surf="surf2" id="t1_2"/>
</tokens>
<ccg root="sp1-3">
<span terminal="t1_1" category="cat1" end="2" begin="1" id="sp1-1"/>
<span terminal="t1_2" category="cat2" end="3" begin="2" id="sp1-2"/>
<span child="sp1-1 sp1-2" rule="lex" category="NP" end="3" begin="1" id="sp1-3"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
coq_types = get_coq_types(ccg_tree)
expected_coq_types = ["Parameter _base2 : Entity -> Prop."]
self.assertEqual(expected_coq_types, coq_types)
def test_match_any2(self):
semantic_index = SemanticIndex(None)
semantic_rules = [
SemanticRule(r'cat1', r'\P.P'),
SemanticRule(r'cat2', r'\P.P'),
SemanticRule(r'cat3', r'\P.P'),
SemanticRule(r'NP', r'\P Q.(Q & P)', {'rule': 'lex'}),
SemanticRule(r'NP', r'\P Q.(Q | P)', {'child_any_pos': 'pos1'}),
SemanticRule(r'NP', r'\P Q.(Q -> P)',
{'child_any_category': 'cat3'})
]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token base="base1" pos="pos1" surf="surf1" id="t1_1"/>
<token base="base2" pos="pos2" surf="surf2" id="t1_2"/>
<token base="base3" pos="pos3" surf="surf3" id="t1_3"/>
</tokens>
<ccg root="sp1-5">
<span terminal="t1_1" category="cat1" pos="pos1" end="2" begin="1" id="sp1-1"/>
<span terminal="t1_2" category="cat2" pos="pos2" end="3" begin="2" id="sp1-2"/>
<span terminal="t1_3" category="cat3" pos="pos3" end="4" begin="3" id="sp1-3"/>
<span child="sp1-1 sp1-2" rule="lex" category="NP" end="3" begin="1" id="sp1-4"/>
<span child="sp1-4 sp1-3" rule="lex" category="NP" end="4" begin="1" id="sp1-5"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
semantics = ccg_tree.get('sem', None)
expected_semantics = lexpr(r'_base3 -> (_base2 | _base1)')
self.assertEqual(expected_semantics, lexpr(semantics))
def test_func_combination_backwardComplexTwoArgs(self):
semantic_index = SemanticIndex(None)
semantic_rules = [
SemanticRule(r'S\NP\NP', r'\P y x e. P(e, x, y)'),
SemanticRule(r'S\S', r'\P Q e. AND(past(e), Q(e))')
]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token id="s1_4" surf="ほめ" pos="動詞" pos1="自立" pos2="*" pos3="*" inflectionType="一段" inflectionForm="連用形" base="ほめる" reading="ホメ"/>
<token id="s1_5" surf="た" pos="助動詞" pos1="*" pos2="*" pos3="*" inflectionType="特殊・タ" inflectionForm="基本形" base="た" reading="タ"/>
</tokens>
<ccg root="s1_sp9">
<span id="s1_sp9" begin="4" end="6" category="(S[mod=nm,form=base]\NP[mod=nm,case=ga])\NP[mod=nm,case=o]" rule="<B2" child="s1_sp10 s1_sp11"/>
<span id="s1_sp10" begin="4" end="5" category="(S[mod=nm,form=cont]\NP[mod=nm,case=ga])\NP[mod=nm,case=o]" terminal="s1_4"/>
<span id="s1_sp11" begin="5" end="6" category="S[mod=nm,form=base]\S[mod=nm,form=cont]" terminal="s1_5"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
semantics = ccg_tree.get('sem', None)
expected_semantics = lexpr(r'\y x e.AND(past(e), _ほめる(x, y, e))')
self.assertEqual(expected_semantics, lexpr(semantics))
def test_match_any2(self):
semantic_index = SemanticIndex(None)
semantic_rules = [SemanticRule(r'cat1', r'\P.P'),
SemanticRule(r'cat2', r'\P.P'),
SemanticRule(r'cat3', r'\P.P'),
SemanticRule(r'NP', r'\P Q.(Q & P)', {'rule' : 'lex'}),
SemanticRule(r'NP', r'\P Q.(Q | P)', {'child_any_pos' : 'pos1'}),
SemanticRule(r'NP', r'\P Q.(Q -> P)', {'child_any_category' : 'cat3'})]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token base="base1" pos="pos1" surf="surf1" id="t1_1"/>
<token base="base2" pos="pos2" surf="surf2" id="t1_2"/>
<token base="base3" pos="pos3" surf="surf3" id="t1_3"/>
</tokens>
<ccg root="sp1-5">
<span terminal="t1_1" category="cat1" pos="pos1" end="2" begin="1" id="sp1-1"/>
<span terminal="t1_2" category="cat2" pos="pos2" end="3" begin="2" id="sp1-2"/>
<span terminal="t1_3" category="cat3" pos="pos3" end="4" begin="3" id="sp1-3"/>
<span child="sp1-1 sp1-2" rule="lex" category="NP" end="3" begin="1" id="sp1-4"/>
<span child="sp1-4 sp1-3" rule="lex" category="NP" end="4" begin="1" id="sp1-5"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
semantics = ccg_tree.get('sem', None)
expected_semantics = lexpr(r'_base3 -> (_base2 | _base1)')
self.assertEqual(expected_semantics, lexpr(semantics))
def test_inner_node_child_categoryWithFeats(self):
semantic_index = SemanticIndex(None)
semantic_rules = [SemanticRule(r'cat1', r'\P.P'),
SemanticRule(r'NP/NP', r'\P.P'),
SemanticRule(r'NP', r'\P Q.(Q -> P)',
{'child1_category' : 'NP/NP'})]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token base="base1" pos="pos1" surf="surf1" id="t1_1"/>
<token base="base2" pos="pos2" surf="surf2" id="t1_2"/>
</tokens>
<ccg root="sp1-3">
<span terminal="t1_1" category="cat1" end="2" begin="1" id="sp1-1"/>
<span terminal="t1_2" category="NP/NP[mod=xx]" end="3" begin="2" id="sp1-2"/>
<span child="sp1-1 sp1-2" rule="lex" category="NP" end="3" begin="1" id="sp1-3"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
semantics = ccg_tree.get('sem', None)
expected_semantics = lexpr(r'_base2 -> _base1')
self.assertEqual(expected_semantics, lexpr(semantics))
def test_vertical_bar(self):
sentence_str = r"""
<sentence id="s1">
<tokens>
<token base="base1" pos="pos1" surf="surf1" id="t1_1"/>
<token base="base2" pos="pos2" surf="surf2" id="t1_2"/>
</tokens>
<ccg root="sp1-3">
<span terminal="t1_1" category="N" end="2" begin="1" id="sp1-1"/>
<span terminal="t1_2" category="N" end="3" begin="2" id="sp1-2"/>
<span child="sp1-1 sp1-2" category="NP\NP" rule=">" end="3" begin="1" id="sp1-3"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
semantic_index = SemanticIndex(None)
semantic_rules = [
SemanticRule(r'N', r'\P.P', {}),
SemanticRule(r'NP|NP', r'\F1 F2.(F1 -> F2)', {'rule': '>'}),
SemanticRule(r'NP/NP', r'\F1 F2.(F1 & F2)', {'rule': '>'})
]
semantic_index.rules = semantic_rules
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
semantics = lexpr(ccg_tree.get('sem', None))
expected_semantics = lexpr(r'(_base1 -> _base2)')
self.assertEqual(expected_semantics, semantics)
def test_inner_node_child_categoryWithFeats(self):
semantic_index = SemanticIndex(None)
semantic_rules = [
SemanticRule(r'cat1', r'\P.P'),
SemanticRule(r'NP/NP', r'\P.P'),
SemanticRule(r'NP', r'\P Q.(Q -> P)', {'child1_category': 'NP/NP'})
]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token base="base1" pos="pos1" surf="surf1" id="t1_1"/>
<token base="base2" pos="pos2" surf="surf2" id="t1_2"/>
</tokens>
<ccg root="sp1-3">
<span terminal="t1_1" category="cat1" end="2" begin="1" id="sp1-1"/>
<span terminal="t1_2" category="NP/NP[mod=xx]" end="3" begin="2" id="sp1-2"/>
<span child="sp1-1 sp1-2" rule="lex" category="NP" end="3" begin="1" id="sp1-3"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
semantics = ccg_tree.get('sem', None)
expected_semantics = lexpr(r'_base2 -> _base1')
self.assertEqual(expected_semantics, lexpr(semantics))
def test_lexical_binary_two_coq_complex_type(self):
semantic_index = SemanticIndex(None)
semantic_rules = [SemanticRule(r'cat1', r'\P x R.P(x, R)', {'coq_type' : 'Entity -> Prop -> Prop'}),
SemanticRule(r'cat2', r'\Q S T.Q(S, T)', {'coq_type' : 'Prop -> Entity -> Prop'}),
SemanticRule(r'NP', r'\P Q x R S T.(Q(x, R) -> P(S, T))', {'rule' : 'lex'})]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token base="base1" pos="pos1" surf="surf1" id="t1_1"/>
<token base="base2" pos="pos2" surf="surf2" id="t1_2"/>
</tokens>
<ccg root="sp1-3">
<span terminal="t1_1" category="cat1" end="2" begin="1" id="sp1-1"/>
<span terminal="t1_2" category="cat2" end="3" begin="2" id="sp1-2"/>
<span child="sp1-1 sp1-2" rule="lex" category="NP" end="3" begin="1" id="sp1-3"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
coq_lib = get_coq_types(ccg_tree)
expected_coq_lib = ['Parameter _base1 : Entity -> Prop -> Prop.',
'Parameter _base2 : Prop -> Entity -> Prop.']
self.assertEqual(expected_coq_lib, coq_lib)
expression = [ccg_tree.get('sem')]
coq_sig = convert_coq_signatures_to_nltk(coq_lib)
nltk_lib = build_dynamic_library(expression, coq_sig)
lib = merge_dynamic_libraries(coq_lib, nltk_lib, './coqlib.v', sentence)
expected_lib = ["Parameter _base2 : Prop -> Entity -> Prop.",
"Parameter _base1 : Entity -> Prop -> Prop."]
self.assertCountEqual(expected_lib, lib)
def test_RTG3Paths2Vars(self):
semantic_index = SemanticIndex(None)
semantic_rules = [SemanticRule(r'N', r'\P.P', {}),
SemanticRule(r'NP', r'\F1 F2.(F1 & F2)', {'rule' : '>'}),
SemanticRule(r'NPNP', r'\F1 F2.(F1 -> F2)',
{'var_paths' : [[0,0], [0,1], [1,0]], 'rule' : '>'})]
semantic_index.rules = semantic_rules
ccg_tree = assign_semantics_to_ccg(self.sentence, semantic_index)
with self.assertRaises(nltk.sem.logic.LogicalExpressionException):
semantics = lexpr(ccg_tree.get('sem', None))
def test_CFG(self):
semantic_index = SemanticIndex(None)
semantic_rules = [SemanticRule(r'N', r'\P.P', {}),
SemanticRule(r'NP', r'\F1 F2.(F1 & F2)', {'rule' : '>'}),
SemanticRule(r'NPNP', r'\F1 F2.(F1 -> F2)', {'rule' : '>'})]
semantic_index.rules = semantic_rules
ccg_tree = assign_semantics_to_ccg(self.sentence, semantic_index)
semantics = lexpr(ccg_tree.get('sem', None))
expected_semantics = lexpr(r'(_base1 & _base2) -> (_base3 & _base4)')
self.assertEqual(expected_semantics, semantics)
def test_RTG1Path(self):
semantic_index = SemanticIndex(None)
semantic_rules = [SemanticRule(r'N', r'\P.P', {}),
SemanticRule(r'NP', r'\F1 F2.(F1 & F2)', {'rule' : '>'}),
SemanticRule(r'NPNP', r'\F1 F2.(F1 -> F2)',
{'var_paths' : [[0,1]], 'rule' : '>'})]
semantic_index.rules = semantic_rules
ccg_tree = assign_semantics_to_ccg(self.sentence, semantic_index)
semantics = lexpr(ccg_tree.get('sem', None))
expected_semantics = lexpr(r'\F2.(_base2 -> F2)')
self.assertEqual(expected_semantics, semantics)
def test_RTG3Paths3Vars(self):
semantic_index = SemanticIndex(None)
semantic_rules = [SemanticRule(r'N', r'\P.P', {}),
SemanticRule(r'NP', r'\F1 F2.(F1 & F2)', {'rule' : '>'}),
SemanticRule(r'NPNP', r'\F1 F2 F3.((F3 & F2) -> F1)',
{'var_paths' : [[0,0], [0,1], [1,0]], 'rule' : '>'})]
semantic_index.rules = semantic_rules
ccg_tree = assign_semantics_to_ccg(self.sentence, semantic_index)
semantics = lexpr(ccg_tree.get('sem', None))
expected_semantics = lexpr(r'((_base3 & _base2) -> _base1)')
self.assertEqual(expected_semantics, semantics)
def test_CFG(self):
semantic_index = SemanticIndex(None)
semantic_rules = [
SemanticRule(r'N', r'\P.P', {}),
SemanticRule(r'NP', r'\F1 F2.(F1 & F2)', {'rule': '>'}),
SemanticRule(r'NPNP', r'\F1 F2.(F1 -> F2)', {'rule': '>'})
]
semantic_index.rules = semantic_rules
ccg_tree = assign_semantics_to_ccg(self.sentence, semantic_index)
semantics = lexpr(ccg_tree.get('sem', None))
expected_semantics = lexpr(r'(_base1 & _base2) -> (_base3 & _base4)')
self.assertEqual(expected_semantics, semantics)
def test_RTG3Paths2Vars(self):
semantic_index = SemanticIndex(None)
semantic_rules = [
SemanticRule(r'N', r'\P.P', {}),
SemanticRule(r'NP', r'\F1 F2.(F1 & F2)', {'rule': '>'}),
SemanticRule(r'NPNP', r'\F1 F2.(F1 -> F2)', {
'var_paths': [[0, 0], [0, 1], [1, 0]],
'rule': '>'
})
]
semantic_index.rules = semantic_rules
ccg_tree = assign_semantics_to_ccg(self.sentence, semantic_index)
with self.assertRaises(nltk.sem.logic.LogicalExpressionException):
semantics = lexpr(ccg_tree.get('sem', None))
def test_RTG1Path(self):
semantic_index = SemanticIndex(None)
semantic_rules = [
SemanticRule(r'N', r'\P.P', {}),
SemanticRule(r'NP', r'\F1 F2.(F1 & F2)', {'rule': '>'}),
SemanticRule(r'NPNP', r'\F1 F2.(F1 -> F2)', {
'var_paths': [[0, 1]],
'rule': '>'
})
]
semantic_index.rules = semantic_rules
ccg_tree = assign_semantics_to_ccg(self.sentence, semantic_index)
semantics = lexpr(ccg_tree.get('sem', None))
expected_semantics = lexpr(r'\F2.(_base2 -> F2)')
self.assertEqual(expected_semantics, semantics)
def test_RTG3Paths3Vars(self):
semantic_index = SemanticIndex(None)
semantic_rules = [
SemanticRule(r'N', r'\P.P', {}),
SemanticRule(r'NP', r'\F1 F2.(F1 & F2)', {'rule': '>'}),
SemanticRule(r'NPNP', r'\F1 F2 F3.((F3 & F2) -> F1)', {
'var_paths': [[0, 0], [0, 1], [1, 0]],
'rule': '>'
})
]
semantic_index.rules = semantic_rules
ccg_tree = assign_semantics_to_ccg(self.sentence, semantic_index)
semantics = lexpr(ccg_tree.get('sem', None))
expected_semantics = lexpr(r'((_base3 & _base2) -> _base1)')
self.assertEqual(expected_semantics, semantics)
def test_np_feature_no(self):
semantic_index = SemanticIndex(None)
semantic_index.rules = [SemanticRule(r'NP', r'\P.P')]
sentence_str = r"""
<sentence id="s0">
<tokens>
<token base="basepred" pos="pos1" surf="surfpred" id="t0_0"/>
</tokens>
<ccg root="sp0-3">
<span terminal="t0_0" category="NP" end="1" begin="0" id="sp0-3"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
semantics = ccg_tree.get('sem', None)
expected_semantics = lexpr(r'_basepred')
self.assertEqual(expected_semantics, lexpr(semantics))
def test_np_feature_no(self):
semantic_index = SemanticIndex(None)
semantic_index.rules = [SemanticRule(r'NP', r'\P.P')]
sentence_str = r"""
<sentence id="s0">
<tokens>
<token base="basepred" pos="pos1" surf="surfpred" id="t0_0"/>
</tokens>
<ccg root="sp0-3">
<span terminal="t0_0" category="NP" end="1" begin="0" id="sp0-3"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
semantics = ccg_tree.get('sem', None)
expected_semantics = lexpr(r'_basepred')
self.assertEqual(expected_semantics, lexpr(semantics))
def test_lexical_binary_two_coq_complex_type(self):
semantic_index = SemanticIndex(None)
semantic_rules = [
SemanticRule(r'cat1', r'\P x R.P(x, R)',
{'coq_type': 'Entity -> Prop -> Prop'}),
SemanticRule(r'cat2', r'\Q S T.Q(S, T)',
{'coq_type': 'Prop -> Entity -> Prop'}),
SemanticRule(r'NP', r'\P Q x R S T.(Q(x, R) -> P(S, T))',
{'rule': 'lex'})
]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token base="base1" pos="pos1" surf="surf1" id="t1_1"/>
<token base="base2" pos="pos2" surf="surf2" id="t1_2"/>
</tokens>
<ccg root="sp1-3">
<span terminal="t1_1" category="cat1" end="2" begin="1" id="sp1-1"/>
<span terminal="t1_2" category="cat2" end="3" begin="2" id="sp1-2"/>
<span child="sp1-1 sp1-2" rule="lex" category="NP" end="3" begin="1" id="sp1-3"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
coq_lib = get_coq_types(ccg_tree)
expected_coq_lib = [
'Parameter _base1 : Entity -> Prop -> Prop.',
'Parameter _base2 : Prop -> Entity -> Prop.'
]
self.assertEqual(expected_coq_lib, coq_lib)
expression = [ccg_tree.get('sem')]
coq_sig = convert_coq_signatures_to_nltk(coq_lib)
nltk_lib, _ = build_dynamic_library(expression, coq_sig)
lib = merge_dynamic_libraries(coq_sig, nltk_lib, './coqlib.v',
sentence)
expected_lib = [
"Parameter _base2 : Prop -> (Entity -> Prop).",
"Parameter _base1 : Entity -> (Prop -> Prop)."
]
self.assertCountEqual(expected_lib, lib)
def test_lexical_unary(self):
semantic_index = SemanticIndex(None)
semantic_rules = [SemanticRule(r'N', r'\P.P'),
SemanticRule(r'NP', r'\P.(P -> P)', {'rule' : 'lex'})]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token base="base1" pos="pos1" surf="surf1" id="t1_1"/>
</tokens>
<ccg root="sp1-2">
<span terminal="t1_1" category="N" end="2" begin="1" id="sp1-1"/>
<span child="sp1-1" rule="lex" category="NP" end="2" begin="1" id="sp1-2"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
semantics = ccg_tree.get('sem', None)
expected_semantics = lexpr(r'_base1 -> _base1')
self.assertEqual(expected_semantics, lexpr(semantics))
def test_lexical_unary(self):
semantic_index = SemanticIndex(None)
semantic_rules = [
SemanticRule(r'N', r'\P.P'),
SemanticRule(r'NP', r'\P.(P -> P)', {'rule': 'lex'})
]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token base="base1" pos="pos1" surf="surf1" id="t1_1"/>
</tokens>
<ccg root="sp1-2">
<span terminal="t1_1" category="N" end="2" begin="1" id="sp1-1"/>
<span child="sp1-1" rule="lex" category="NP" end="2" begin="1" id="sp1-2"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
semantics = ccg_tree.get('sem', None)
expected_semantics = lexpr(r'_base1 -> _base1')
self.assertEqual(expected_semantics, lexpr(semantics))
def test_func_combination_backwardComplexTwoArgs(self):
semantic_index = SemanticIndex(None)
semantic_rules = [SemanticRule(r'S\NP\NP', r'\P y x e. P(e, x, y)'),
SemanticRule(r'S\S', r'\P Q e. AND(past(e), Q(e))')]
semantic_index.rules = semantic_rules
sentence_str = r"""
<sentence id="s1">
<tokens>
<token id="s1_4" surf="ほめ" pos="動詞" pos1="自立" pos2="*" pos3="*" inflectionType="一段" inflectionForm="連用形" base="ほめる" reading="ホメ"/>
<token id="s1_5" surf="た" pos="助動詞" pos1="*" pos2="*" pos3="*" inflectionType="特殊・タ" inflectionForm="基本形" base="た" reading="タ"/>
</tokens>
<ccg root="s1_sp9">
<span id="s1_sp9" begin="4" end="6" category="(S[mod=nm,form=base]\NP[mod=nm,case=ga])\NP[mod=nm,case=o]" rule="<B2" child="s1_sp10 s1_sp11"/>
<span id="s1_sp10" begin="4" end="5" category="(S[mod=nm,form=cont]\NP[mod=nm,case=ga])\NP[mod=nm,case=o]" terminal="s1_4"/>
<span id="s1_sp11" begin="5" end="6" category="S[mod=nm,form=base]\S[mod=nm,form=cont]" terminal="s1_5"/>
</ccg>
</sentence>
"""
sentence = etree.fromstring(sentence_str)
ccg_tree = assign_semantics_to_ccg(sentence, semantic_index)
semantics = ccg_tree.get('sem', None)
expected_semantics = lexpr(r'\y x e.AND(past(e), _ほめる(x, y, e))')
self.assertEqual(expected_semantics, lexpr(semantics))
