def parse_string(self, lines):
[none, var, state, input, output, init, invar, trans] = range(8)
section = none
inits = TRUE()
invars = TRUE()
transs = TRUE()
sparser = StringParser()
count = 0
vars = set([])
states = set([])
inputs = set([])
outputs = set([])
invar_props = []
ltl_props = []
for line in lines:
count += 1
if line.strip() in ["", "\n"]:
continue
if T_VAR == line[:len(T_VAR)]:
section = var
continue
if T_STATE == line[:len(T_STATE)]:
section = state
continue
if T_INPUT == line[:len(T_INPUT)]:
section = input
continue
if T_OUTPUT == line[:len(T_OUTPUT)]:
section = output
continue
if T_INIT == line[:len(T_INIT)]:
section = init
continue
if T_INVAR == line[:len(T_INVAR)]:
section = invar
continue
if T_TRANS == line[:len(T_TRANS)]:
section = trans
continue
if section in [var, state, input, output]:
line = line[:-2].replace(" ", "").split(":")
varname, vartype = line[0], (line[1][:-1].split("("))
if varname[0] == "'":
varname = varname[1:-1]
vardef = self._define_var(varname, vartype)
vars.add(vardef)
if section == state:
states.add(vardef)
if section == input:
inputs.add(vardef)
if section == output:
outputs.add(vardef)
if section in [init, invar, trans]:
qline = quote_names(line[:-2], replace_ops=False)
if section == init:
inits = And(inits, sparser.parse_formula(qline))
if section == invar:
invars = And(invars, sparser.parse_formula(qline))
if section == trans:
transs = And(transs, sparser.parse_formula(qline))
hts = HTS("STS")
ts = TS()
ts.vars = vars
ts.state_vars = states
ts.input_vars = inputs
ts.output_vars = outputs
ts.init = inits
ts.invar = invars
ts.trans = transs
hts.add_ts(ts)
return (hts, invar_props, ltl_props)
def parse_string(self, lines):
[none, var, state, input, output, init, invar, trans,
ftrans] = range(9)
section = none
inits = TRUE()
invars = TRUE()
transs = TRUE()
ftranss = {}
sparser = StringParser()
count = 0
vars = set([])
states = set([])
inputs = set([])
outputs = set([])
invar_props = []
ltl_props = []
for line in lines:
count += 1
if (line.strip() in ["", "\n"]) or line[0] == T_COM:
continue
if T_VAR == line[:len(T_VAR)]:
section = var
continue
if T_STATE == line[:len(T_STATE)]:
section = state
continue
if T_INPUT == line[:len(T_INPUT)]:
section = input
continue
if T_OUTPUT == line[:len(T_OUTPUT)]:
section = output
continue
if T_INIT == line[:len(T_INIT)]:
section = init
continue
if T_INVAR == line[:len(T_INVAR)]:
section = invar
continue
if T_TRANS == line[:len(T_TRANS)]:
section = trans
continue
if T_FTRANS == line[:len(T_FTRANS)]:
section = ftrans
continue
if section in [var, state, input, output]:
varname, vartype = line[:-2].replace(" ", "").split(":")
if varname[0] == "'":
varname = varname[1:-1]
vartype = parse_typestr(vartype)
vardef = self._define_var(varname, vartype)
vars.add(vardef)
if section == state:
states.add(vardef)
if section == input:
inputs.add(vardef)
if section == output:
outputs.add(vardef)
if section in [init, invar, trans]:
line = line.replace(T_SC, "").strip()
qline = quote_names(line, replace_ops=False)
if section == init:
inits = And(inits, sparser.parse_formula(qline))
if section == invar:
invars = And(invars, sparser.parse_formula(qline))
if section == trans:
transs = And(transs, sparser.parse_formula(qline))
if section == ftrans:
strvar = line[:line.find(":=")]
var = sparser.parse_formula(
quote_names(strvar, replace_ops=False))
cond_ass = line[line.find(":=") + 2:].strip()
ftranss[var] = []
for cond_as in cond_ass.split("{"):
if cond_as == "":
continue
cond = cond_as[:cond_as.find(",")]
ass = cond_as[cond_as.find(",") + 1:cond_as.find("}")]
ftranss[var].append((sparser.parse_formula(
quote_names(cond, replace_ops=False)),
sparser.parse_formula(
quote_names(ass,
replace_ops=False))))
hts = HTS("STS")
ts = TS()
ts.vars = vars
ts.state_vars = states
ts.input_vars = inputs
ts.output_vars = outputs
ts.init = inits
ts.invar = invars
ts.trans = transs
ts.ftrans = ftranss
hts.add_ts(ts)
return (hts, invar_props, ltl_props)
def compute(self, hts, prop):
Logger.log("Building COI", 1)
self._build_var_deps(hts)
coi_vars = set(self._free_variables(prop))
if (len(coi_vars) < 1) or (self.var_deps == {}):
return hts
if hts.assumptions is not None:
for assumption in hts.assumptions:
for v in self._free_variables(assumption):
coi_vars.add(v)
if hts.lemmas is not None:
for lemma in hts.lemmas:
for v in self._free_variables(lemma):
coi_vars.add(v)
coits = TS("COI")
coi_vars = list(coi_vars)
i = 0
visited = set([])
while i < len(coi_vars):
var = coi_vars[i]
if (var in visited) or (var not in self.var_deps):
i += 1
continue
coi_vars = coi_vars[:i + 1] + list(
self.var_deps[var]) + coi_vars[i + 1:]
visited.add(var)
i += 1
coi_vars = frozenset(coi_vars)
trans = list(
conjunctive_partition(hts.single_trans(include_ftrans=True)))
invar = list(
conjunctive_partition(hts.single_invar(include_ftrans=True)))
init = list(conjunctive_partition(hts.single_init()))
coits.trans = [
f for f in trans
if self._intersect(coi_vars, self._free_variables(f))
]
coits.invar = [
f for f in invar
if self._intersect(coi_vars, self._free_variables(f))
]
coits.init = [
f for f in init
if self._intersect(coi_vars, self._free_variables(f))
]
Logger.log("COI statistics:", 1)
Logger.log(" Vars: %s -> %s" % (len(hts.vars), len(coi_vars)), 1)
Logger.log(" Init: %s -> %s" % (len(init), len(coits.init)), 1)
Logger.log(" Invar: %s -> %s" % (len(invar), len(coits.invar)), 1)
Logger.log(" Trans: %s -> %s" % (len(trans), len(coits.trans)), 1)
coits.trans = And(coits.trans)
coits.invar = And(coits.invar)
coits.init = And(coits.init)
coits.vars = set([])
for bf in [init, invar, trans]:
for f in bf:
for v in self._free_variables(f):
coits.vars.add(v)
coits.input_vars = set([v for v in coi_vars if v in hts.input_vars])
coits.output_vars = set([v for v in coi_vars if v in hts.output_vars])
coits.state_vars = set([v for v in coi_vars if v in hts.state_vars])
new_hts = HTS("COI")
new_hts.add_ts(coits)
if self.save_model:
printer = HTSPrintersFactory.printer_by_name("STS")
with open("/tmp/coi_model.ssts", "w") as f:
f.write(printer.print_hts(new_hts, []))
return new_hts
