private BranchingRule <TERM> CreateFinalComposedRule(TERM pathCond, int qAB, Sequence <TERM> outputFromB, BranchingRule <TERM> ruleB, TERM regB)
{
if (ruleB is SwitchRule <TERM> )
{
throw new NotImplementedException(ruleB.ToString());
}
var br = ruleB as BaseRule <TERM>;
if (br != null)
{
var yields = br.Yields.ConvertAll(z => Simpl(Subst(z, B.RegVar, regB)));
var outp = outputFromB.Append(yields);
var res = new BaseRule <TERM>(outp, regVar, qAB);
return(res);
}
else
{
var ite = ruleB as IteRule <TERM>;
if (ite != null)
{
var condLifted = Subst(ite.Condition, B.RegVar, regB);
var path_and_condLifted = solver.MkAnd(pathCond, condLifted);
if (!solver.IsSatisfiable(path_and_condLifted))
{
//path ==> !condLifted, the true-branch is unreachable
var res = CreateFinalComposedRule(pathCond, qAB, outputFromB, ite.FalseCase, regB);
return(res);
}
else
{
var path_and_not_condLifted = solver.MkAnd(pathCond, solver.MkNot(condLifted));
if (!solver.IsSatisfiable(path_and_not_condLifted))
{
//path ==> condLifted, the false-branch is unreachable
var res = CreateFinalComposedRule(pathCond, qAB, outputFromB, ite.TrueCase, regB);
return(res);
}
else
{
var f = CreateFinalComposedRule(path_and_not_condLifted, qAB, outputFromB, ite.FalseCase, regB);
var t = CreateFinalComposedRule(path_and_condLifted, qAB, outputFromB, ite.TrueCase, regB);
if (t is UndefRule <TERM> && f is UndefRule <TERM> )
{
return(UndefRule <TERM> .Default);
}
return(new IteRule <TERM>(condLifted, t, f));
}
}
}
else
{
return(UndefRule <TERM> .Default);
}
}
}
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);
}
}
}
