def test_diagonal(self): base_set = Set(Atom(1)) diag_rels = [relations.diag(*base_set), relations.diag(1)] for diag_rel in diag_rels: self.assertEqual(diag_rel.cardinality, 1) self.assertTrue(relations.is_member(diag_rel)) self.assertTrue(diag_rel.has_element(Couplet(1, 1))) base_set = Set(Atom(1), Atom('a')) diag_clan = clans.diag(1, 'a') self.assertEqual(diag_clan.cardinality, 1) diag_rels = [ relations.diag(*base_set), relations.diag(1, 'a'), sets.single(diag_clan) ] for diag_rel in diag_rels: self.assertEqual(diag_rel.cardinality, 2) self.assertTrue(relations.is_member(diag_rel)) self.assertTrue(diag_rel.has_element(Couplet(1, 1))) self.assertTrue(diag_rel.has_element(Couplet('a', 'a'))) arg1 = Set(1, 2, 3) arg2 = [v for v in Set(1, 2, 3)] result_diag = Set(Couplet(1, 1), Couplet(2, 2), Couplet(3, 3)) self.assertEqual(relations.diag(*arg1), result_diag) self.assertEqual(relations.diag(*arg2), result_diag)
def test_diagonal(self): base_set = Set(Atom(1)) diag_rels = [ relations.diag(*base_set), relations.diag(1)] for diag_rel in diag_rels: self.assertEqual(diag_rel.cardinality, 1) self.assertTrue(relations.is_member(diag_rel)) self.assertTrue(diag_rel.has_element(Couplet(1, 1))) base_set = Set(Atom(1), Atom('a')) diag_clan = clans.diag(1, 'a') self.assertEqual(diag_clan.cardinality, 1) diag_rels = [ relations.diag(*base_set), relations.diag(1, 'a'), sets.single(diag_clan)] for diag_rel in diag_rels: self.assertEqual(diag_rel.cardinality, 2) self.assertTrue(relations.is_member(diag_rel)) self.assertTrue(diag_rel.has_element(Couplet(1, 1))) self.assertTrue(diag_rel.has_element(Couplet('a', 'a'))) arg1 = Set(1, 2, 3) arg2 = [v for v in Set(1, 2, 3)] result_diag = Set(Couplet(1, 1), Couplet(2, 2), Couplet(3, 3)) self.assertEqual(relations.diag(*arg1), result_diag) self.assertEqual(relations.diag(*arg2), result_diag)
# By extending superstriction to clans, which are sets of sets (of Couplets), we can define a helpful # mechanism to restrict vocab_clan to only those relations that contain particular values. import algebraixlib.algebras.clans as clans salutation_records_clan = clans.superstrict(vocab_clan, Set(Set(Couplet('meaning', 'salutation')))) earth_records_clan = clans.superstrict(vocab_clan, Set(Set(Couplet('meaning', 'earth')))) print("salutation_records_clan:", salutation_records_clan) print("earth_records_clan:", earth_records_clan) # By choosing an appropriate right-hand argument, our extended composition operation from earlier can # model projection. words_langs_clan = Set(Set(Couplet('word', 'word'), Couplet('language', 'language'))) print("words_langs_clan:", words_langs_clan) # The relations.diag and clans.diag utility functions create a "diagonal" relation or clan, # respectively, with simpler syntax. assert words_langs_clan == clans.diag('word', 'language') # Since the meaning of each set of records ('salutation') is invariant among the relations in # salutation_records_clan, we can drop those Couplets. Note that the cardinality of the resulting # clan is the same, but each relation now contains only two Couplets. salutation_words_n_langs_clan = clans.compose(salutation_records_clan, words_langs_clan) print("salutation_words_n_langs_clan:", salutation_words_n_langs_clan) # However, we can take this one step further and "rename" the 'word' attribute to something more # specific by replacing the value 'word' with 'salutation' everywhere we find it as the left of a # Couplet. By doing this, we both compress the information in each relation and also set our data up # for later processing. salutations_n_langs_clan = clans.compose(salutation_words_n_langs_clan, Set(Set(Couplet("salutation", "word"), Couplet("language", "language")))) print("salutations_n_langs_clan:", salutations_n_langs_clan)
salutation_records_clan = clans.superstrict( vocab_clan, Set(Set(Couplet('meaning', 'salutation')))) earth_records_clan = clans.superstrict(vocab_clan, Set(Set(Couplet('meaning', 'earth')))) print("salutation_records_clan:", salutation_records_clan) print("earth_records_clan:", earth_records_clan) # By choosing an appropriate right-hand argument, our extended composition operation from earlier # can model projection. words_langs_clan = Set( Set(Couplet('word', 'word'), Couplet('language', 'language'))) print("words_langs_clan:", words_langs_clan) # The relations.diag and clans.diag utility functions create a "diagonal" relation or clan, # respectively, with simpler syntax. assert words_langs_clan == clans.diag('word', 'language') # Since the meaning of each set of records ('salutation') is invariant among the relations in # salutation_records_clan, we can drop those Couplets. Note that the cardinality of the resulting # clan is the same, but each relation now contains only two Couplets. salutation_words_n_langs_clan = clans.compose(salutation_records_clan, words_langs_clan) print("salutation_words_n_langs_clan:", salutation_words_n_langs_clan) # However, we can take this one step further and "rename" the 'word' attribute to something more # specific by replacing the value 'word' with 'salutation' everywhere we find it as the left of a # Couplet. By doing this, we both compress the information in each relation and also set our data up # for later processing. salutations_n_langs_clan = clans.compose( salutation_words_n_langs_clan, Set(Set(Couplet("salutation", "word"), Couplet("language", "language"))))