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_new_context_replace_fact(self): predicate_shot = Predicate(content="$shooter shot $victim") predicate_no_gun = Predicate(content="$suspect had a gun", truth=False) predicate_told = Predicate(content="$speaker told $hearer $statement") shot = Fact(predicate=predicate_shot, terms=[Entity(name="Alice"), Entity(name="Bob")]) told = Fact( predicate=predicate_told, terms=[Entity(name="Henry"), Entity(name="Jenna"), shot], ) no_gun = Fact(predicate=predicate_no_gun, terms=Entity(name="Dan")) changes = ContextRegister.from_lists( [ Entity(name="Alice"), Entity(name="Henry"), Entity(name="Jenna"), shot ], [ Entity(name="Dan"), Entity(name="Leslie"), Entity(name="Mike"), no_gun ], ) result = told.new_context(changes) assert ( "told <Mike> the fact it was false that <Dan> had a gun".lower() in result.short_string.lower())
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_holding_flagged_exclusive(self, make_regime, make_enactment): """ Test that "exclusive" flag doesn't mess up the holding where it's placed. Test whether the Feist opinion object includes a holding with the output "Rural's telephone directory was copyrightable" and the input "Rural's telephone directory was original", when that holding was marked "exclusive" in the JSON. """ to_read = load_holdings("holding_feist.json") feist_holdings = readers.read_holdings(to_read, regime=make_regime) directory = Entity("Rural's telephone directory") original = Fact(Predicate("{} was an original work"), directory) copyrightable = Fact(Predicate("{} was copyrightable"), directory) originality_enactments = [ make_enactment["securing_for_authors"], make_enactment["right_to_writings"], make_enactment["copyright_requires_originality"], ] originality_rule = Rule( Procedure(outputs=copyrightable, inputs=original), mandatory=False, universal=False, enactments=originality_enactments, ) assert any( feist_holding.rule.means(originality_rule) for feist_holding in feist_holdings )
def test_input_or_despite_factors(self): """Test part of the process of checking contradiction.""" rural = Entity(name="Rural's telephone directory") compilation = Predicate( content="${rural_s_telephone_directory} was a compilation of facts" ) idea = Predicate(content="${rural_s_telephone_directory} was an idea") copyrightable = Fact( predicate=Predicate( content="${rural_s_telephone_directory} was copyrightable" ), terms=rural, ) left = Procedure( outputs=(copyrightable), inputs=(Fact(predicate=compilation, terms=rural)), ) right = Procedure( outputs=(copyrightable), inputs=(Fact(predicate=idea, terms=rural)), ) context = ContextRegister() explanation = Explanation.from_context(context) gen = left._has_input_or_despite_factors_implied_by_all_inputs_of( right, explanation ) with pytest.raises(StopIteration): next(gen)
def test_implies_due_to_more_complex_entity_order(self, make_exhibit): """Test the entire _registers_for_interchangeable_context function.""" hit = Fact( predicate="$person1 hit $target1 and $target2", terms=[Entity(name="Moe"), Entity(name="Curly"), Entity(name="Larry")], ) hit2 = Fact( predicate="$person1 hit $target1 and $target2", terms=[ Entity(name="Joker"), Entity(name="Batman"), Entity(name="Superman"), ], ) exhibit = Exhibit( form="testimony", offered_by=Entity(name="Curly"), statement=hit, statement_attribution=Entity(name="Larry"), ) exhibit2 = Exhibit( form="testimony", offered_by=Entity(name="Joker"), statement=hit2, statement_attribution=Entity(name="Batman"), ) assert exhibit.implies(exhibit2)
def test_concrete_to_abstract(self): predicate = Predicate(content="$person had a farm") statement = Fact(predicate=predicate, terms=Entity(name="Old MacDonald")) assert str( statement).lower() == "the fact that <old macdonald> had a farm" generic_str = str(statement.make_generic()).lower() assert generic_str == "<the fact that <old macdonald> had a farm>"
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_no_implication_complex(self): murder_fact = Fact( predicate=self.murder_predicate, terms=[Entity(name="Alice"), Entity(name="Craig")], ) relevant_to_craig = Fact(predicate=self.relevant_predicate, terms=[self.shot_fact, murder_fact]) assert not self.relevant_fact >= relevant_to_craig
def test_add_unrelated_factors(self): murder = Fact( predicate=Predicate(content="$person committed a murder"), terms=Entity(name="Al"), ) crime = Fact( predicate=Predicate(content="$person committed a crime"), terms=Entity(name="Al"), ) assert murder + crime is None
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_statement_implies_no_truth_value(self): fact = Fact( predicate=Predicate(content="$person was a person"), terms=Entity(name="Alice"), ) whether = Fact( predicate=Predicate(content="$person was a person", truth=None), terms=Entity(name="Alice"), ) assert fact >= whether assert not whether > fact
def test_new_statement_from_entities(self): predicate = Predicate(content="$person managed $place") statement = Fact( predicate=predicate, terms=[Entity(name="Steve Jobs"), Entity(name="Apple")]) different = statement.new_context( [Entity(name="Darth Vader"), Entity(name="the Death Star")]) assert "<Darth Vader> managed" in str(different) assert isinstance(different.term_sequence, TermSequence)
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_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_same_predicate_true_vs_false(self): fact = Fact( predicate=Predicate(content="$person was a person"), terms=Entity(name="Alice"), ) fiction = Fact( predicate=Predicate(content="$person was a person", truth=False), terms=Entity(name="Alice"), ) assert fact.contradicts(fiction) assert fact.truth != fiction.truth
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_is_beard_implied( self, facial_hair_over_5mm, facial_hair_on_or_below_chin, facial_hair_uninterrupted, outcome, fake_beard_client, make_beard_rule, ): beard = Entity(name="a facial feature") sec_4 = fake_beard_client.read("/test/acts/47/4/") was_facial_hair = Predicate(content="$thing was facial hair") fact_was_facial_hair = Fact(predicate=was_facial_hair, terms=beard) hypothetical = Rule( procedure=Procedure( inputs=[ fact_was_facial_hair, Fact( predicate=Comparison( content="the length of $thing was", sign=">=", expression=Q_("5 millimeters"), truth=facial_hair_over_5mm, ), terms=beard, ), Fact( predicate=Predicate( content="$thing occurred on or below the chin", truth=facial_hair_on_or_below_chin, ), terms=beard, ), Fact( predicate=Predicate( content= "$thing existed in an uninterrupted line from the front " "of one ear to the front of the other ear below the nose", truth=facial_hair_uninterrupted, ), terms=beard, ), ], outputs=Fact(predicate=Predicate(content="$thing was a beard"), terms=beard), ), enactments=sec_4, ) meets_chin_test = make_beard_rule[0].implies(hypothetical) meets_ear_test = make_beard_rule[1].implies(hypothetical) assert outcome == meets_chin_test or meets_ear_test
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_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_specific_statement_implies_generic(self): concrete = Fact( predicate=Predicate(content="$person was a person"), terms=Entity(name="Alice"), ) generic = Fact( predicate=Predicate(content="$person was a person"), terms=Entity(name="Alice"), generic=True, ) assert concrete > generic assert not generic > concrete
def test_specific_implies_generic_form_of_another_fact(self): concrete = Fact( predicate=Predicate(content="$person was a person"), terms=Entity(name="Alice"), ) generic_merperson = Fact( predicate=Predicate(content="$person was a merperson"), terms=Entity(name="Alice"), generic=True, ) assert concrete > generic_merperson
def test_new_concrete_context(self): """ "Dragonfly Inn" is still a string representation of an Entity object, but it's not in angle brackets because it can't be replaced by another Entity object without changing the meaning of the Fact. """ predicate = Predicate(content="$place was a hotel") statement = Fact(predicate=predicate, terms=[Entity(name="Independence Inn")]) different = statement.new_context( [Entity(name="Dragonfly Inn", generic=False)]) assert "Dragonfly Inn was a hotel" in str(different)
def test_get_factor_from_recursive_search(self): predicate_shot = Predicate(content="$shooter shot $victim") predicate_told = Predicate(content="$speaker told $hearer $statement") shot = Fact(predicate=predicate_shot, terms=[Entity(name="Alice"), Entity(name="Bob")]) told = Fact( predicate=predicate_told, terms=[Entity(name="Henry"), Entity(name="Jenna"), shot], ) factors = told.recursive_terms assert factors["<Alice>"].compare_keys(Entity(name="Alice"))
def test_specific_implies_generic_explain(self): concrete = Fact( predicate=Predicate(content="$person was a person"), terms=Entity(name="Alice"), ) generic = Fact( predicate=Predicate(content="$person was a person"), terms=Entity(name="Alice"), generic=True, ) answer = concrete.explain_implication(generic) assert (str(concrete), generic) in answer.context.items()
def test_too_much_info_to_change_context(self): """Test that a list of terms to replace requires "changes" to be consistent.""" statement = Fact( predicate="$person1 loved $person2", terms=[Entity(name="Donald"), Entity(name="Daisy")], ) new = statement.new_context( changes=[Entity(name="Mickey")], terms_to_replace=[Entity(name="Donald"), Entity(name="Daisy")], ) assert "<Mickey> loved <Daisy>" in str(new)
def test_is_beard_implied( self, facial_hair_over_5mm, facial_hair_on_or_below_chin, facial_hair_uninterrupted, outcome, make_beard_rule, ): beard = Entity("a facial feature") sec_4 = client.read(path="/test/acts/47/4/") hypothetical = Rule( procedure=Procedure( inputs=[ Fact(Predicate("{} was facial hair"), context_factors=beard), Fact( Predicate( "the length of {} was {}", comparison=">=", quantity=Q_("5 millimeters"), truth=facial_hair_over_5mm, ), context_factors=beard, ), Fact( Predicate( "{} occurred on or below the chin", truth=facial_hair_on_or_below_chin, ), context_factors=beard, ), Fact( Predicate( "{} existed in an uninterrupted line from the front " "of one ear to the front of the other ear below the nose", truth=facial_hair_uninterrupted, ), context_factors=beard, ), ], outputs=Fact(Predicate("{} was a beard"), context_factors=beard), ), enactments=sec_4, ) meets_chin_test = make_beard_rule[0].implies(hypothetical) meets_ear_test = make_beard_rule[1].implies(hypothetical) assert outcome == meets_chin_test or meets_ear_test