public void Run() { Dictionary <string, string> cfg = new Dictionary <string, string>() { { "AUTO_CONFIG", "true" } }; using (Context ctx = new Context(cfg)) { RealExpr x = ctx.MkRealConst("x"); RealExpr y = ctx.MkRealConst("y"); Goal g = ctx.MkGoal(); g.Assert(ctx.MkOr(ctx.MkLt(x, ctx.MkReal(0)), ctx.MkGt(x, ctx.MkReal(0)))); g.Assert(ctx.MkEq(x, ctx.MkAdd(y, ctx.MkReal(1)))); g.Assert(ctx.MkLt(y, ctx.MkReal(0))); Tactic t = ctx.MkTactic("split-clause"); ApplyResult ar = t[g]; foreach (var sg in ar.Subgoals) { Console.WriteLine(sg); } } }
private void ejectReplacedEquipment(EquipmentModelDefinition eqDefToApply, ApplyResult result) { HashSet <Part> ejectedParts = null; HashSet <EquipmentModelDefinition> ejectedEquipment = null; if (GetEquipmentToEject(eqDefToApply, out ejectedParts, out ejectedEquipment)) { foreach (EquipmentModelDefinition item in ejectedEquipment) { equipmentList.Remove(item); if (this.EquipmentEjected != null) { try { this.EquipmentEjected(item); } catch (Exception ex) { Log.LogException(this, ex); } } } } result.PartsEjected = ejectedParts; result.EquipmentEjected = ejectedEquipment; }
private object ApplyItem() { object obj = null; string errorMessage = ""; string successMessage = ""; bool edited; ApplyResult result = this.ProcessApplyItem(ref obj, out errorMessage, out successMessage, out edited); if (!String.IsNullOrWhiteSpace(errorMessage)) { this.SetErrorMessage(errorMessage); } if (!String.IsNullOrWhiteSpace(successMessage)) { this.SetSuccessMessage(successMessage); } switch (result) { case ApplyResult.Cancel: return(Response.AsRedirect(this.MainPage)); case ApplyResult.Message: break; case ApplyResult.Save: return(Response.AsRedirect(String.Format("{0}?{1}={2}", this.MainPage, Master.Success, edited ? Master.PostEdit : Master.PostAdd))); } this.Context.ViewBag.MainPage = this.MainPage; this.Context.ViewBag.ConfigPage = this.ConfigPage; return(View["controls/configurecontrol", obj]); }
public void Run() { Dictionary <string, string> cfg = new Dictionary <string, string>() { { "AUTO_CONFIG", "true" } }; using (Context ctx = new Context(cfg)) { RealExpr x = ctx.MkRealConst("x"); RealExpr y = ctx.MkRealConst("y"); RealExpr z = ctx.MkRealConst("z"); RealExpr zero = ctx.MkReal(0); RealExpr one = ctx.MkReal(1); Goal g = ctx.MkGoal(); g.Assert(ctx.MkOr(ctx.MkEq(x, zero), ctx.MkEq(x, one))); g.Assert(ctx.MkOr(ctx.MkEq(y, zero), ctx.MkEq(y, one))); g.Assert(ctx.MkOr(ctx.MkEq(z, zero), ctx.MkEq(z, one))); g.Assert(ctx.MkGt(ctx.MkAdd(x, y, z), ctx.MkReal(2))); Tactic t = ctx.Repeat(ctx.OrElse(ctx.MkTactic("split-clause"), ctx.MkTactic("skip"))); ApplyResult ar = t[g]; foreach (var sg in ar.Subgoals) { Console.WriteLine(sg); } } }
public override ApplyResult Apply(object[] args) { var list = args .OfType <T>() .ToList(); var seed = _seedFunc(list[0], list.Count); return(ApplyResult.From(list.Skip(1).Aggregate(seed, _aggrFunc))); }
private void HintResponse(SocketIO.SocketIOEvent E) { ApplyResult result = JsonConvert.DeserializeObject <ApplyResult>(E.data.ToString()); if (result.State) { isitHint = true; MakeSelect(result.path[0].Src.R, result.path[0].Src.C); List <List <Action> > send = new List <List <Action> >(); send.Add(result.path); selectedPiece.GetComponent <Piece>().FindAllPossibleMoves(send, pieces, grid, highLightMaterial1, highLightMaterial2, highLightMaterial4); //Capture(selectedPiece, ConvertA2S(result.path)); } }
/// <summary> /// Compile MCFunction. /// </summary> /// <param name="env">Build environment</param> /// <param name="generateOutput">Should a text output be generated?</param> public void Compile(BuildEnvironment env, bool generateOutput = true) { // Apply custom commands var toRemove = new List <Command.Command>(); int i = 0; while (i < Commands.Count) { Command.Command command = Commands[i]; foreach (ICustomCommand customCommand in CustomCommands) { if (customCommand.DoesApply(env, command)) { ApplyResult result = customCommand.Apply(env, command); // Strip command from output if requested if (result.StripFromOutput) { toRemove.Add(command); } // Add replacement commands Commands.InsertRange(i + 1, result.AddCommands); } } i++; } // Remove compiler commands (they are not meant for the output) foreach (Command.Command command in toRemove) { Commands.Remove(command); } toRemove.Clear(); // Split function blocks into seperate McFunctions SplitFunctionBlocks(env); if (generateOutput) { // Compile to vanilla MCFunction file GenerateMcFunction(env); } }
public ApplyResult ApplyEquipment(DCustomEquipment customEqToApply) { EquipmentModelDefinition equipmentDefinition = Definition.GetEquipmentDefinition(customEqToApply); ApplyResult applyResult = new ApplyResult(); applyResult.CustomEquipmentApplied = customEqToApply; applyResult.EquipmentDefinitionApplied = equipmentDefinition; applyResult.PartsAdded = new HashSet <Part>(); if (equipmentDefinition != null) { ejectReplacedEquipment(equipmentDefinition, applyResult); applyParts(equipmentDefinition, customEqToApply, applyResult.PartsAdded); ejectRemainingParts(applyResult.PartsEjected); equipmentList.Add(equipmentDefinition); } return(applyResult); }
private void ApplyMoveResponse(SocketIO.SocketIOEvent E) { ApplyResult result = JsonConvert.DeserializeObject <ApplyResult>(E.data.ToString()); if (result.State) { if (selectedPiece == null) { selectAutoMove(result.path[0].Src.R, result.path[0].Src.C); AutoMove(pieces[result.path[0].Src.R, result.path[0].Src.C], ConvertA2S(result.path)); } else { Capture(pieces[result.path[0].Src.R, result.path[0].Src.C], ConvertA2S(result.path)); } } }
public override ApplyResult Apply(object[] args) { if (args.Length < _parameters.Length) { var msg = String.Format("Expected {0} arguments, actual: {1}", _parameters.Length, args.Length); return(new ApplyResult(msg)); } Debug.Assert(args.Length >= _parameters.Length); var newEnv = _scmEnvironment.Extend(); for (int i = 0; i < _parameters.Length; i++) { newEnv.Add(_parameters[i], args[i]); } var se = _scmExpression.Eval(newEnv).Value as SelfEvaluatingExpression; return(ApplyResult.From(se.Value)); }
public void Run() { using (Context ctx = new Context()) { RealExpr x = ctx.MkRealConst("x"); RealExpr y = ctx.MkRealConst("y"); Goal g = ctx.MkGoal(); g.Assert(ctx.MkGt(x, ctx.MkReal(10)), ctx.MkEq(y, ctx.MkAdd(x, ctx.MkReal(1)))); g.Assert(ctx.MkGt(y, ctx.MkReal(1))); Tactic t = ctx.MkTactic("simplify"); ApplyResult r = t.Apply(g); Console.WriteLine(r); Console.WriteLine(g.Size); foreach (Goal s in r.Subgoals) { Console.WriteLine(s); } Console.WriteLine("Old goal: "); Console.WriteLine(g); t = ctx.Then(ctx.MkTactic("simplify"), ctx.MkTactic("solve-eqs")); r = t.Apply(g); Console.WriteLine(r); Solver solver = ctx.MkSolver(); foreach (BoolExpr f in r.Subgoals[0].Formulas) { solver.Assert(f); } Console.WriteLine(solver); Console.WriteLine(solver.Check()); Console.WriteLine(solver.Model); Console.WriteLine("applying model convert"); Console.WriteLine(r.ConvertModel(0, solver.Model)); Console.WriteLine("done"); } }
public void Run() { Dictionary <string, string> cfg = new Dictionary <string, string>() { { "AUTO_CONFIG", "true" } }; using (Context ctx = new Context(cfg)) { Tactic t = ctx.Then(ctx.MkTactic("simplify"), ctx.MkTactic("normalize-bounds"), ctx.MkTactic("solve-eqs")); IntExpr x = ctx.MkIntConst("x"); IntExpr y = ctx.MkIntConst("y"); IntExpr z = ctx.MkIntConst("z"); Goal g = ctx.MkGoal(); g.Assert(ctx.MkGt(x, ctx.MkInt(10))); g.Assert(ctx.MkEq(y, ctx.MkAdd(x, ctx.MkInt(3)))); g.Assert(ctx.MkGt(z, y)); ApplyResult r = t[g]; Console.WriteLine(r); Solver s = ctx.MkSolver(); s.Assert(r.Subgoals[0].Formulas); Console.WriteLine(s.Check()); Console.WriteLine("subgoal model"); Model sgm = s.Model; Console.WriteLine(sgm); Console.WriteLine("converted model"); Model m = r.ConvertModel(0, sgm); Console.WriteLine(m); Console.WriteLine(m.Evaluate(x)); } }
// IManagedHotReloadAgent public async ValueTask ApplyUpdatesAsync(ImmutableArray <ManagedHotReloadUpdate> updates, CancellationToken cancellationToken) { if (!_sessionActive) { WriteToOutputWindow($"ApplyUpdatesAsync called but the session is not active."); return; } if (_deltaApplier is null) { WriteToOutputWindow($"ApplyUpdatesAsync called but we have no delta applier."); } if (!_sessionActive || _deltaApplier is null) { return; } try { WriteToOutputWindow(VSResources.HotReloadSendingUpdates); ApplyResult result = await _deltaApplier.ApplyUpdatesAsync(updates, cancellationToken); if (result == ApplyResult.Success || result == ApplyResult.SuccessRefreshUI) { WriteToOutputWindow(VSResources.HotReloadApplyUpdatesSuccessful); if (_callback is not null) { await _callback.OnAfterChangesAppliedAsync(cancellationToken); } } } catch (Exception ex) { string message = $"{ex.GetType()}: {ex.Message}"; WriteToOutputWindow(string.Format(VSResources.HotReloadApplyUpdatesFailure, message)); throw; } }
/// <summary> /// Consolidate constraints. Remove all redundancies. /// Eg. (= rax, rbx-4443) and (= rbx-4443, 2) is replaced by (= rax, 2) /// </summary> public static void Consolidate(bool undef, Solver solver, Solver solver_U, Context ctx) { if (true) { #region Doc /* * tacticName ackermannize_bv: A tactic for performing full Ackermannization on bv instances. * tacticName subpaving: tactic for testing subpaving module. * tacticName horn: apply tactic for horn clauses. * tacticName horn-simplify: simplify horn clauses. * tacticName nlsat: (try to) solve goal using a nonlinear arithmetic solver. * tacticName qfnra-nlsat: builtin strategy for solving QF_NRA problems using only nlsat. * tacticName nlqsat: apply a NL-QSAT solver. * tacticName qe-light: apply light-weight quantifier elimination. * tacticName qe-sat: check satisfiability of quantified formulas using quantifier elimination. * tacticName qe: apply quantifier elimination. * tacticName qsat: apply a QSAT solver. * tacticName qe2: apply a QSAT based quantifier elimination. * tacticName qe_rec: apply a QSAT based quantifier elimination recursively. * tacticName vsubst: checks satsifiability of quantifier-free non-linear constraints using virtual substitution. * tacticName sat: (try to) solve goal using a SAT solver. * tacticName sat-preprocess: Apply SAT solver preprocessing procedures (bounded resolution, Boolean constant propagation, 2-SAT, subsumption, subsumption resolution). * tacticName ctx-solver-simplify: apply solver-based contextual simplification rules. * tacticName smt: apply a SAT based SMT solver. * tacticName unit-subsume-simplify: unit subsumption simplification. * tacticName aig: simplify Boolean structure using AIGs. * tacticName add-bounds: add bounds to unbounded variables (under approximation). * tacticName card2bv: convert pseudo-boolean constraints to bit-vectors. * tacticName degree-shift: try to reduce degree of polynomials (remark: :mul2power simplification is automatically applied). * tacticName diff-neq: specialized solver for integer arithmetic problems that contain only atoms of the form (<= k x) (<= x k) and (not (= (- x y) k)), where x and y are constants and k is a numeral, and all constants are bounded. * tacticName elim01: eliminate 0-1 integer variables, replace them by Booleans. * tacticName eq2bv: convert integer variables used as finite domain elements to bit-vectors. * tacticName factor: polynomial factorization. * tacticName fix-dl-var: if goal is in the difference logic fragment, then fix the variable with the most number of occurrences at 0. * tacticName fm: eliminate variables using fourier-motzkin elimination. * tacticName lia2card: introduce cardinality constraints from 0-1 integer. * tacticName lia2pb: convert bounded integer variables into a sequence of 0-1 variables. * tacticName nla2bv: convert a nonlinear arithmetic problem into a bit-vector problem, in most cases the resultant goal is an under approximation and is useul for finding models. * tacticName normalize-bounds: replace a variable x with lower bound k <= x with x' = x - k. * tacticName pb2bv: convert pseudo-boolean constraints to bit-vectors. * tacticName propagate-ineqs: propagate ineqs/bounds, remove subsumed inequalities. * tacticName purify-arith: eliminate unnecessary operators: -, /, div, mod, rem, is-int, to-int, ^, root-objects. * tacticName recover-01: recover 0-1 variables hidden as Boolean variables. * tacticName bit-blast: reduce bit-vector expressions into SAT. * tacticName bv1-blast: reduce bit-vector expressions into bit-vectors of size 1 (notes: only equality, extract and concat are supported). * tacticName bv_bound_chk: attempts to detect inconsistencies of bounds on bv expressions. * tacticName propagate-bv-bounds: propagate bit-vector bounds by simplifying implied or contradictory bounds. * tacticName reduce-bv-size: try to reduce bit-vector sizes using inequalities. * tacticName bvarray2uf: Rewrite bit-vector arrays into bit-vector (uninterpreted) functions. * tacticName dt2bv: eliminate finite domain data-types. Replace by bit-vectors. * tacticName elim-small-bv: eliminate small, quantified bit-vectors by expansion. * tacticName max-bv-sharing: use heuristics to maximize the sharing of bit-vector expressions such as adders and multipliers. * tacticName blast-term-ite: blast term if-then-else by hoisting them. * tacticName cofactor-term-ite: eliminate term if-the-else using cofactors. * tacticName collect-statistics: Collects various statistics. * tacticName ctx-simplify: apply contextual simplification rules. * tacticName der: destructive equality resolution. * tacticName distribute-forall: distribute forall over conjunctions. * tacticName elim-term-ite: eliminate term if-then-else by adding fresh auxiliary declarations. * tacticName elim-uncnstr: eliminate application containing unconstrained variables. * tacticName snf: put goal in skolem normal form. * tacticName nnf: put goal in negation normal form. * tacticName occf: put goal in one constraint per clause normal form (notes: fails if proof generation is enabled; only clauses are considered). * tacticName pb-preprocess: pre-process pseudo-Boolean constraints a la Davis Putnam. * tacticName propagate-values: propagate constants. * tacticName reduce-args: reduce the number of arguments of function applications, when for all occurrences of a function f the i-th is a value. * tacticName simplify: apply simplification rules. * tacticName elim-and: convert (and a b) into (not (or (not a) (not b))). * tacticName solve-eqs: eliminate variables by solving equations. * tacticName split-clause: split a clause in many subgoals. * tacticName symmetry-reduce: apply symmetry reduction. * tacticName tseitin-cnf: convert goal into CNF using tseitin-like encoding (note: quantifiers are ignored). * tacticName tseitin-cnf-core: convert goal into CNF using tseitin-like encoding (note: quantifiers are ignored). This tactic does not apply required simplifications to the input goal like the tseitin-cnf tactic. * tacticName fpa2bv: convert floating point numbers to bit-vectors. * tacticName qffp: (try to) solve goal using the tactic for QF_FP. * tacticName qffpbv: (try to) solve goal using the tactic for QF_FPBV (floats+bit-vectors). * tacticName nl-purify: Decompose goal into pure NL-sat formula and formula over other theories. * tacticName default: default strategy used when no logic is specified. * tacticName qfbv-sls: (try to) solve using stochastic local search for QF_BV. * tacticName nra: builtin strategy for solving NRA problems. * tacticName qfaufbv: builtin strategy for solving QF_AUFBV problems. * tacticName qfauflia: builtin strategy for solving QF_AUFLIA problems. * tacticName qfbv: builtin strategy for solving QF_BV problems. * tacticName qfidl: builtin strategy for solving QF_IDL problems. * tacticName qflia: builtin strategy for solving QF_LIA problems. * tacticName qflra: builtin strategy for solving QF_LRA problems. * tacticName qfnia: builtin strategy for solving QF_NIA problems. * tacticName qfnra: builtin strategy for solving QF_NRA problems. * tacticName qfuf: builtin strategy for solving QF_UF problems. * tacticName qfufbv: builtin strategy for solving QF_UFBV problems. * tacticName qfufbv_ackr: A tactic for solving QF_UFBV based on Ackermannization. * tacticName qfufnra: builtin strategy for solving QF_UNFRA problems. * tacticName ufnia: builtin strategy for solving UFNIA problems. * tacticName uflra: builtin strategy for solving UFLRA problems. * tacticName auflia: builtin strategy for solving AUFLIA problems. * tacticName auflira: builtin strategy for solving AUFLIRA problems. * tacticName aufnira: builtin strategy for solving AUFNIRA problems. * tacticName lra: builtin strategy for solving LRA problems. * tacticName lia: builtin strategy for solving LIA problems. * tacticName lira: builtin strategy for solving LIRA problems. * tacticName skip: do nothing tactic. * tacticName fail: always fail tactic. * tacticName fail-if-undecided: fail if goal is undecided. * tacticName macro-finder: Identifies and applies macros. * tacticName quasi-macros: Identifies and applies quasi-macros. * tacticName ufbv-rewriter: Applies UFBV-specific rewriting rules, mainly demodulation. * tacticName bv: builtin strategy for solving BV problems (with quantifiers). * tacticName ufbv: builtin strategy for solving UFBV problems (with quantifiers). */ #endregion { //Tactic taY = ctx.MkTactic("default"); // does not work: all constraitns are lost //Tactic taX = ctx.MkTactic("skip"); //Tactic ta0 = ctx.MkTactic("ctx-solver-simplify"); //VERY SLOW Tactic ta1 = ctx.MkTactic("simplify"); // some minor rewrites Tactic ta2 = ctx.MkTactic("ctx-simplify"); // no differences compared with SKIP //Tactic ta3 = ctx.MkTactic("qfbv"); // does not work: all constraitns are lost //Tactic ta3b = ctx.MkTactic("qfbv-sls");// does not work: all constraitns are lost //Tactic ta4 = ctx.MkTactic("solve-eqs");// does not work: all constraitns are lost Tactic ta5 = ctx.MkTactic("propagate-values"); // no differences compared with SKIP //Tactic ta6 = ctx.MkTactic("sat"); // make much more constrains such that Flatten takes VERY LONG //Tactic ta6b = ctx.MkTactic("sat-preprocess"); // does not work: some constrains are lost //Tactic ta7 = ctx.MkTactic("smt"); // does not work: all constraitns are lost using (Tactic tactic = ctx.AndThen(ta2, ctx.AndThen(ta1, ta5))) // using (Tactic tactic = ctx.AndThen(ta2, ta1)) { if (!undef) { using (Goal goal1 = ctx.MkGoal()) { goal1.Assert(solver.Assertions); using (ApplyResult ar = tactic.Apply(goal1)) { solver.Reset(); solver.Assert(ar.Subgoals[0].Formulas); } } } else { using (Goal goal1 = ctx.MkGoal()) { goal1.Assert(solver_U.Assertions); using (ApplyResult ar = tactic.Apply(goal1)) { solver_U.Reset(); solver_U.Assert(ar.Subgoals[0].Formulas); } } } } } } }
public override ApplyResult Apply(object[] args) { return(ApplyResult.From(_func((TArg)args[0], (TArg)args[1]))); }
/// <summary> /// Compute post from pre /// </summary> /// <param name="pre"></param> /// <returns></returns> public Expr MakePost(Expr pre) { KeyValuePair <Transition, Expr> postKey = new KeyValuePair <Transition, Expr>(this, pre); if (Transition.CachePost.ContainsKey(postKey)) { return(CachePost[postKey]); } Expr idx = Controller.Instance.Indices["i"]; ConcreteLocation l = this.Parent; List <BoolExpr> resets = new List <BoolExpr>(); resets.Add((BoolExpr)pre); // add prestate if (this.NextStates.Count > 0) { resets.Add((BoolExpr)this.ToTerm()); // discrete location post-state (e.g., loc'[i] = 2) } List <String> globalVariableResets = new List <String>(); // global variables not reset List <String> indexVariableResets = new List <String>(); // indexed variables of process moving that are not reset List <String> universalIndexVariableResets = new List <String>(); // universally quantified indexed variables that are reset if (this.Reset != null) { resets.Add((BoolExpr)this.Reset); globalVariableResets = Controller.Instance.Z3.findGlobalVariableResets(this.Reset); indexVariableResets = Controller.Instance.Z3.findIndexedVariableResets(this.Reset); } else { // global variable was not mentioned since reset is null: add it to the identity global variables (g' = g) globalVariableResets = Controller.Instance.Z3.findGlobalVariableResets(null); indexVariableResets = Controller.Instance.Z3.findIndexedVariableResets(null); } if (this.UGuard != null) // TODO: handle univerasl resets (assume none for now) { universalIndexVariableResets = Controller.Instance.Z3.findIndexedVariableResetsNeg(this.UGuard); } Expr resetAnd = null; // create conjunction of pre-state and post-state conditions if (resets.Count > 0) { resetAnd = Controller.Instance.Z3.MkAnd(resets.ToArray()); } Expr identity; if (l == null) { // TODO NEXT: GLOBAL INDEXED VARIABLE COULD CAUSE RESETS / "be the process moving" int i = 0; Expr gidx = null; foreach (var v in Controller.Instance.GlobalVariables) { if (Controller.Instance.Sys.Variables.Find( delegate(Variable gv) { return(gv.Name == v.Key); }).Type == Variable.VarType.index && Controller.Instance.Z3.findTerm(this.Reset, v.Value, true)) { gidx = v.Value; i++; } // TODO: need to refactor forall identity to allow multiple processes moving, for now throw exception if it happens if (i > 1) { throw new Exception("Error: too many global index variables used."); } } identity = Controller.Instance.Sys.forallIdentityPost(gidx, globalVariableResets, indexVariableResets, universalIndexVariableResets, this.UGuard, 0); // no process moves if no location } else { identity = Controller.Instance.Sys.forallIdentityPost(idx, globalVariableResets, indexVariableResets, universalIndexVariableResets, this.UGuard, 0); } resetAnd = Controller.Instance.Z3.MkAnd((BoolExpr)resetAnd, (BoolExpr)identity); resetAnd = Controller.Instance.Z3.copyExpr(resetAnd); // short circuit /* * if (this.Reset == null && Controller.Instance.Sys.Variables.Count == 0) * { * return resetAnd; * } */ // replace all function declarations with constants (e.g., (q i) => (qi), where qi is a constant, instead of a function) List <Expr> bound = new List <Expr>(); // TODO: use this.Parent.Parent.Parent, etc to access hybrid automata, holism, etc (will make generalizing to compositions easier) foreach (var v in Controller.Instance.Sys.HybridAutomata[0].Variables) { Expr varConst = Controller.Instance.Z3.MkConst(v.Name + "_" + "i", v.TypeSort); Expr varConstPost = Controller.Instance.Z3.MkConst(v.NamePrimed + "_" + "i", v.TypeSort); resetAnd = resetAnd.Substitute(Controller.Instance.Z3.MkApp(v.Value, idx), varConst); resetAnd = resetAnd.Substitute(Controller.Instance.Z3.MkApp(v.ValuePrimed, idx), varConstPost); bound.Add(varConst); } foreach (var v in Controller.Instance.GlobalVariables.Values) { bound.Add(v); } //Expr post = Controller.Instance.Z3.MkExists(new Expr[] { idx }, (BoolExpr)resetAnd); Expr post = Controller.Instance.Z3.MkExists(bound.ToArray(), (BoolExpr)resetAnd); // HACK: replace all location names with their values... foreach (var loc in Controller.Instance.Sys.HybridAutomata[0].Locations) { post = post.Substitute(loc.LabelExpr, loc.BitVectorExpr); } post = post.Substitute(Controller.Instance.IndexN, Controller.Instance.Z3.MkInt(Controller.Instance.IndexNValue)); Tactic tqe = Controller.Instance.Z3.Repeat(Controller.Instance.Z3.MkTactic("qe")); Goal g = Controller.Instance.Z3.MkGoal(); List <BoolExpr> remAss = Controller.Instance.Z3.Assumptions.FindAll(a => a.IsQuantifier); // todo: add type constraints to constant (q_i) instead of functions (q i) Controller.Instance.Z3.Assumptions.RemoveAll(a => a.IsQuantifier); // otherwise q.e. will fail g.Assert(Controller.Instance.Z3.Assumptions.ToArray()); Controller.Instance.Z3.Assumptions.AddRange(remAss); // add back g.Assert(Controller.Instance.Z3.AssumptionsUniversal.ToArray()); g.Assert((BoolExpr)post); g = g.Simplify(); ApplyResult ar = tqe.Apply(g); List <BoolExpr> postStates = new List <BoolExpr>(); foreach (var sg in ar.Subgoals) { postStates.AddRange(sg.Formulas); } postStates.RemoveAll(fa => Controller.Instance.Z3.Assumptions.Contains(fa)); postStates.RemoveAll(fa => Controller.Instance.Z3.AssumptionsUniversal.Contains(fa)); post = Controller.Instance.Z3.MkAnd(postStates.ToArray()); // HACK: replace all location values with their names... foreach (var loc in Controller.Instance.Sys.HybridAutomata[0].Locations) { post = post.Substitute(loc.BitVectorExpr, loc.LabelExpr); } // convert constants back to functions foreach (var v in Controller.Instance.Sys.HybridAutomata[0].Variables) { Expr varConst = Controller.Instance.Z3.MkConst(v.Name + "_" + "i", v.TypeSort); Expr varConstPost = Controller.Instance.Z3.MkConst(v.NamePrimed + "_" + "i", v.TypeSort); post = post.Substitute(varConst, Controller.Instance.Z3.MkApp(v.Value, idx)); post = post.Substitute(varConstPost, Controller.Instance.Z3.MkApp(v.ValuePrimed, idx)); } Controller.Instance.Z3.unprimeAllVariables(ref post); // unprime System.Console.WriteLine("POST: " + post.ToString()); // cache result CachePost.Add(postKey, post); return(post); }
// IManagedHotReloadAgent public async ValueTask ApplyUpdatesAsync(ImmutableArray <ManagedHotReloadUpdate> updates, CancellationToken cancellationToken) { if (!_sessionActive) { WriteToOutputWindow( new HotReloadLogMessage( HotReloadVerbosity.Detailed, $"{nameof(ApplyUpdatesAsync)} called but the session is not active.", Name, _variant ), default); return; } if (_deltaApplier is null) { WriteToOutputWindow( new HotReloadLogMessage( HotReloadVerbosity.Detailed, $"{nameof(ApplyUpdatesAsync)} called but we have no delta applier.", Name, _variant ), default); } if (!_sessionActive || _deltaApplier is null) { return; } try { WriteToOutputWindow( new HotReloadLogMessage( HotReloadVerbosity.Detailed, VSResources.HotReloadSendingUpdates, Name, _variant ), cancellationToken); ApplyResult result = await _deltaApplier.ApplyUpdatesAsync(updates, cancellationToken); if (result == ApplyResult.Success || result == ApplyResult.SuccessRefreshUI) { WriteToOutputWindow( new HotReloadLogMessage( HotReloadVerbosity.Detailed, VSResources.HotReloadApplyUpdatesSuccessful, Name, _variant ), cancellationToken); if (_callback is not null) { await _callback.OnAfterChangesAppliedAsync(cancellationToken); } } } catch (Exception ex) { string message = $"{ex.GetType()}: {ex.Message}"; WriteToOutputWindow( new HotReloadLogMessage( HotReloadVerbosity.Minimal, string.Format(VSResources.HotReloadApplyUpdatesFailure, message), Name, _variant, errorLevel: HotReloadDiagnosticErrorLevel.Error ), cancellationToken); throw; } }
public void Test_Z3_GoalsAndProbes() { using (Context ctx = new Context()) { Solver solver = ctx.MkSolver(); #region Print all Probes if (false) { for (int i = 0; i < ctx.ProbeNames.Length; ++i) { Console.WriteLine(i + ": probe " + ctx.ProbeNames[i] + "; " + ctx.ProbeDescription(ctx.ProbeNames[i])); } /* * 0: probe is-quasi-pb; true if the goal is quasi-pb. * 1: probe is-unbounded; true if the goal contains integer/real constants that do not have lower/upper bounds. * 2: probe is-pb; true if the goal is a pseudo-boolean problem. * 3: probe arith-max-deg; max polynomial total degree of an arithmetic atom. * 4: probe arith-avg-deg; avg polynomial total degree of an arithmetic atom. * 5: probe arith-max-bw; max coefficient bit width. * 6: probe arith-avg-bw; avg coefficient bit width. * 7: probe is-qflia; true if the goal is in QF_LIA. * 8: probe is-qfauflia; true if the goal is in QF_AUFLIA. * 9: probe is-qflra; true if the goal is in QF_LRA. * 10: probe is-qflira; true if the goal is in QF_LIRA. * 11: probe is-ilp; true if the goal is ILP. * 12: probe is-qfnia; true if the goal is in QF_NIA (quantifier-free nonlinear integer arithmetic). * 13: probe is-qfnra; true if the goal is in QF_NRA (quantifier-free nonlinear real arithmetic). * 14: probe is-nia; true if the goal is in NIA (nonlinear integer arithmetic, formula may have quantifiers). * 15: probe is-nra; true if the goal is in NRA (nonlinear real arithmetic, formula may have quantifiers). * 16: probe is-nira; true if the goal is in NIRA (nonlinear integer and real arithmetic, formula may have quantifiers). * 17: probe is-lia; true if the goal is in LIA (linear integer arithmetic, formula may have quantifiers). * 18: probe is-lra; true if the goal is in LRA (linear real arithmetic, formula may have quantifiers). * 19: probe is-lira; true if the goal is in LIRA (linear integer and real arithmetic, formula may have quantifiers). * 20: probe is-qfufnra; true if the goal is QF_UFNRA (quantifier-free nonlinear real arithmetic with other theories). * 21: probe memory; ammount of used memory in megabytes. * 22: probe depth; depth of the input goal. * 23: probe size; number of assertions in the given goal. * 24: probe num-exprs; number of expressions/terms in the given goal. * 25: probe num-consts; number of non Boolean constants in the given goal. * 26: probe num-bool-consts; number of Boolean constants in the given goal. * 27: probe num-arith-consts; number of arithmetic constants in the given goal. * 28: probe num-bv-consts; number of bit-vector constants in the given goal. * 29: probe produce-proofs; true if proof generation is enabled for the given goal. * 30: probe produce-model; true if model generation is enabled for the given goal. * 31: probe produce-unsat-cores; true if unsat-core generation is enabled for the given goal. * 32: probe has-patterns; true if the goal contains quantifiers with patterns. * 33: probe is-propositional; true if the goal is in propositional logic. * 34: probe is-qfbv; true if the goal is in QF_BV. * 35: probe is-qfaufbv; true if the goal is in QF_AUFBV. * 36: probe is-qfbv-eq; true if the goal is in a fragment of QF_BV which uses only =, extract, concat. * 37: probe is-qffp; true if the goal is in QF_FP (floats). * 38: probe is-qffpbv; true if the goal is in QF_FPBV (floats+bit-vectors). */ } #endregion Print all Probes #region Print all Tactics if (false) { for (int i = 0; i < ctx.TacticNames.Length; ++i) { Console.WriteLine(i + ": tactic " + ctx.TacticNames[i] + "; " + ctx.TacticDescription(ctx.TacticNames[i])); } /* * 0: tactic qfbv; builtin strategy for solving QF_BV problems. * 1: tactic qflia; builtin strategy for solving QF_LIA problems. * 2: tactic qflra; builtin strategy for solving QF_LRA problems. * 3: tactic qfnia; builtin strategy for solving QF_NIA problems. * 4: tactic qfnra; builtin strategy for solving QF_NRA problems. * 5: tactic qfufnra; builtin strategy for solving QF_UNFRA problems. * 6: tactic add-bounds; add bounds to unbounded variables(under approximation). * 7: tactic card2bv; convert pseudo-boolean constraints to bit - vectors. * 8: tactic degree-shift; try to reduce degree of polynomials(remark: :mul2power simplification is automatically applied). * 9: tactic diff-neq; specialized solver for integer arithmetic problems that contain only atoms of the form(<= k x)(<= x k) and(not(= (-x y) k)), where x and y are constants and k is a numberal, and all constants are bounded. * 10: tactic elim01; eliminate 0 - 1 integer variables, replace them by Booleans. * 11: tactic eq2bv; convert integer variables used as finite domain elements to bit-vectors. * 12: tactic factor; polynomial factorization. * 13: tactic fix-dl - var; if goal is in the difference logic fragment, then fix the variable with the most number of occurrences at 0. * 14: tactic fm; eliminate variables using fourier - motzkin elimination. * 15: tactic lia2card; introduce cardinality constraints from 0 - 1 integer. * 16: tactic lia2pb; convert bounded integer variables into a sequence of 0 - 1 variables. * 17: tactic nla2bv; convert a nonlinear arithmetic problem into a bit-vector problem, in most cases the resultant goal is an under approximation and is useul for finding models. * 18: tactic normalize - bounds; replace a variable x with lower bound k <= x with x' = x - k. * 19: tactic pb2bv; convert pseudo-boolean constraints to bit - vectors. * 20: tactic propagate-ineqs; propagate ineqs/ bounds, remove subsumed inequalities. * 21: tactic purify-arith; eliminate unnecessary operators: -, /, div, mod, rem, is- int, to - int, ^, root - objects. * 22: tactic recover-01; recover 0 - 1 variables hidden as Boolean variables. * 23: tactic blast-term-ite; blast term if-then -else by hoisting them. * 24: tactic cofactor-term-ite; eliminate term if-the -else using cofactors. * 25: tactic ctx-simplify; apply contextual simplification rules. * 26: tactic der; destructive equality resolution. * 27: tactic distribute-forall; distribute forall over conjunctions. * 28: tactic elim-term-ite; eliminate term if-then -else by adding fresh auxiliary declarations. * 29: tactic elim-uncnstr; eliminate application containing unconstrained variables. * 30: tactic snf; put goal in skolem normal form. * 31: tactic nnf; put goal in negation normal form. * 32: tactic occf; put goal in one constraint per clause normal form (notes: fails if proof generation is enabled; only clauses are considered). * 33: tactic pb-preprocess; pre - process pseudo - Boolean constraints a la Davis Putnam. * 34: tactic propagate-values; propagate constants. * 35: tactic reduce-args; reduce the number of arguments of function applications, when for all occurrences of a function f the i - th is a value. * 36: tactic simplify; apply simplification rules. * 37: tactic elim-and; convert(and a b) into(not(or(not a)(not b))). * 38: tactic solve-eqs; eliminate variables by solving equations. * 39: tactic split-clause; split a clause in many subgoals. * 40: tactic symmetry-reduce; apply symmetry reduction. * 41: tactic tseitin-cnf; convert goal into CNF using tseitin - like encoding(note: quantifiers are ignored). * 42: tactic tseitin-cnf-core; convert goal into CNF using tseitin - like encoding(note: quantifiers are ignored).This tactic does not apply required simplifications to the input goal like the tseitin - cnf tactic. * 43: tactic skip; do nothing tactic. * 44: tactic fail; always fail tactic. * 45: tactic fail-if-undecided; fail if goal is undecided. * 46: tactic bit-blast; reduce bit-vector expressions into SAT. * 47: tactic bv1-blast; reduce bit-vector expressions into bit - vectors of size 1(notes: only equality, extract and concat are supported). * 48: tactic reduce-bv-size; try to reduce bit - vector sizes using inequalities. * 49: tactic max-bv-sharing; use heuristics to maximize the sharing of bit-vector expressions such as adders and multipliers. * 50: tactic nlsat; (try to) solve goal using a nonlinear arithmetic solver. * 51: tactic qfnra-nlsat; builtin strategy for solving QF_NRA problems using only nlsat. * 52: tactic sat; (try to) solve goal using a SAT solver. * 53: tactic sat-preprocess; Apply SAT solver preprocessing procedures(bounded resolution, Boolean constant propagation, 2 - SAT, subsumption, subsumption resolution). * 54: tactic ctx-solver-simplify; apply solver-based contextual simplification rules. * 55: tactic smt; apply a SAT based SMT solver. * 56: tactic unit-subsume-simplify; unit subsumption simplification. * 57: tactic aig; simplify Boolean structure using AIGs. * 58: tactic horn; apply tactic for horn clauses. * 59: tactic horn-simplify; simplify horn clauses. * 60: tactic qe-light; apply light-weight quantifier elimination. * 61: tactic qe-sat; check satisfiability of quantified formulas using quantifier elimination. * 62: tactic qe; apply quantifier elimination. * 63: tactic vsubst; checks satsifiability of quantifier-free non - linear constraints using virtual substitution. * 64: tactic nl-purify; Decompose goal into pure NL-sat formula and formula over other theories. * 65: tactic macro-finder; Identifies and applies macros. * 66: tactic quasi-macros; Identifies and applies quasi-macros. * 67: tactic bv; builtin strategy for solving BV problems(with quantifiers). * 68: tactic ufbv; builtin strategy for solving UFBV problems(with quantifiers). * 69: tactic fpa2bv; convert floating point numbers to bit-vectors. * 70: tactic qffp; (try to) solve goal using the tactic for QF_FP. * 71: tactic qffpbv; (try to) solve goal using the tactic for QF_FPBV(floats+bit-vectors). * 72: tactic qfbv-sls; (try to) solve using stochastic local search for QF_BV. * 73: tactic subpaving; tactic for testing subpaving module. */ } #endregion Print all Tactics BitVecExpr rax = ctx.MkBVConst("rax", 64); BitVecExpr rbx = ctx.MkBVConst("rbx", 64); BoolExpr a1 = ctx.MkEq(rax, ctx.MkBV(0, 64)); BoolExpr a2 = ctx.MkEq(rbx, rax); Goal goal1 = ctx.MkGoal(true, false, false); goal1.Assert(a1, a2); Console.WriteLine("goal1=" + goal1 + "; inconsistent=" + goal1.Inconsistent); Tactic tactic1 = ctx.MkTactic("simplify"); // Console.WriteLine("tactic1=" + tactic1.ToString()); ApplyResult applyResult = tactic1.Apply(goal1); Console.WriteLine("applyResult=" + applyResult.ToString() + "; nSubGoals=" + applyResult.NumSubgoals); // Console.WriteLine("AsBoolExpr=" + goal1.AsBoolExpr()); #region Probe Tests if (false) { Probe probe1 = ctx.MkProbe("is-qfbv"); double d = probe1.Apply(goal1); Console.WriteLine("d=" + d); } #endregion Probe Tests } }