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;
}
