def test_load_factor_marked_reciprocal(self):
fact = Fact(
predicate=Comparison(
content="the distance between $place1 and $place2 was",
sign="<",
expression="5 miles",
),
terms=TermSequence(
[Entity(name="the apartment"),
Entity(name="the office")]),
)
assert hasattr(fact.predicate.quantity, "dimensionality")
data = {
"type":
"fact",
"content":
"the distance between ${place1} and ${place2} was",
"sign":
"<",
"expression":
"5 miles",
"terms": [
{
"type": "entity",
"name": "the office"
},
{
"type": "entity",
"name": "the apartment"
},
],
}
loaded_fact = Fact(**data)
assert loaded_fact.means(fact)
def test_equal_referencing_diffent_generic_terms(self):
predicate = Predicate(content="$speaker greeted $listener")
fact = Fact(predicate=predicate,
terms=[Entity(name="Al"),
Entity(name="Meg")])
fact_b = Fact(predicate=predicate,
terms=[Entity(name="Jim"),
Entity(name="Ned")])
assert fact.means(fact_b)
def test_equality_because_factors_are_generic_entities(self):
predicate = Predicate(content="$speaker greeted $listener")
fact = Fact(predicate=predicate,
terms=[Entity(name="Al"),
Entity(name="Meg")])
fact_b = Fact(predicate=predicate,
terms=[Entity(name="Ed"),
Entity(name="Imogene")])
assert fact.means(fact_b)
def test_equality_factor_from_same_predicate(self):
predicate = Predicate(content="$speaker greeted $listener")
fact = Fact(predicate=predicate,
terms=[Entity(name="Al"),
Entity(name="Meg")])
fact_b = Fact(predicate=predicate,
terms=[Entity(name="Al"),
Entity(name="Meg")])
assert fact.means(fact_b)
def test_means_despite_plural(self):
directory = Entity(name="the telephone directory", plural=False)
listings = Entity(name="the telephone listings", plural=True)
directory_original = Fact(
predicate=Predicate(content="$thing was original"),
terms=directory)
listings_original = Fact(
predicate=Predicate(content="$thing were original"),
terms=listings)
assert directory_original.means(listings_original)
def test_unequal_to_statement(self, watt_factor, e_copyright):
stole_predicate = Predicate(content="$defendant stole $object")
stole_fact = Fact(
predicate=stole_predicate,
terms=[Entity(name="Alice"),
Entity(name="the gold bar")],
)
assert not stole_fact.means(e_copyright)
with pytest.raises(TypeError):
e_copyright.means(watt_factor["f1"])
def test_changing_order_of_concrete_terms_changes_meaning(self):
ann = Entity(name="Ann", generic=False)
bob = Entity(name="Bob", generic=False)
parent_sentence = Predicate(content="$mother was ${child}'s parent")
ann_parent = Fact(predicate=parent_sentence, terms=(ann, bob))
bob_parent = Fact(predicate=parent_sentence, terms=(bob, ann))
assert str(ann_parent).lower(
) == "the fact that Ann was Bob's parent".lower()
assert str(bob_parent).lower(
) == "the fact that Bob was Ann's parent".lower()
assert not ann_parent.means(bob_parent)
def test_unequal_because_one_factor_is_absent(self):
predicate = Predicate(content="$shooter shot $victim")
fact = Fact(predicate=predicate,
terms=[Entity(name="Al"),
Entity(name="Meg")])
fact_b = Fact(
predicate=predicate,
terms=[Entity(name="Al"), Entity(name="Meg")],
absent=True,
)
assert not fact.means(fact_b)
def test_factor_different_predicate_truth_unequal(self):
predicate = Predicate(content="$shooter shot $victim")
false_predicate = Predicate(content="$shooter shot $victim",
truth=False)
fact = Fact(predicate=predicate,
terms=[Entity(name="Al"),
Entity(name="Meg")])
fact_b = Fact(predicate=false_predicate,
terms=[Entity(name="Al"),
Entity(name="Meg")])
assert not fact.means(fact_b)
def test_unequal_because_a_factor_is_not_generic(self):
predicate = Predicate(content="$speaker greeted $listener")
fact = Fact(predicate=predicate,
terms=[Entity(name="Al"),
Entity(name="Meg")])
fact_b = Fact(
predicate=predicate,
terms=[Entity(name="Ed"),
Entity(name="Imogene", generic=False)],
)
assert not fact.means(fact_b)
def test_generic_terms_with_different_text_equal(self):
predicate = Predicate(content="$speaker greeted $listener")
different_predicate = Predicate(content="$speaker attacked $listener")
fact = Fact(
predicate=predicate,
terms=[Entity(name="Al"), Entity(name="Meg")],
generic=True,
)
different_fact = Fact(
predicate=different_predicate,
terms=[Entity(name="Al"), Entity(name="Meg")],
generic=True,
)
assert fact.means(different_fact)
def test_true_and_false_generic_terms_equal(self):
predicate = Predicate(content="$speaker greeted $listener")
false_predicate = Predicate(content="$speaker greeted $listener",
truth=False)
fact = Fact(
predicate=predicate,
terms=[Entity(name="Al"), Entity(name="Meg")],
generic=True,
)
false_fact = Fact(
predicate=false_predicate,
terms=[Entity(name="Ed"),
Entity(name="Imogene")],
generic=True,
)
assert fact.means(false_fact)
def test_interchangeable_concrete_terms(self):
"""Detect that placeholders differing only by a final digit are interchangeable."""
ann = Entity(name="Ann", generic=False)
bob = Entity(name="Bob", generic=False)
ann_and_bob_were_family = Fact(
predicate=Predicate(
content=
"$relative1 and $relative2 both were members of the same family"
),
terms=(ann, bob),
)
bob_and_ann_were_family = Fact(
predicate=Predicate(
content=
"$relative1 and $relative2 both were members of the same family"
),
terms=(bob, ann),
)
assert ann_and_bob_were_family.means(bob_and_ann_were_family)
def test_equal_with_different_generic_subfactors(self):
shot_predicate = Predicate(content="$shooter shot $victim")
shot_fact = Fact(predicate=shot_predicate,
terms=[Entity(name="Alice"),
Entity(name="Bob")])
murder_predicate = Predicate(content="$shooter murdered $victim")
murder_fact = Fact(predicate=murder_predicate,
terms=[Entity(name="Alice"),
Entity(name="Bob")])
relevant_predicate = Predicate(
content="$clue was relevant to $conclusion")
relevant_fact = Fact(predicate=relevant_predicate,
terms=[shot_fact, murder_fact])
changes = ContextRegister.from_lists(
[Entity(name="Alice"), Entity(name="Bob")],
[Entity(name="Deb"), Entity(name="Eve")],
)
new_fact = relevant_fact.new_context(changes)
assert relevant_fact.means(new_fact)
def test_factor_reciprocal_unequal(self):
predicate = Predicate(
content="$advisor told $employer to hire $applicant")
three_entities = Fact(
predicate=predicate,
terms={
"advisor": Entity(name="Alice"),
"employer": Entity(name="Bob"),
"applicant": Entity(name="Craig"),
},
)
repeating_predicate = Predicate(
content="$applicant told $employer to hire $applicant")
two_entities = Fact(
predicate=repeating_predicate,
terms={
"applicant": Entity(name="Alice"),
"employer": Entity(name="Bob"),
},
)
assert not three_entities.means(two_entities)
