def isBC(self, bc, show_reason = False):
if type(bc) is str:
bc = spot.formula(bc)
c = spot.language_containment_checker()
#non-triviality
if not sat_check(bc.to_str('spin')) or not sat_check(spot.formula_Not(bc).to_str('spin')):
if show_reason:
print('bc is true or false')
return False
not_g = spot.formula_Not(spot.formula_And(self.goals))
if not sat_check(spot.formula_And([not_g, spot.formula_Not(bc)]).to_str('spin')) and not sat_check(spot.formula_And([spot.formula_Not(not_g), bc]).to_str('spin')):
if show_reason:
print('trivial')
return False
#logical incosistency
if sat_check(spot.formula_And(self.doms + self.goals + [bc,]).to_str('spin')):
if show_reason:
print('consistency')
return False
else:
#minimality
for i in range(len(self.goals)):
if not sat_check(spot.formula_And(self.doms + [goal for goal in self.goals if goal != self.goals[i]] + [bc,]).to_str('spin')):
if show_reason:
print('not minimality')
print(i, self.goals[i].to_str())
return False
return True
def is_not_gd_BC(self):
not_g_d = spot.formula_Not(spot.formula_And(self.goals + self.doms))
#logical incosistency
if sat_check(spot.formula_And(self.doms + self.goals + [not_g_d,]).to_str('spot')):
return False
else:
#minimality
for i in range(len(self.goals)):
if not sat_check(spot.formula_And(self.doms + [goal for goal in self.goals if goal != self.goals[i]] + [not_g_d,]).to_str('spin')):
return False
return True
def get_pbcs_from_aut(aut):
pbcs = []
acc = []
for s in range(0, aut.num_states()):
if aut.state_is_accepting(s):
acc.append(s)
for acc_i in acc:
aut_temp = spot.automaton(aut.to_str('hoa', '1.1'))
for acc_j in acc:
if acc_j != acc_i:
for t in aut_temp.out(acc_j):
t.cond = buddy.bddfalse
run = aut_temp.accepting_run()
plist = [p for p in run.prefix]
pbct = spot.formula_tt()
step = 0
for p in plist:
p_step = spot.bdd_format_formula(aut.get_dict(), p.label)
p_step = spot.formula(p_step)
for i in range(step):
p_step = spot.formula_X(p_step)
pbct = spot.formula_And([pbct, p_step])
step += 1
pbcs.append(pbct)
return pbcs
def isGeneral(self, bc1, bc2):
if type(bc1) is str:
bc1 = spot.formula(bc1)
if type(bc2) is str:
bc2 = spot.formula(bc2)
if not sat_check(spot.formula_And([bc2, spot.formula_Not(bc1)]).to_str('spin')):
return True
else:
return False
def isBC_t(self, bc, no_relation_gi):
if type(bc) is str:
bc = spot.formula(bc)
#logical incosistency
if sat_check(spot.formula_And(self.doms + self.goals + [bc,]).to_str('spin')):
return -1
else:
#minimality
no_relation_g = []
for i in range(len(self.goals)):
if i in no_relation_gi:
no_relation_g.append(self.goals[i])
for i in range(len(self.goals)):
if i in no_relation_gi:
continue
if not sat_check(spot.formula_And(self.doms + [goal for goal in self.goals if goal != self.goals[i] and goal not in no_relation_g] + [bc,]).to_str('spin')):
return i
return -2
def isWitness(self, bc1, bc2):
if type(bc1) is str:
bc1 = spot.formula(bc1)
if type(bc2) is str:
bc2 = spot.formula(bc2)
# if self.isGeneral(bc1, bc2):
# print('just genral')
# return False
if not self.isBC(spot.formula_And([bc2, spot.formula_Not(bc1)])):
return True
else:
return False
def getNonsenseBC(self):
# start = time.time()
f = spot.formula_Not(spot.formula_And(self.goals))
sim_option = spot.tl_simplifier_options()
sim_option.reduce_basics = False
sim = spot.tl_simplifier(sim_option)
f = sim.simplify(f)
f = spot.unabbreviate(f, "GFMW^ie")
print(f.to_str())
nonsense_bc = []
for child_i in f:
if child_i.kind() == spot.op_F:
nonsense_bc.append(spot.formula_Or([child if child != child_i else child[0] for child in f]))
nonsense_bc.append(spot.formula_Or([child if child != child_i else spot.formula_X(child[0]) for child in f]))
# print('get nonsense in: ' + str(time.time()-start))
return nonsense_bc
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import spot
lcc = spot.language_containment_checker()
formulas = ['GFa', 'FGa', '(GFa) U b',
'(a U b) U c', 'a U (b U c)',
'(a W b) W c', 'a W (b W c)',
'(a R b) R c', 'a R (b R c)',
'(a M b) M c', 'a M (b M c)',
'(a R b) U c', 'a U (b R c)',
'(a M b) W c', 'a W (b M c)',
'(a U b) R c', 'a R (b U c)',
'(a W b) M c', 'a M (b W c)',
]
# The rewriting assume the atomic proposition will not change
# once we reache the non-alive part.
cst = spot.formula('G(X!alive => ((a <=> Xa) && (b <=> Xb) && (c <=> Xc)))')
for f in formulas:
f1 = spot.formula(f)
f2 = f1.unabbreviate()
f3 = spot.formula_And([spot.from_ltlf(f1), cst])
f4 = spot.formula_And([spot.from_ltlf(f2), cst])
print("{}\t=>\t{}".format(f1, f3))
print("{}\t=>\t{}".format(f2, f4))
assert lcc.equal(f3, f4)
print()
def dandng_aut(self): return spot.translate(spot.formula_And([spot.formula_Not(spot.formula_And(self.goals))] + self.doms), 'ba', 'det')
def ngd_aut(self): return spot.translate(spot.formula_Not(spot.formula_And(self.goals + self.doms)), 'ba', 'det')
def showdg(self): print(spot.formula_And(self.doms+self.goals).to_str())
def quickSolution(self):
start_time = time.time()
BCs = []
for goal_i in self.goals:
G_minusi = spot.formula_And([g for g in self.goals if g != goal_i])
sim_option = spot.tl_simplifier_options()
sim_option.reduce_basics = False
sim = spot.tl_simplifier(sim_option)
regular_goal_i = sim.simplify(spot.formula_Not(goal_i))
regular_goal_i = spot.unabbreviate(regular_goal_i, "FMW^ie")
# print(regular_goal_i.to_str())
all_ap = spot.atomic_prop_collect(spot.formula_And(self.doms+self.goals))
gi_ap = spot.atomic_prop_collect(goal_i)
none_relation_ap = [ap for ap in all_ap if ap not in gi_ap]
# special case
special_cases = []
if regular_goal_i.kind() == spot.op_ap:
for ap in none_relation_ap:
special_cases.append(spot.formula_And([regular_goal_i,ap]))
elif regular_goal_i.kind() == spot.op_tt:
for ap in none_relation_ap:
special_cases.append(spot.formula_And([regular_goal_i,ap]))
elif regular_goal_i.kind() == spot.op_Not:
for ap in none_relation_ap:
special_cases.append(spot.formula_And([regular_goal_i,ap]))
elif regular_goal_i.kind() == spot.op_And:
for ap in none_relation_ap:
special_cases.append(spot.formula_And([regular_goal_i,ap]))
elif regular_goal_i.kind() == spot.op_G:
for ap in none_relation_ap:
special_cases.append(spot.formula_And([regular_goal_i,ap]))
elif regular_goal_i.kind() == spot.op_Or:
a = regular_goal_i[0]
b = regular_goal_i[1]
special_cases = [a,b]
elif regular_goal_i.kind() == spot.op_X:
for ap in none_relation_ap:
special_cases.append(spot.formula_And([regular_goal_i,ap]))
elif regular_goal_i.kind() == spot.op_R:
a = regular_goal_i[0]
b = regular_goal_i[1]
special_cases = [a,spot.formula_And([b,spot.formula_X(a)])]
elif regular_goal_i.kind() == spot.op_U:
a = regular_goal_i[0]
b = regular_goal_i[1]
special_cases = [b,spot.formula_And([a,spot.formula_X(b)])]
else:
continue
# check sc
for sc in special_cases:
f = spot.formula_And([sc, G_minusi] + self.doms).to_str()
pbc = spot.formula_Or([sc, spot.formula_Not(G_minusi)])
if sat_check(f):
BCs.append(pbc)
gen_time = time.time()
# for bc in BCs:
# print(bc.to_str())
# print(self.isBC(bc))
BCs_real = []
for bc in BCs:
if self.isBC(bc):
BCs_real.append(bc)
BCg = BCs_real.copy()
for bc in BCs_real:
if not self.isBC(bc):
BCs_real.remove(bc)
for bc1 in BCs_real:
if bc != bc1:
a = self.isWitness(bc, bc1)
b = self.isWitness(bc1, bc)
if a and b:
if len(bc.to_str()) < len(bc1.to_str()):
BCs_real.remove(bc1)
if a and not b:
BCs_real.remove(bc1)
# for bc in BCs:
# print(bc.to_str())
return BCg, BCs_real, gen_time-start_time, time.time()-gen_time
def its_impossible(self):
for i in range(len(self.goals)):
if not sat_check( spot.formula_And( self.doms + [goal if goal != self.goals[i] else spot.formula_Not(goal) for goal in self.goals ] ).to_str('spin') ):
print('why')
print(str(i), self.goals[i].to_str())
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import spot
lcc = spot.language_containment_checker()
formulas = ['GFa', 'FGa', '(GFa) U b',
'(a U b) U c', 'a U (b U c)',
'(a W b) W c', 'a W (b W c)',
'(a R b) R c', 'a R (b R c)',
'(a M b) M c', 'a M (b M c)',
'(a R b) U c', 'a U (b R c)',
'(a M b) W c', 'a W (b M c)',
'(a U b) R c', 'a R (b U c)',
'(a W b) M c', 'a M (b W c)',
]
# The rewriting assume the atomic proposition will not change
# once we reache the non-alive part.
cst = spot.formula('G(X!alive => ((a <=> Xa) && (b <=> Xb) && (c <=> Xc)))')
for f in formulas:
f1 = spot.formula(f)
f2 = f1.unabbreviate()
f3 = spot.formula_And([spot.from_ltlf(f1), cst])
f4 = spot.formula_And([spot.from_ltlf(f2), cst])
print("{}\t=>\t{}".format(f1, f3))
print("{}\t=>\t{}".format(f2, f4))
assert lcc.equal(f3, f4)
print()