def test_contradiction_of_group(self):
lived_at = Predicate(content="$person lived at $residence")
bob_lived = Fact(
predicate=lived_at, terms=[Entity(name="Bob"), Entity(name="Bob's house")]
)
carl_lived = Fact(
predicate=lived_at, terms=[Entity(name="Carl"), Entity(name="Carl's house")]
)
distance_long = Comparison(
content="the distance from the center of $city to $residence was",
sign=">=",
expression="50 miles",
)
statement_long = Fact(
predicate=distance_long,
terms=[Entity(name="Houston"), Entity(name="Bob's house")],
)
distance_short = Comparison(
content="the distance from the center of $city to $residence was",
sign="<=",
expression="10 kilometers",
)
statement_short = Fact(
predicate=distance_short,
terms=[Entity(name="El Paso"), Entity(name="Carl's house")],
)
left = FactorGroup([bob_lived, statement_long])
right = FactorGroup([carl_lived, statement_short])
explanation = left.explain_contradiction(right)
assert explanation.context["<Houston>"].name == "El Paso"
assert contradicts(left, right)
class TestConsistent:
p_small_weight = Comparison(
content="the amount of gold $person possessed was",
sign="<",
expression=Q_("1 gram"),
)
p_large_weight = Comparison(
content="the amount of gold $person possessed was",
sign=">=",
expression=Q_("100 kilograms"),
)
small = Fact(predicate=p_large_weight, terms=Entity(name="Alice"))
big = Fact(predicate=p_small_weight, terms=Entity(name="Bob"))
def test_contradictory_facts_about_same_entity(self):
register = ContextRegister()
register.insert_pair(Entity(name="Alice"), Entity(name="Bob"))
assert not self.small.consistent_with(self.big, register)
explanations = list(
self.small.explanations_consistent_with(self.big,
context=register))
assert not explanations
def test_factor_consistent_with_none(self):
assert self.small.consistent_with(None)
def test_interchangeable_terms_in_factorgroup(self):
"""Fails whether the method is 'comparison' or '_verbose_comparison'"""
left = FactorGroup([
Statement(
predicate=Comparison(
content="the distance between $place1 and $place2 was",
truth=True,
sign="<=",
expression="35 foot",
),
terms=(
Entity(name="Scylla", generic=True, plural=False),
Entity(name="Charybdis", generic=True, plural=False),
),
),
Statement(
predicate=Comparison(
content=
"the distance between ${monster} and a boat used by ${hero} was",
truth=True,
sign="<=",
expression="5 foot",
),
terms=(
Entity(name="Scylla", generic=True, plural=False),
Entity(name="Ulysses", generic=True, plural=False),
),
),
])
right = FactorGroup([
Statement(
predicate=Comparison(
content="the distance between $place1 and $place2 was",
truth=True,
sign="<=",
expression="35 foot",
),
terms=(
Entity(name="Charybdis", generic=True, plural=False),
Entity(name="Scylla", generic=True, plural=False),
),
),
Statement(
predicate=Comparison(
content=
"the distance between $thing and a boat used by $person was",
truth=True,
sign="<=",
expression="5 foot",
),
terms=(
Entity(name="Scylla", generic=True, plural=False),
Entity(name="Ulysses", generic=True, plural=False),
),
),
])
gen = left.explanations_implication(right)
result = next(gen)
assert result
def test_round_trip(self):
predicate = Comparison(
**{"content": "{}'s favorite number was", "sign": "==", "expression": 42}
)
dumped = predicate.dict()
new_statement = Comparison(**dumped)
assert "{}'s favorite number was exactly equal to 42" in str(new_statement)
def test_compare_intervals_different_units(self):
miles = Comparison(
content="the distance was", sign="<", expression=Q_("30 miles")
)
kilos = Comparison(
content="the distance was", sign="<", expression=Q_("40 kilometers")
)
assert kilos.quantity_range.implies(miles.quantity_range)
def test_dump_comparison_with_date_expression(self):
copyright_date_range = Comparison(
content="the date when $work was created was",
sign=">=",
expression=date(1978, 1, 1),
)
dumped = copyright_date_range.dict()
assert dumped["quantity_range"]["quantity"] == date(1978, 1, 1)
def test_no_duplicate_explanations_consistent(self):
large_payments = FactorGroup([
Statement(
predicate=Comparison(
content=
"the number of dollars that $payer paid to $payee was",
sign=">",
expression=10000,
),
terms=[Entity(name="Alice"),
Entity(name="Bob")],
),
Statement(
predicate=Comparison(
content=
"the number of dollars that $payer paid to $payee was",
sign=">",
expression=1000,
),
terms=[Entity(name="Dan"),
Entity(name="Eve")],
),
])
small_payments = FactorGroup([
Statement(
predicate=Comparison(
content=
"the number of dollars that $payer paid to $payee was",
sign=">",
expression=100,
),
terms={
"payer": Entity(name="Fred"),
"payee": Entity(name="Greg")
},
),
Statement(
predicate=Comparison(
content=
"the number of dollars that $payer paid to $payee was",
sign=">",
expression=10,
),
terms={
"payer": Entity(name="Jim"),
"payee": Entity(name="Kim")
},
),
])
assert large_payments.consistent_with(small_payments)
all_explanations = list(
large_payments.explanations_consistent_with(small_payments))
assert len(all_explanations) == 24
limited_explanations = list(
large_payments.explanations_consistent_with(
small_payments,
context=([Entity(name="Alice")], [Entity(name="Jim")])))
assert len(limited_explanations) == 6
def test_no_contradiction_of_predicate(self):
more_cows = Comparison(
content="the number of cows $person owned was",
sign=">",
expression=10,
)
no_cows = Predicate(content="the number of cows $person owned was", truth=False)
assert not more_cows.contradicts(no_cows)
assert not no_cows.contradicts(more_cows)
def test_reuse_quantity_range_for_contradiction(self):
dogs = Comparison(content="the number of dogs was", sign=">", expression=3)
cats = Comparison(
content="the number of cats was", quantity_range=dogs.quantity_range
)
fewer_cats = Comparison(
content="the number of cats was", sign="<", expression=3
)
assert cats.contradicts(fewer_cats)
def test_dump_to_dict_with_units(self):
predicate = Comparison(
content="the distance between $place1 and $place2 was",
truth=True,
sign="<>",
expression=Q_("35 feet"),
)
dumped = predicate.dict()
assert dumped["quantity_range"]["quantity"] == "35 foot"
def test_interchangeable_terms_in_different_orders(self):
more_than_100_yards = Comparison(
content="the distance between $site1 and $site2 was",
sign=">",
expression="100 yards",
)
less_than_1_mile = Comparison(
content="the distance between $site1 and $site2 was",
sign="<",
expression="1 mile",
)
protest_facts = FactorGroup([
Statement(
predicate=more_than_100_yards,
terms=[
Entity(name="the political convention"),
Entity(name="the police cordon"),
],
),
Statement(
predicate=less_than_1_mile,
terms=[
Entity(name="the police cordon"),
Entity(name="the political convention"),
],
),
])
assert "between <the political convention> and " in str(protest_facts)
more_than_50_meters = Comparison(
content="the distance between $site1 and $site2 was",
sign=">",
expression="50 meters",
)
less_than_2_km = Comparison(
content="the distance between $site1 and $site2 was",
sign="<=",
expression="2 km",
)
speech_zone_facts = FactorGroup([
Statement(
predicate=more_than_50_meters,
terms=[
Entity(name="the free speech zone"),
Entity(name="the courthouse"),
],
),
Statement(
predicate=less_than_2_km,
terms=[
Entity(name="the free speech zone"),
Entity(name="the courthouse"),
],
),
])
assert protest_facts.implies(speech_zone_facts)
def test_no_contradiction_inconsistent_dimensions(self):
equal = Comparison(
content="${defendant}'s sentence was", sign="=", expression="8 years"
)
less = Comparison(
content="${defendant}'s sentence was", sign="<=", expression="10 parsecs"
)
assert not equal.contradicts(less)
assert not equal.implies(less)
def test_no_contradiction_exact_different_unit(self):
acres = Comparison(
content="the size of the farm was", sign=">", expression=Q_("20 acres")
)
kilometers = Comparison(
content="the size of the farm was",
sign="=",
expression=Q_("100 square kilometers"),
)
assert not acres.contradicts(kilometers)
def test_comparison_implies_predicate_false(self):
distance = Comparison(
content="the distance between $place1 and $place2 was",
sign=">",
expression="20 miles",
)
predicate = Predicate(content="the distance between $place1 and $place2 was")
assert not distance.implies(predicate)
assert not distance.contradicts(predicate)
assert not predicate.contradicts(distance)
def test_predicate_not_same_with_interchangeable_terms(self):
interchangeable = Comparison(
content="the distance between $place1 and $place2 was",
sign="<",
expression=Q_("20 feet"),
)
not_interchangeable = Comparison(
content="the distance between $west and $east was",
sign="<",
expression=Q_("20 feet"),
)
assert not interchangeable.means(not_interchangeable)
def test_same_volume(self):
volume_in_liters = Comparison(
content="the volume of fuel in the tank was",
sign="=",
expression="10 liters",
)
volume_in_milliliters = Comparison(
content="the volume of fuel in the tank was",
sign="=",
expression="10000 milliliters",
)
assert volume_in_liters.means(volume_in_milliliters)
def test_term_outside_of_group(self):
speed = "${person}'s speed was"
comparison = Comparison(content=speed,
sign=">",
expression="36 kilometers per hour")
other = Comparison(content=speed,
sign=">",
expression="10 meters per second")
left = FactorGroup(
Statement(predicate=comparison, terms=Entity(name="Ann")))
right = Statement(predicate=other, terms=Entity(name="Bob"))
assert left.means(right)
def test_not_equal_implies(self):
meters = Comparison(
content="the length of the football field was",
sign="!=",
expression="1000 meter",
)
kilometers = Comparison(
content="the length of the football field was",
sign="!=",
expression="1 kilometer",
)
assert meters.means(kilometers)
def test_not_equal_does_not_imply(self):
yards = Comparison(
content="the length of the football field was",
sign="!=",
expression="100 yards",
)
meters = Comparison(
content="the length of the football field was",
sign="!=",
expression="80 meters",
)
assert not yards >= meters
def test_implication_due_to_dates(self):
copyright_date_range = Comparison(
content="the date when $work was created was",
sign=">=",
expression="1978-01-01",
)
copyright_date_specific = Comparison(
content="the date when $work was created was",
sign="=",
expression=date(1980, 6, 20),
)
assert copyright_date_specific.implies(copyright_date_range)
def test_no_comparison_with_comparison(self):
comparison = Comparison(
content="${person}'s speed was",
sign=">",
expression="36 kilometers per hour",
)
other_comparison = Comparison(content="${person}'s speed was",
sign=">",
expression="10 meters per second")
left = FactorGroup(
Statement(predicate=comparison, terms=Entity(name="Ann")))
assert not left.means(other_comparison)
def test_cannot_convert_date_to_time_period(self):
time = Comparison(
content="the time $object took to biodegrade was",
sign=">",
expression=Q_("2000 years"),
)
day = Comparison(
content="the day was",
sign="=",
expression=date(2020, 1, 1),
)
with pytest.raises(TypeError):
time.quantity_range.get_unit_converted_interval(day.quantity_range)
def test_inconsistent_dimensionality_date(self):
number = Comparison(
content="the distance between $place1 and $place2 was",
sign=">",
expression=20,
)
day = Comparison(
content="the distance between $place1 and $place2 was",
sign=">",
expression=date(2000, 1, 1),
)
assert not number.quantity_range.consistent_dimensionality(day.quantity_range)
assert not day.quantity_range.consistent_dimensionality(number.quantity_range)
def test_does_not_exclude_other_quantity(self):
comparison = Comparison(
content="the distance between $place1 and $place2 was",
sign=">",
expression=Q_("20 miles"),
)
comparison_opposite = Comparison(
content="the distance between $place1 and $place2 was",
sign="<",
expression=Q_("30 miles"),
)
left = comparison.quantity_range
right = comparison_opposite.quantity_range
assert left.contradicts(right.interval) is False
def test_convert_quantity_of_Comparison(self):
comparison = Comparison(
content="the distance between $place1 and $place2 was",
sign=">",
expression=Q_("20 miles"),
)
comparison_km = Comparison(
content="the distance between $place1 and $place2 was",
sign=">",
expression=Q_("30 kilometers"),
)
result = comparison.quantity_range.get_unit_converted_interval(
comparison_km.quantity_range
)
assert 18 < result.left < 19
def test_no_implication_pint_quantity_and_int(self):
fact_exact = Fact(
predicate=Comparison(content="${person}'s height was",
sign="=",
expression=66),
terms=Entity(name="Alice"),
)
fact_greater = Fact(
predicate=Comparison(content="${person}'s height was",
sign=">",
expression="60 inches"),
terms=Entity(name="Alice"),
)
assert not fact_exact >= fact_greater
assert not fact_greater >= fact_exact
def test_plural_in_comparison(self):
comparison = Comparison(
content="the weights of ${the defendants} were",
sign=">",
expression="200 pounds",
)
assert comparison.content.endswith("was")
def test_comparison_with_wrong_comparison_symbol(self):
with pytest.raises(ValueError):
_ = Comparison(
content="the height of {} was {}",
sign=">>",
expression=Q_("160 centimeters"),
)
def test_string_for_date_as_expression(self):
copyright_date_range = Comparison(
content="the date when $work was created was",
sign=">=",
expression=date(1978, 1, 1),
)
assert "1978" in str(copyright_date_range)
def test_comparison_negative_attr(self):
comparison = Comparison(
content="the balance in the bank account was", sign="<=", expression=-100
)
assert comparison.quantity_range.magnitude == -100
assert comparison.quantity_range._include_negatives is True
assert comparison.interval.end == -100
