STbRule <T> MkSTbRule(IEnumerable <Move <Pair <BDD, T> > > moves, Func <int, int> getState, Func <int, Sequence <T> > getYield, Func <int, T, T> getUpdate)
{
List <Tuple <T, BaseRule <T> > > cases = new List <Tuple <T, BaseRule <T> > >();
var allGuards = solver.CharSetProvider.False;
foreach (var m in moves)
{
cases.Add(new Tuple <T, BaseRule <T> >(ConvertToPredicate(m.Label.First),
new BaseRule <T>(getYield(m.TargetState), getUpdate(m.TargetState, m.Label.Second), getState(m.TargetState))));
allGuards = solver.CharSetProvider.MkOr(allGuards, m.Label.First);
}
STbRule <T> r = UndefRule <T> .Default;
if (cases.Count > 0)
{
if (allGuards.IsFull)
{
r = cases[0].Item2;
}
else
{
r = new IteRule <T>(cases[0].Item1, cases[0].Item2, UndefRule <T> .Default);
}
for (int i = 1; i < cases.Count; i++)
{
r = new IteRule <T>(cases[i].Item1, cases[i].Item2, r);
}
}
return(r);
}
internal BranchingRule <TERM> ToIte(Func <TERM, TERM, TERM> mkEq)
{
var res = defaultcase;
for (int i = cases.Length - 1; i >= 0; i--)
{
res = new IteRule <TERM>(mkEq(input, cases[i].Key), cases[i].Value, res);
}
return(res);
}
internal BranchingRule <TERM> ToIteForVisualization()
{
var res = defaultcase;
for (int i = cases.Length - 1; i >= 0; i--)
{
res = new IteRule <TERM>(cases[i].Key, cases[i].Value, res);
}
return(res);
}
internal STbRule <TERM> ToIteForVisualization()
{
var res = defaultcase;
for (int i = 0; i < cases.Length; i++)
{
res = new IteRule <TERM>(cases[i].Key, cases[i].Value, res);
}
return(res);
}
internal override BranchingRule <TERM> Concretize1(TERM path, IContextCore <TERM> solver,
Func <TERM, TERM> fBP, Func <TERM, TERM> fNBP,
Func <int, TERM, int> stateMap, TERM newReg, TERM inputVar)
{
ConsList <TERM> abstr_vals = null; //all possible values for a_tmp
var regAbstr = fBP(register);
#region collect all possible distinct solutions into abstr_vals
solver.MainSolver.Push();
var a = solver.MkFreshConst("a", regAbstr);
var c = solver.MkFreshConst("c", inputVar);
var r = solver.MkFreshConst("r", newReg);
var assertion = solver.ApplySubstitution(solver.MkAnd(path, solver.MkEq(a, regAbstr)), newReg, r, inputVar, c);
//string tmp = ((IPrettyPrinter<TERM>)solver).PrettyPrint(assertion);
solver.MainSolver.Assert(assertion);
var model = solver.MainSolver.GetModel(solver.True, a);
while (model != null)
{
var aVal = model[a].Value;
abstr_vals = new ConsList <TERM>(aVal, abstr_vals);
solver.MainSolver.Assert(solver.MkNeq(a, aVal));
model = solver.MainSolver.GetModel(solver.True, a);
}
solver.MainSolver.Pop();
#endregion
if (abstr_vals == null) //list cannot be empty because the path is feasible
{
throw new AutomataException(AutomataExceptionKind.InternalError);
}
//now create corresponding concrete outputs for the cases
//note that, in case of a boolean abstraction, we need to add additional cases
//according to the output values that were obtained
var newRegister = fNBP(register);
var newState = stateMap(state, abstr_vals.First);
BranchingRule <TERM> rule = new BaseRule <TERM>(yields, newRegister, newState);
abstr_vals = abstr_vals.Rest;
while (abstr_vals != null)
{
newRegister = fNBP(register);
newState = stateMap(state, abstr_vals.First);
var brule = new BaseRule <TERM>(yields, newRegister, newState);
TERM cond = solver.Simplify(solver.MkEq(abstr_vals.First, regAbstr));
rule = new IteRule <TERM>(cond, brule, rule);
abstr_vals = abstr_vals.Rest;
}
return(rule);
}
BranchingRule <TERM> Comp(TERM pathCond, BranchingRule <TERM> ruleA, int qB, Func <int, int, int> stateComposer, bool isFinal)
{
if (ruleA is SwitchRule <TERM> )
{
throw new NotImplementedException(ruleA.ToString());
}
var ite = ruleA as IteRule <TERM>;
if (ite != null)
{
var iteCondLifted = solver.ApplySubstitution(ite.Condition, A.RegVar, regVar_1);
var pathCond_T = (pathCond.Equals(solver.True) ? iteCondLifted : solver.MkAnd(pathCond, iteCondLifted));
var pathCond_F = (pathCond.Equals(solver.True) ? solver.MkNot(iteCondLifted) : solver.MkAnd(pathCond, solver.MkNot(iteCondLifted)));
var res_T = Comp(pathCond_T, ite.TrueCase, qB, stateComposer, isFinal);
var res_F = Comp(pathCond_F, ite.FalseCase, qB, stateComposer, isFinal);
if (res_T is UndefRule <TERM> && res_F is UndefRule <TERM> )
{
return(UndefRule <TERM> .Default);
}
var res = new IteRule <TERM>(iteCondLifted, res_T, res_F);
return(res);
}
else
{
var br = ruleA as BaseRule <TERM>;
if (br != null)
{
var yieldsFromALifted = br.Yields.ConvertAll(t => solver.ApplySubstitution(t, A.RegVar, regVar_1));
var inputsToB = ConsList <TERM> .Create(yieldsFromALifted);
var regALifted = solver.ApplySubstitution(br.Register, A.RegVar, regVar_1);
var res = this.EvalB(inputsToB, br.State, regALifted, pathCond, qB, regVar_2, stateComposer, Sequence <TERM> .Empty, isFinal);
return(res);
}
else
{
return(UndefRule <TERM> .Default);
}
}
}
