Python 如何在Z3py中定义公理？

我必须在Z3中做一个公理，但是我看了（用量词建模）的例子，我不理解大多数事情。我想如果有人能给我一个Z3py小公理的例子，帮助我理解

我执行的示例是：

Type     = DeclareSort('Type')
subtype  = Function('subtype', Type, Type, BoolSort())
array_of = Function('array_of', Type, Type)
root     = Const('root', Type)

x, y, z  = Consts('x y z', Type)

axioms = [ ForAll(x, subtype(x, x)),
           ForAll([x, y, z], Implies(And(subtype(x, y), subtype(y, z)),
                                     subtype(x, z))),
           ForAll([x, y], Implies(And(subtype(x, y), subtype(y, x)),
                                  x == y)),
           ForAll([x, y, z], Implies(And(subtype(x, y), subtype(x, z)),
                                     Or(subtype(y, z), subtype(z, y)))),
           ForAll([x, y], Implies(subtype(x, y),
                                  subtype(array_of(x), array_of(y)))),

           ForAll(x, subtype(root, x))
           ]
s = Solver()
s.add(axioms)
print s
print s.check()
print "Interpretation for Type:"
print s.model()[Type]
print "Model:"
print s.model()

问题是我不理解输出

[root = Type!val!0,
 subtype = [else ->
            Or(And(If(Var(0) == Type!val!1,
                      Type!val!1,
                      Type!val!0) ==
                   Type!val!1,
                   If(Var(1) == Type!val!1,
                      Type!val!1,
                      Type!val!0) ==
                   Type!val!1),
               And(If(Var(0) == Type!val!1,
                      Type!val!1,
                      Type!val!0) ==
                   Type!val!0,
                   If(Var(1) == Type!val!1,
                      Type!val!1,
                      Type!val!0) ==
                   Type!val!1),
               And(If(Var(0) == Type!val!1,
                      Type!val!1,
                      Type!val!0) ==
                   Type!val!0,
                   If(Var(1) == Type!val!1,
                      Type!val!1,
                      Type!val!0) ==
                   Type!val!0))],
 array_of = [else -> Type!val!1]]

---

出于这个原因，我需要检查一个小示例，以便更好地理解它是如何工作的

您可能指的是这段代码：

Type=DeclareSort（'Type'））
子类型=函数（'subtype'，Type，Type，BoolSort（））
array_of=函数（'array_of'，Type，Type）
root=Const（'root'，类型）
x、 y，z=常数（'x y z'，类型）
axioms=[ForAll（x，子类型（x，x）），
ForAll（[x，y，z]）表示（和（子类型（x，y），子类型（y，z）），
亚型（x，z）），
ForAll（[x，y]，暗示（和（子类型（x，y），子类型（y，x）），
x==y）），
ForAll（[x，y，z]）表示（和（子类型（x，y），子类型（x，z）），
或（亚型（y，z），亚型（z，y）），
ForAll（[x，y]）表示（子类型（x，y），
子类型（x的数组_，y的数组_）），
ForAll（x，子类型（根，x））
]
s=解算器（）
s、 添加（公理）
印刷品
打印s.检查（）
打印“类型的解释：”
打印s.model（）[类型]
打印“型号：”
打印s.model（）

公理只不过是一个量化的断言（请参见如何使用

s.add

将列表

公理添加到解算器），它们通常与未解释的函数有关。（在本例中，
子类型
和数组\`）

不太清楚你在挣扎什么。请问一个具体的问题。你试过运行这个代码吗？它产生了你期望的效果吗？
我编辑了第一条评论，我想了解它是如何工作的，以及如何工作的一个小例子，因为我没有任何想法。输出只是说
root
可以是任何类型（这里给出的名称是
Type！val！0
，而
子类型
是一个匹配大表达式的每个输入的函数，而
array_of
是一个将所有内容匹配到
Type！val！1
的函数，它不同于
根
。这就是
else->
符号的含义；如果它是映射修复d输入到其他值，它们已经被列出。你可以按原样读取表达式：它是一组连词（
和
）的析取（
或
），每个连词本身都是一个条件（
如果
）。希望这是清楚的！