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); }
internal override BranchingRule <TERM> Subst1(TERM path, IContextCore <TERM> solver, Dictionary <TERM, TERM> subst) { TERM condInst = solver.Simplify(solver.ApplySubstitution(condition, subst)); TERM path_and_condInst = And(solver, path, condInst); TERM path_and_not_condInst = And(solver, path, solver.MkNot(condInst)); if (!solver.IsSatisfiable(path_and_condInst)) { return(falseCase.Subst1(path, solver, subst)); } if (!solver.IsSatisfiable(path_and_not_condInst)) { return(trueCase.Subst1(path, solver, subst)); } else { var t = trueCase.Subst1(path_and_condInst, solver, subst); var f = falseCase.Subst1(path_and_not_condInst, solver, subst); if ((t is UndefRule <TERM>) && (f is UndefRule <TERM>)) { return(UndefRule <TERM> .Default); } return(new IteRule <TERM>(condInst, t, f)); } }
internal override BranchingRule <TERM> ApplyInp(TERM pred, IContextCore <TERM> solver, TERM x, TERM t) { Sequence <TERM> newYields = new Sequence <TERM>(Array.ConvertAll(yields.ToArray(), y => solver.Simplify(solver.ApplySubstitution(y, x, t)))); TERM newRegister = solver.Simplify(solver.ApplySubstitution(register, x, t)); return(new BaseRule <TERM>(newYields, newRegister, state)); }
internal override BranchingRule <TERM> Subst1(TERM path, IContextCore <TERM> solver, Dictionary <TERM, TERM> subst) { Sequence <TERM> newYields = new Sequence <TERM>(Array.ConvertAll(yields.ToArray(), y => solver.Simplify(solver.ApplySubstitution(y, subst)))); TERM newRegister = solver.Simplify(solver.ApplySubstitution(register, subst)); return(new BaseRule <TERM>(newYields, newRegister, state)); }
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); }