public BranchingRule <TERM> Compose(int q, BranchingRule <TERM> rule, TERM y1, TERM y2, TERM y, TERM predicate, IContextCore <TERM> solver, Func <int, int, int> stateComposer) { if (rule is UndefRule <TERM> ) { return(rule); } if (this.yields.Length == 0) { int pq = stateComposer(state, q); var register1 = solver.ApplySubstitution(register, y1, solver.MkProj(0, y)); var register2 = solver.MkProj(1, y); var newreg = solver.MkTuple(register1, register2); var res = new BaseRule <TERM>(Sequence <TERM> .Empty, newreg, pq); return(res); } else { var y_1 = solver.MkProj(0, y); foreach (var o in yields) { var o1 = solver.ApplySubstitution(o, y1, y_1); //var rule1 = rule.Subst(solver, y2) } } return(null); }
private BranchingRule <TERM> EvalB(ConsList <TERM> inputs, int qA, TERM regA, TERM pathCond, int qB, TERM regB, Func <int, int, int> stateComposer, Sequence <TERM> outputFromB, bool isFinal) { if (inputs == null) { int qAB = stateComposer(qA, qB); if (isFinal) { var fr = B.GetFinalRuleFrom(qB); if (fr.IsNotUndef) { return(this.CreateFinalComposedRule(pathCond, qAB, outputFromB, fr, regB)); } else { return(UndefRule <TERM> .Default); } } else { TERM regAB = (regA.Equals(regVar_1) && regB.Equals(regVar_2) ? regVar : JoinRegs(regA, regB)); var res = new BaseRule <TERM>(outputFromB, regAB, qAB); return(res); } } else { return(EvalB_Rule(B.GetRuleFrom(qB), qA, regA, pathCond, inputs, regB, stateComposer, outputFromB, isFinal)); } }
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); } } }
IEnumerable <TERM> GetBaseRuleNonequivalences(IContextCore <TERM> solver, BaseRule <TERM> a, BaseRule <TERM> b) { yield return(solver.MkNeq(a.Register, b.Register)); for (int i = 0; i < a.Yields.Length; ++i) { yield return(solver.MkNeq(a.Yields[i], b.Yields[i])); } }
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); }