Z3：是否可以只简化断言的一部分？

我在Windows7上使用的是Z3版本4.3.2 64位的JavaAPI以及Java7 64位，但我不认为必须使用Java来回答这个问题

现在，我正在使用以下Java代码简化Z3中断言的一个子集：

Tactic simplifyTactic = ctx.mkTactic("ctx-solver-simplify");
Goal goal = ctx.mkGoal(true, false, false);
goal.add(bel.toArray(new BoolExpr[0])); // bel is List<BoolExpr>
ApplyResult applyResult = simplifyTactic.apply(goal);

tractic simplify=ctx.mktractic（“ctx解算器简化”）；
Goal-Goal=ctx.mkGoal（真、假、假）；
goal.add（bel.toArray（新BoolExpr[0]）；//贝尔在名单上
ApplyResult ApplyResult=简化策略。应用（目标）；

到目前为止，我已经过滤了要简化的断言，然后使用上面的代码对它们进行了简化，正如预期的那样

经过一些测试，我得出结论，我还需要插入模型的过滤断言（其中包含一些元信息，如基数）

当另一组断言B仍然被考虑但没有改变时，是否可以简化某组断言A

下面的例子可以稍微澄清一下这个问题：

(declare-const a Bool)
(declare-const b Bool)
(declare-const c Bool)
(declare-const d Bool)

(assert (=> a c)); member of set A
(assert (=> b d)); member of set A
(assert a); member of set A

; member of set B
(assert 
    (<= 
        (+ (ite (= c true) 1 0) (ite (= d true) 1 0))
        1
    )
)

; member of set B
(assert 
    (>= 
        (+ (ite (= c true) 1 0) (ite (= d true) 1 0))
        1
    )
)

(apply ctx-solver-simplify)

（声明常量为布尔）
（宣布常数b布尔）
（声明常数c布尔）
（宣布康斯特布尔）
（断言（=>AC））；集合A的成员
（断言（=>bd））；集合A的成员
（a）主张；集合A的成员
; 集合B的成员
（断言
(= 
（+（ite（=c真）10）（ite（=d真）10））
1.
)
)
（应用ctx解算器简化）

如果此SMT-LIB V2代码由Z3执行，则结果为：

(goals 
    (goal 
        c 
        (not b) 
        a 
        (<= (+ (ite (= c true) 1 0) (ite (= d true) 1 0)) 1) 
        :precision precise :depth 1
    ) 
)

（目标
（目标
C
（不是b）
A.
（为了简化，您需要同时添加
A
和
B
。下面的脚本使用检查简化结果中的每个断言
e
是否等于集合
B
中的任何断言
edel
，如果是，则在简化结果中不包括
e
，所有操作都在使用
A
和
B
进行初始简化。当然，您也可以通过指针从简化的结果中删除
B
中的所有断言，但是如果
B
中的断言被转换，这可能会失败（就像我在z3py而不是Z3的SMT接口中运行示例时的情况一样），因此，这有助于证明断言是否与脚本相同

它还检查了<代码> b>代码>中所有断言的连接。一般来说，您可能需要考虑它的排列（例如，代码< B/<代码>中的断言的成对、三元组等的连词）。，这可能会使其不切实际，但可能会满足您的目的。它适用于提供的示例。以下是z3py中的脚本（链接到rise4fun:）：
a，b，c，d=Bools（'a，b，c，d'）
g=目标（）
A=[]
附加（暗示（A，c））
附加（暗示（b，d））
A.附加（A）
B=[]
B.append（（如果（c==True，1，0）+（如果（d==True，1，0））=1）
g、 加（A）
g、 加（B）
#t=策略（‘简化’）
#打印t（g）#注意差异
t=策略（'ctx-solver-simplify'）
ar=t（g）
print ar#[[c，Not（b），a，If（d，1，0）你能给断言集a和b添加一个最小的例子吗？我做了一些类似于其他策略的事情（例如，量词消除），有A和B将帮助我看看我所做的是否可行。我添加了一个简单的示例。希望这有帮助。您的方法是朝着正确方向迈出的一大步。实际上，还需要测试B的排列，因为在第一次测试中，结果还不是我所希望的。谢谢。
a,b,c,d = Bools('a b c d')
g = Goal()

A = []
A.append(Implies(a, c))
A.append(Implies(b, d))
A.append(a)

B = []
B.append((If(c == True, 1, 0) +  (If(d == True, 1, 0))) <=  1 )
B.append((If(c == True, 1, 0) +  (If(d == True, 1, 0))) >=  1 )

g.add(A)
g.add(B)

#t = Tactic('simplify')
#print t(g) # note difference

t = Tactic('ctx-solver-simplify')
ar = t(g)
print ar # [[c, Not(b), a, If(d, 1, 0) <= 0]]

s = Solver()
s.add(A)
result = []
for e in ar[0]: # iterate over expressions in result
  # try to prove equal
  s.push()
  s.add(Not(e == And(B))) # conunction of all assertions in B
  satres = s.check()
  s.pop()
  if satres == unsat:
    continue

  # check each in B individually
  for edel in B:
    # try to prove equal
    s.push()
    s.add(Not(e == edel))
    satres = s.check()
    s.pop()
    if satres != unsat:
      result.append(e)
      break

print result # [c, Not(b), a]