4

我目前正在发现 Owlready 库的所有可能性。现在我正在尝试处理一些 SWRL 规则，到目前为止它进展顺利，但我被困在某一点上。

我已经在我的本体中定义了一些规则，现在我想查看所有结果（所以，一切都是从规则中推断出来的）。

例如，如果我有一个规则

has_brother(David, ?b) ^ has_child(?b, ?s) -> has_uncle(?s, David)

大卫有两个兄弟，约翰和皮特，约翰的孩子是安娜，皮特的孩子是西蒙，我也想看到类似的东西：

has_brother(David, John) ^ has_child(John, Anna) -> has_uncle(Anna, David)

has_brother(David, Pete) ^ has_child(Pete, Simon) -> has_uncle(Simon, David)

这有可能吗？我想也许如果我运行推理器，我可以在它的输出中看到它，但我在任何地方都找不到它。

我感谢任何可能的帮助！

4

1 回答 1

2

这是我的解决方案：



import owlready2 as owl

onto = owl.get_ontology("http://test.org/onto.owl")

with onto:
    class Person(owl.Thing):
        pass

    class has_brother(owl.ObjectProperty, owl.SymmetricProperty, owl.IrreflexiveProperty):
        domain = [Person]
        range = [Person]
    
    class has_child(Person >> Person):
        pass
    
    class has_uncle(Person >> Person):
        pass

    rule1 = owl.Imp()
    rule1.set_as_rule(
        "has_brother(?p, ?b), has_child(?p, ?c) -> has_uncle(?c, ?b)"
    )

    # This rule gives "irreflexive transitivity",
    # i.e. transitivity, as long it does not lead to has_brother(?a, ?a)"
    rule2 = owl.Imp()
    rule2.set_as_rule(
        "has_brother(?a, ?b), has_brother(?b, ?c), differentFrom(?a, ?c) -> has_brother(?a, ?c)"
    )
    
david = Person("David")
john = Person("John")
pete = Person("Pete")
anna = Person("Anna")
simon = Person("Simon")

owl.AllDifferent([david, john, pete, anna, simon])

david.has_brother.extend([john, pete])

john.has_child.append(anna)
pete.has_child.append(simon)

print("Uncles of Anna:", anna.has_uncle) # -> []
print("Uncles of Simon:", simon.has_uncle) # -> []
owl.sync_reasoner(infer_property_values=True)
print("Uncles of Anna:", anna.has_uncle) # -> [onto.Pete, onto.David]
print("Uncles of Simon:", simon.has_uncle) # -> [onto.John, onto.David]

笔记：

有人可能认为has_brother是

  • 对称的，即has_brother(A, B)⇒has_brother(B, A)
  • 传递的，即has_brother(A, B) + has_brother(B, C) ⇒ has_brother(A, C)
  • 不自反，即没有人是他自己的兄弟。

然而，传递性只有在唯一名称假设成立时才成立。否则A可能是同一个人C，这与非自反性冲突。因此，我对这种“弱传递性”使用了一个规则。

一次，has_brother果然大叔规矩也行。当然，推理器必须先运行。

更新：我在这个 Jupyter 笔记本中发布了解决方案（其中还包含执行的输出）。

于 2021-10-02T14:19:59.947 回答