public Transition(ConcreteLocation p) { this.Parent = p; // todo next: switch if not int type: , Controller.Instance.IndexType Expr hidxinner = Controller.Instance.Z3.MkIntConst("h"); this.TransitionTermGlobal = (BoolExpr)this.makeTransitionTerm(null, hidxinner, null); // no local vars this.TransitionTerm = (BoolExpr)this.makeTransitionTerm(this.Parent, hidxinner, null); // with local vars }
private static BoolExpr MakeRuleRegResult(Rn selectedReg, IList <Rn> regs, BitVecExpr newState, int lineNumber, Context ctx) { BoolExpr[] r = new BoolExpr[regs.Count]; for (int i = 0; i < regs.Count; ++i) { Rn reg1 = regs[i]; r[i] = ctx.MkEq(GetReg(reg1, lineNumber, ctx), (selectedReg == reg1) ? newState : GetReg(reg1, lineNumber - 1, ctx)); } return(ctx.MkAnd(r)); }
internal override void AddFact( BoolExpr <DomainConstraint <BoolLiteral, Constant> > fact) { base.AddFact(fact); this._kbExpression = (BoolExpr <DomainConstraint <BoolLiteral, Constant> >) new AndExpr <DomainConstraint <BoolLiteral, Constant> >(new BoolExpr <DomainConstraint <BoolLiteral, Constant> >[2] { this._kbExpression, fact }); }
internal static BoolExpr <DomainConstraint <BoolLiteral, Constant> > ToDnf( BoolExpr <DomainConstraint <BoolLiteral, Constant> > expr, bool isNnf) { if (!isNnf) { expr = FragmentQueryKBChaseSupport.Normalizer.ToNnfAndSplitRange(expr); } return(expr.Accept <BoolExpr <DomainConstraint <BoolLiteral, Constant> > >((Visitor <DomainConstraint <BoolLiteral, Constant>, BoolExpr <DomainConstraint <BoolLiteral, Constant> > >)FragmentQueryKBChaseSupport.Normalizer.DnfTreeVisitor.Instance)); }
/// <summary> Constructor </summary> public StateUpdate(string prevKey, string nextKey, Tools tools) { this._branch_Condition = null; this._prevKey_Regular = prevKey; this._prevKey_Branch = null; this._nextKey = nextKey; this._tools = tools; this._ctx = new Context(tools.Settings); // housekeeping in Dispose(); this.Empty = true; }
public static (BitVecExpr result, BoolExpr cf, BoolExpr of, BoolExpr af) Addition( BitVecExpr a, BitVecExpr b, Context ctx) { BitVecExpr result = ctx.MkBVAdd(a, b); BoolExpr cf = ToolsFlags.Create_CF_Add(a, b, a.SortSize, ctx); BoolExpr of = ToolsFlags.Create_OF_Add(a, b, a.SortSize, ctx); BoolExpr af = ToolsFlags.Create_AF_Add(a, b, ctx); return(result : result, cf : cf, of : of, af : af); }
public BoolExpr Conflict(Context ctx, params BoolExpr[] packs) { BoolExpr q = ctx.MkFalse(); foreach (BoolExpr p in packs) { q = ctx.MkOr(q, ctx.MkNot(p)); } return(q); }
private static IReadOnlyList <BoolExpr> CheckSatForMethod(MethodInfo method, Context context) { var result = method.Invoke(null, new object[] { context }); return(result switch { IEnumerable <BoolExpr> boolExpressions => boolExpressions.ToList(), BoolExpr boolExpr => new[] { boolExpr }, _ => throw new InvalidOperationException("Unsupported result type"), });
public void Run() { using (Context ctx = new Context()) { BoolExpr e = ctx.MkTrue(); Solver s = ctx.MkSolver(); s.Assert(e); Console.WriteLine(s.Check()); } }
public bool IsTransformAcceptedByRestriction() { Z3Body body = Z3Body.MkZ3Const(); Z3Body transformedBody = this.Transform.Transform(body); BoolExpr expr = this.Restriction.Evaluate(transformedBody); SolverCheckResult checkResult = Z3AnalysisInterface.CheckStatus(expr); return(checkResult.Status != Status.UNSATISFIABLE); }
//TODO consider creating a special StateUpdateMerge class /// <summary>Constructor for merging. prevKey_Regular is the key for the regular continue for the provided branchCondition</summary> public StateUpdate(BoolExpr branchCondition, string prevKey_Regular, string prevKey_Branch, string nextKey, Tools tools) { this._ctx = new Context(tools.Settings); // housekeeping in Dispose(); this._branch_Condition = branchCondition.Translate(this._ctx) as BoolExpr; this._prevKey_Regular = prevKey_Regular; this._prevKey_Branch = prevKey_Branch; this._nextKey = nextKey; this._tools = tools; this.Empty = false; }
public void Set(Flags flag, BoolExpr value, BoolExpr undef) { this.Empty = false; lock (this._ctxLock) { Context ctx = this._ctx; value = value?.Translate(ctx) as BoolExpr; undef = undef?.Translate(ctx) as BoolExpr; BoolExpr key = Tools.Create_Key(flag, this.NextKey, ctx); BoolExpr value_Constraint; { if (value == null) { value_Constraint = ctx.MkEq(key, Tools.Create_Flag_Key_Fresh(flag, this._tools.Rand, ctx)); } else if (value.IsTrue) { value_Constraint = key; } else if (value.IsFalse) { value_Constraint = ctx.MkNot(key); } else { value_Constraint = ctx.MkEq(key, value); } } BoolExpr undef_Constraint; { if (undef == null) { undef_Constraint = ctx.MkEq(key, Tools.Create_Flag_Key_Fresh(flag, this._tools.Rand, ctx)); } else if (undef.IsTrue) { undef_Constraint = key; } else if (undef.IsFalse) { undef_Constraint = ctx.MkNot(key); } else { undef_Constraint = ctx.MkEq(key, undef); } } this.Set_Private(flag, value_Constraint, false); this.Set_Private(flag, undef_Constraint, true); } }
public static (BitVecExpr result, BoolExpr cf, BoolExpr of, BoolExpr af) Substract( BitVecExpr a, BitVecExpr b, Context ctx) { uint nBits = a.SortSize; BitVecExpr result = ctx.MkBVSub(a, b); BoolExpr cf = ToolsFlags.Create_CF_Sub(a, b, nBits, ctx); BoolExpr of = ToolsFlags.Create_OF_Sub(a, b, nBits, ctx); BoolExpr af = ToolsFlags.Create_AF_Sub(a, b, ctx); return(result : result, cf : cf, of : of, af : af); }
private BoolExpression(bool isTrue) { if (isTrue) { this.m_tree = (BoolExpr <DomainConstraint <BoolLiteral, Constant> >)TrueExpr <DomainConstraint <BoolLiteral, Constant> > .Value; } else { this.m_tree = (BoolExpr <DomainConstraint <BoolLiteral, Constant> >)FalseExpr <DomainConstraint <BoolLiteral, Constant> > .Value; } }
public override void VisitOr(BoolExpr e) { for (var i = 0; i < e.Operands.Count(); i++) { Visit(e.Operands.ElementAt(i)); if (i + 1 != e.Operands.Count()) { _sb.Append(" "); } } }
public override void VisitAnd(BoolExpr e) { for (var i = 0; i < e.Operands.Count(); i++) { Visit(e.Operands.ElementAt(i)); if (i + 1 != e.Operands.Count()) { _sb.Append(Environment.NewLine); } } }
public static void Run() { Z3Point3D constPoint = Z3Point3D.MkZ3Const("const"); // ("const X", "const Y", "const Z") Z3Point3D normalized = new Z3Point3D(); ArithExpr higherCoord = Z3Math.Max( Z3Math.Max( Z3Math.Abs(constPoint.X), Z3Math.Abs(constPoint.Y)), Z3Math.Abs(constPoint.Z)); normalized.X = Z3.Context.MkDiv(constPoint.X, constPoint.Y); normalized.Y = Z3Math.One;//Z3.Context.MkDiv(constPoint.Y, higherCoord); normalized.Z = Z3.Context.MkDiv(constPoint.Z, constPoint.Y); normalized.X = CalcApproximateCoordFromManhattanToEuclidianSystem(normalized.X, normalized.Y, normalized.Z); normalized.Y = CalcApproximateCoordFromManhattanToEuclidianSystem(normalized.Y, normalized.X, normalized.Z); normalized.Z = CalcApproximateCoordFromManhattanToEuclidianSystem(normalized.Z, normalized.Y, normalized.X); Z3Point3D up = Z3Point3D.DirectionPoint(Direction.Up); // (0, 1, 0) Z3Point3D distVec = normalized - up; ArithExpr distance = Max( Abs(CalcApproximateCoordFromManhattanToEuclidianSystem(distVec.X, distVec.Y, distVec.Z)), Abs(CalcApproximateCoordFromManhattanToEuclidianSystem(distVec.Y, distVec.X, distVec.Z)), Abs(CalcApproximateCoordFromManhattanToEuclidianSystem(distVec.Z, distVec.Y, distVec.X))); BoolExpr expr = Z3.Context.MkLt(distance, Z3.Context.MkReal(1, 2)); Solver solver = Z3.Context.MkSolver(); solver.Assert(expr); Status status = solver.Check(); Statistics stats = solver.Statistics; switch (status) { case Status.UNKNOWN: Console.WriteLine("Solver check for witness returned Status.UNKNOWN because: " + solver.ReasonUnknown); throw new ArgumentException("Test Failed Expception"); case Status.UNSATISFIABLE: Console.WriteLine("There is no valid witness for " + expr); throw new ArgumentException("Test Failed Expception"); case Status.SATISFIABLE: Console.WriteLine("OK, model: " + solver.Model); break; } }
internal override void AddFact( BoolExpr <DomainConstraint <BoolLiteral, Constant> > fact) { base.AddFact(fact); this._kbSize += fact.CountTerms(); if (this._implications == null) { return; } this.CacheFact(fact); }
private void AssertBranchInfoToSolver(bool addUndef = true) { foreach (BranchInfo e in this.BranchInfoStore.Values) { BoolExpr expr = e.GetData(this._ctx); this.Solver.Assert(expr); if (addUndef) { this.Solver_U.Assert(expr); } } }
public void FinalResult(Z3Body input, out Z3Body transformed, out BoolExpr evaluation) { transformed = input; evaluation = Z3Math.True; foreach (var step in this.Steps) { var pose = step.Pose; transformed = pose.Transform.Transform(transformed); evaluation = Z3.Context.MkAnd(evaluation, pose.Restriction.Evaluate(transformed)); } }
public BoolExpr GetData(Context ctx) { if (false) { BoolExpr bc = this.BranchCondition.Translate(ctx) as BoolExpr; return(this.BranchTaken ? bc : ctx.MkNot(bc)); } else { return(this.BranchTaken ? this.BranchCondition : ctx.MkNot(this.BranchCondition)); } }
public void Run() { Dictionary <string, string> cfg = new Dictionary <string, string>() { { "AUTO_CONFIG", "true" } }; using (Context ctx = new Context(cfg)) { RealExpr d = ctx.MkRealConst("d"); RealExpr a = ctx.MkRealConst("a"); RealExpr t = ctx.MkRealConst("t"); RealExpr v_i = ctx.MkRealConst("v_i"); RealExpr v_f = ctx.MkRealConst("v_f"); BoolExpr[] equations = new BoolExpr[] { ctx.MkEq(d, ctx.MkAdd(ctx.MkMul(v_i, t), ctx.MkDiv(ctx.MkMul(a, ctx.MkPower(t, ctx.MkReal(2))), ctx.MkReal(2)))), ctx.MkEq(v_f, ctx.MkAdd(v_i, ctx.MkMul(a, t))) }; Console.WriteLine("Kinematic equations: "); foreach (BoolExpr e in equations) { Console.WriteLine(e); } BoolExpr[] problem = new BoolExpr[] { ctx.MkEq(v_i, ctx.MkReal(30)), ctx.MkEq(v_f, ctx.MkReal(0)), ctx.MkEq(a, ctx.MkReal(-8)) }; Console.WriteLine("Problem: "); foreach (BoolExpr p in problem) { Console.WriteLine(p); } Solver s = ctx.MkSolver(); s.Assert(equations); s.Assert(problem); if (s.Check() != Status.SATISFIABLE) { throw new Exception("BUG"); } Console.WriteLine("Solution: "); Console.WriteLine(s.Model); } }
public void UnsatCoreAndProofExample(Context ctx) { Console.WriteLine("UnsatCoreAndProofExample"); Solver solver = ctx.MkSolver(); BoolExpr pa = ctx.MkBoolConst("PredA"); BoolExpr pb = ctx.MkBoolConst("PredB"); BoolExpr pc = ctx.MkBoolConst("PredC"); BoolExpr pd = ctx.MkBoolConst("PredD"); BoolExpr p1 = ctx.MkBoolConst("P1"); BoolExpr p2 = ctx.MkBoolConst("P2"); BoolExpr p3 = ctx.MkBoolConst("P3"); BoolExpr p4 = ctx.MkBoolConst("P4"); BoolExpr t = ctx.MkBool(true); //BoolExpr[] assumptions = new BoolExpr[] { ctx.MkNot(p1), ctx.MkNot(p2), ctx.MkNot(p3), ctx.MkNot(p4) }; //var assumptions = new List<BoolExpr> { ctx.MkNot(p1), ctx.MkNot(p2), ctx.MkNot(p3), ctx.MkNot(p4) }; var assumptions = new List <BoolExpr> { ctx.MkNot(p2) }; BoolExpr f1 = ctx.MkAnd(new BoolExpr[] { pa, pb, pc }); BoolExpr f2 = ctx.MkAnd(new BoolExpr[] { pa, ctx.MkNot(pb), pc }); BoolExpr f3 = ctx.MkOr(ctx.MkNot(pa), ctx.MkNot(pc)); BoolExpr f4 = pd; solver.AssertAndTrack(ctx.MkAnd(f1, p1), ctx.MkAnd(f1, p1)); solver.AssertAndTrack(ctx.MkOr(f2, p2), ctx.MkOr(f2, p2)); solver.AssertAndTrack(ctx.MkOr(f3, p3), ctx.MkOr(f3, p3)); solver.AssertAndTrack(ctx.MkOr(f4, p4), ctx.MkOr(f4, p4)); //var statement = ctx.MkAnd(p1, ctx.MkNot(p1)); //solver.AssertAndTrack(statement, statement); //solver.AssertAndTrack(ctx.MkAnd(p1, ctx.MkNot(p1)), p1); //solver.AssertAndTrack(ctx.MkAnd(p1, ctx.MkNot(p1)), ctx.MkAnd(p1, ctx.MkNot(p1))); //solver.Assert(ctx.MkAnd(p1, ctx.MkNot(p1))); Status result = solver.Check(); if (result == Status.UNSATISFIABLE) { Console.WriteLine("unsat"); //Console.WriteLine("proof: {0}", solver.Proof); Console.WriteLine("core: "); foreach (Expr c in solver.UnsatCore) { Console.WriteLine("{0}", c); } } if (result == Status.SATISFIABLE) { Console.WriteLine("sat"); //Console.WriteLine(String.Join(" ", solver.Units.ToList())); } }
public void Run() { Dictionary <string, string> cfg = new Dictionary <string, string>() { { "AUTO_CONFIG", "true" } }; using (Context ctx = new Context(cfg)) { IntExpr[] X = new IntExpr[5]; for (uint i = 0; i < 5; i++) { X[i] = ctx.MkIntConst(string.Format("x_{0}", i)); } RealExpr[] Y = new RealExpr[5]; for (uint i = 0; i < 5; i++) { Y[i] = ctx.MkRealConst(string.Format("y_{0}", i)); } BoolExpr[] P = new BoolExpr[5]; for (uint i = 0; i < 5; i++) { P[i] = ctx.MkBoolConst(string.Format("p_{0}", i)); } foreach (Expr x in X) { Console.WriteLine(x); } foreach (Expr x in Y) { Console.WriteLine(x); } foreach (Expr x in P) { Console.WriteLine(x); } foreach (ArithExpr y in Y) { Console.WriteLine(ctx.MkPower(y, ctx.MkReal(2))); } ArithExpr[] Yp = new ArithExpr[Y.Length]; for (uint i = 0; i < Y.Length; i++) { Yp[i] = ctx.MkPower(Y[i], ctx.MkReal(2)); } Console.WriteLine(ctx.MkAdd(Yp)); } }
/// <summary> Constructor </summary> public StateUpdate(string prevKey, string nextKey, Tools tools) { Contract.Requires(tools != null); this.branch_Condition_ = null; this.prevKey_Regular_ = prevKey; this.prevKey_Branch_ = null; this.nextKey_ = nextKey; this.tools_ = tools; this.ctx_ = new Context(tools.ContextSettings); // housekeeping in Dispose(); this.Empty = true; }
public RotateDirectionRestriction(JointType jointType, Z3Point3D startPoint, int degrees, Direction direction) : base(body => { ArithExpr currentValue; var targetValue = 0.0; var directionSign = 1.0; var currentPoint = body.Joints[jointType]; CalcZ3CurrentAndTargetValue(currentPoint, startPoint, degrees, direction, out currentValue, out targetValue, out directionSign); BoolExpr expr = Z3.Context.MkTrue(); switch (direction) { case Direction.Right: case Direction.Up: case Direction.Front: expr = Z3.Context.MkGt(currentValue, Z3Math.Real(targetValue)); break; case Direction.Left: case Direction.Down: case Direction.Back: expr = Z3.Context.MkLt(currentValue, Z3Math.Real(targetValue)); break; } return(expr); }, body => { double currentValue; var targetValue = 0.0; var directionSign = 1.0; var currentPoint = body.Vectors[jointType]; var startPointConverted = new Point3D( startPoint.GetXValue(), startPoint.GetYValue(), startPoint.GetZValue()); CalcCurrentAndTargetValue(currentPoint, startPointConverted, degrees, direction, out currentValue, out targetValue, out directionSign); var percentage = PercentageCalculator.calc( -1 * directionSign, targetValue, currentValue); return(percentage); }, jointType) { this.JointType = jointType; this.Direction = direction; this.Degrees = degrees; }
public AlwaysExpression(string line) : base(line) { line = line.Trim().Remove(0, "always".Length); List <Token> tokens; List <string> tokenValues; var expression = LogicFormulaParser.Parse(line, out tokens, out tokenValues); Conditions = LogicFormulaParser.GetConditions(line); AdeSystem.Fluents.AddRange(tokens.Select(i => i.Value)); AdeSystem.Fluents = AdeSystem.Fluents.Distinct().ToList(); Expression = expression; }
public static (BitVecExpr result, BoolExpr cf) ShiftOperations( Mnemonic op, BitVecExpr value, BitVecExpr nShifts, BoolExpr carryIn, string prevKey, Context ctx) { Contract.Requires(value != null); Contract.Requires(nShifts != null); Contract.Requires(ctx != null); Contract.Requires(nShifts.SortSize == 8); //Console.WriteLine("ShiftOperations:nShifts=" + nShifts); uint nBits = value.SortSize; BitVecExpr carryBV = ctx.MkITE(carryIn, ctx.MkBV(1, 1), ctx.MkBV(0, 1)) as BitVecExpr; BitVecExpr nShifts65 = ctx.MkZeroExt(nBits + 1 - 8, nShifts); BitVecExpr value_out; BoolExpr bitValue; switch (op) { case Mnemonic.RCR: { BitVecExpr valueWithCarry = ctx.MkConcat(carryBV, value); BitVecExpr rotatedValue = ctx.MkBVRotateRight(valueWithCarry, nShifts65); value_out = ctx.MkExtract(nBits - 1, 0, rotatedValue); bitValue = ToolsZ3.GetBit(rotatedValue, nBits, ctx.MkBV(1, 1), ctx); } break; case Mnemonic.RCL: { BitVecExpr valueWithCary = ctx.MkConcat(value, carryBV); BitVecExpr rotatedValue = ctx.MkBVRotateLeft(valueWithCary, nShifts65); value_out = ctx.MkExtract(nBits, 1, rotatedValue); bitValue = ToolsZ3.GetBit(rotatedValue, 0, ctx.MkBV(1, 1), ctx); } break; default: throw new Exception(); } BoolExpr cf_current = Tools.Create_Key(Flags.CF, prevKey, ctx); BoolExpr cf = ctx.MkITE(ctx.MkEq(nShifts, ctx.MkBV(0, 8)), cf_current, bitValue) as BoolExpr; //Console.WriteLine("ShiftOperations:cf=" + cf); return(result : value_out, cf : cf); }
/// <summary> /// Double negation /// </summary> /// <param name="node"></param> /// <returns></returns> public static bool DN(ref BoolExpr node) { if (node.Op == OperatorType.NOT && node.Right.Op == OperatorType.NOT) { var oldNode = node; node = node.Right.Right; node.Parent = oldNode.Parent; UpdateParent(node, oldNode); return(true); } return(false); }
private static Model?Check(Context ctx, BoolExpr cond) { Solver solver = ctx.MkSolver(); solver.Assert(cond); Status q = solver.Check(); if (q != Status.SATISFIABLE) { return(null); } return(solver.Model); }
// <-- Name // | FN Name TupleType // | BOOL_LITERAL // | INT_LITERAL // | STRING_LITERAL // | LPAREN (Expression)? RPAREN private IUnboundExpr PrimaryExpr() { IUnboundExpr expression; if (CurrentIs(TokenType.Name)) { var name = Consume(); expression = new NameExpr(name.Position, name.StringValue, TypeArgs()); } else if (CurrentIs(TokenType.Fn)) expression = FuncExpr(); else if (CurrentIs(TokenType.Bool)) expression = new BoolExpr(Consume(TokenType.Bool)); else if (CurrentIs(TokenType.Int)) expression = new IntExpr(Consume(TokenType.Int)); else if (CurrentIs(TokenType.String)) expression = new StringExpr(Consume(TokenType.String)); else if (CurrentIs(TokenType.LeftParen)) { Token leftParen = Consume(TokenType.LeftParen); if (CurrentIs(TokenType.RightParen)) { // () -> unit expression = new UnitExpr(leftParen.Position); } else if (CurrentIs(TokenType.Operator)) { // ( OPERATOR ) -> an operator in prefix form Token op = Consume(TokenType.Operator); expression = new NameExpr(op.Position, op.StringValue); } else { // anything else is a regular parenthesized expression expression = Expression(); } Consume(TokenType.RightParen); } else expression = null; return expression; }
public override Null Visit(BoolExpr node) { context = null; node.computedType = new PrimType { kind = PrimKind.Bool }; return null; }