public void Run()
{
Dictionary <string, string> cfg = new Dictionary <string, string>()
{
{ "AUTO_CONFIG", "true" },
{ "MODEL", "true" }
};
using (Context ctx = new Context(cfg))
{
RealExpr x = ctx.MkRealConst("x");
RealExpr y = ctx.MkRealConst("y");
Solver s = ctx.MkSolver();
s.Assert(ctx.MkAnd(ctx.MkEq(ctx.MkAdd(x, ctx.MkReal("10000000000000000000000")), y),
ctx.MkGt(y, ctx.MkReal("20000000000000000"))));
s.Check();
Console.WriteLine(s.Model);
Expr q = ctx.MkAdd(ctx.MkPower(ctx.MkReal(2), ctx.MkReal(1, 2)),
ctx.MkPower(ctx.MkReal(3), ctx.MkReal(1, 2)));
Console.WriteLine(q);
AlgebraicNum an = (AlgebraicNum)q.Simplify();
Console.WriteLine(an);
Console.WriteLine("[" + an.ToLower(10) + "," + an.ToUpper(10) + "]");
Console.WriteLine(an.ToDecimal(10));
}
}
public void Run()
{
using (Context ctx = new Context())
{
RealExpr x = ctx.MkRealConst("x");
RealExpr y = ctx.MkRealConst("y");
Console.WriteLine(ctx.MkEq(x, y));
Console.WriteLine(ctx.MkNot(ctx.MkEq(x, y)));
BoolExpr f1 = ctx.MkEq(x, y);
BoolExpr f2 = ctx.MkEq(x, y);
BoolExpr f3 = ctx.MkNot(ctx.MkEq(x, y));
Console.WriteLine(f1 == f2);
Console.WriteLine(f2 == f1);
Console.WriteLine(f1 == f3);
FuncDecl f = ctx.MkFuncDecl("f", new Sort[] { ctx.IntSort, ctx.RealSort }, ctx.IntSort);
IntExpr a = ctx.MkIntConst("a");
IntExpr b = ctx.MkIntConst("b");
Console.WriteLine(ctx.MkGt((IntExpr)f[a, ctx.MkInt2Real(a)], b));
Console.WriteLine(f.Range);
Console.WriteLine(f.Arity);
Console.WriteLine(f.Domain[0]);
Console.WriteLine(f.Domain[1]);
Console.WriteLine(f.DeclKind == Z3_decl_kind.Z3_OP_UNINTERPRETED);
Console.WriteLine(ctx.MkAdd(a, b).FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ADD);
Console.WriteLine(ctx.MkAdd(a, b).FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_UNINTERPRETED);
}
}
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")));
Console.WriteLine(t[g]);
t = ctx.Repeat(ctx.OrElse(ctx.MkTactic("split-clause"), ctx.MkTactic("skip")), 1);
Console.WriteLine(t[g]);
t = ctx.Then(ctx.Repeat(ctx.OrElse(ctx.MkTactic("split-clause"), ctx.MkTactic("skip"))), ctx.MkTactic("solve-eqs"));
Console.WriteLine(t[g]);
}
}
public void Run()
{
using (Context ctx = new Context())
{
RealExpr x = ctx.MkRealConst("x");
RealExpr y = ctx.MkRealConst("y");
Solver s = ctx.Then(ctx.MkTactic("simplify"), ctx.MkTactic("nlsat")).Solver;
s.Assert(ctx.MkEq(ctx.MkPower(x, ctx.MkReal(2)), ctx.MkReal(2)),
ctx.MkEq(ctx.MkPower(y, ctx.MkReal(3)), ctx.MkAdd(x, ctx.MkReal(1))));
Console.WriteLine(s.Check());
ctx.UpdateParamValue(":pp-decimal", "true");
Console.WriteLine(s.Model);
Console.WriteLine(s.Statistics);
foreach (string k in s.Statistics.Keys)
{
Console.WriteLine(k);
}
Console.WriteLine("NLSAT stages: " + s.Statistics["nlsat stages"].Value);
Console.WriteLine("NLSAT propagations: " + s.Statistics["nlsat propagations"].Value);
}
}
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");
RatNum zero = ctx.MkReal(0);
RatNum two = ctx.MkReal(2);
Goal g = ctx.MkGoal();
g.Assert(ctx.MkGt(x, zero));
g.Assert(ctx.MkGt(y, zero));
g.Assert(ctx.MkEq(x, ctx.MkAdd(y, two)));
Console.WriteLine(g);
Tactic t1 = ctx.MkTactic("simplify");
Tactic t2 = ctx.MkTactic("solve-eqs");
Tactic t = ctx.AndThen(t1, t2);
Console.WriteLine(t[g]);
}
}
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");
Params ps = ctx.MkParams();
ps.Add(":som", true);
Expr q = ctx.MkPower(ctx.MkAdd(x, y), ctx.MkReal(3));
q = q.Simplify(ps);
Console.WriteLine(ps);
Console.WriteLine(q);
ps = ctx.MkParams();
ps.Add(":mul-to-power", true);
q = q.Simplify(ps);
Console.WriteLine(ps);
Console.WriteLine(q);
}
}
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 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");
RatNum zero = ctx.MkReal(0);
RatNum two = ctx.MkReal(2);
Goal g = ctx.MkGoal();
g.Assert(ctx.MkGe(ctx.MkSub(ctx.MkPower(x, two), ctx.MkPower(y, two)), zero));
Probe p = ctx.MkProbe("num-consts");
Probe p2 = ctx.Gt(p, ctx.Const(2));
Tactic t = ctx.Cond(p2, ctx.MkTactic("simplify"), ctx.MkTactic("factor"));
Console.WriteLine(t[g]);
g = ctx.MkGoal();
g.Assert(ctx.MkGe(ctx.MkAdd(x, x, y, z), zero));
g.Assert(ctx.MkGe(ctx.MkSub(ctx.MkPower(x, two), ctx.MkPower(y, two)), zero));
Console.WriteLine(t[g]);
}
}
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);
}
}
}
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");
Solver s = ctx.MkSolver();
s.Assert(ctx.MkGt(x, ctx.MkReal(1)),
ctx.MkGt(y, ctx.MkReal(1)),
ctx.MkOr(ctx.MkGt(ctx.MkAdd(x, y), ctx.MkReal(1)),
ctx.MkLt(ctx.MkSub(x, y), ctx.MkReal(2))));
Console.WriteLine("asserted constraints: ");
foreach (var c in s.Assertions)
{
Console.WriteLine(c);
}
Console.WriteLine(s.Check());
Console.WriteLine(s.Statistics);
Console.WriteLine("stats for last check: ");
foreach (Statistics.Entry e in s.Statistics.Entries)
{
Console.WriteLine(e);
}
}
}
public void Run()
{
Dictionary <string, string> settings = new Dictionary <string, string>()
{
{ "AUTO_CONFIG", "true" }, { "MODEL", "true" }
};
using (Context ctx = new Context(settings))
{
IntExpr a = ctx.MkIntConst("a");
IntExpr b = ctx.MkIntConst("b");
IntExpr c = ctx.MkIntConst("c");
RealExpr d = ctx.MkRealConst("d");
RealExpr e = ctx.MkRealConst("e");
BoolExpr q = ctx.MkAnd(
ctx.MkGt(a, ctx.MkAdd(b, ctx.MkInt(2))),
ctx.MkEq(a, ctx.MkAdd(ctx.MkMul(ctx.MkInt(2), c), ctx.MkInt(10))),
ctx.MkLe(ctx.MkAdd(c, b), ctx.MkInt(1000)),
ctx.MkGe(d, e));
Solver s = ctx.MkSolver();
s.Assert(q);
Console.WriteLine(s.Check());
Console.WriteLine(s.Model);
}
}
private BoolExpr handleRealRectangularObstacle(RectangularObstacle obstacle, Context ctx, IntExpr[] sourcesX,
IntExpr[] sourcesY, IntExpr[] destinationsX, IntExpr[] destinationsY)
{
RealExpr obstacleLeftX = ctx.MkReal(obstacle.realLocation.x.ToString(new CultureInfo("en-US")));
RealExpr obstacleRightX = ctx.MkReal((obstacle.realLocation.x + obstacle.width).ToString(new CultureInfo("en-US")));
RealExpr obstacleLeftY = ctx.MkReal(obstacle.realLocation.y.ToString(new CultureInfo("en-US")));
RealExpr obstacleRightY = ctx.MkReal((obstacle.realLocation.y + obstacle.length).ToString(new CultureInfo("en-US")));
RealExpr passDistance = ctx.MkReal(obstaclePassDistance);
BoolExpr[] avoidingObstaclesX = new BoolExpr[pathSegments];
BoolExpr[] avoidingObstaclesY = new BoolExpr[pathSegments];
BoolExpr[] avoidingObstaclesCombined = new BoolExpr[pathSegments];
for (int i = 0; i < pathSegments; i++)
{
ArithExpr xl_minus_xs = ctx.MkSub(obstacleLeftX, sourcesX[i]);
ArithExpr xl_minus_xd = ctx.MkSub(obstacleLeftX, destinationsX[i]);
ArithExpr xs_minus_xh = ctx.MkSub(sourcesX[i], obstacleRightX);
ArithExpr xd_minus_xh = ctx.MkSub(destinationsX[i], obstacleRightX);
avoidingObstaclesX[i] = ctx.MkOr(ctx.MkAnd(ctx.MkGe(xl_minus_xs, passDistance), ctx.MkGe(xl_minus_xd, passDistance)),
ctx.MkAnd(ctx.MkGe(xs_minus_xh, passDistance), ctx.MkGe(xd_minus_xh, passDistance)));
ArithExpr yl_minus_ys = ctx.MkSub(obstacleLeftY, sourcesY[i]);
ArithExpr yl_minus_yd = ctx.MkSub(obstacleLeftY, destinationsY[i]);
ArithExpr ys_minus_yh = ctx.MkSub(sourcesY[i], obstacleRightY);
ArithExpr yd_minus_yh = ctx.MkSub(destinationsY[i], obstacleRightY);
avoidingObstaclesY[i] = ctx.MkOr(ctx.MkAnd(ctx.MkGe(yl_minus_ys, passDistance), ctx.MkGe(yl_minus_yd, passDistance)),
ctx.MkAnd(ctx.MkGe(ys_minus_yh, passDistance), ctx.MkGe(yd_minus_yh, passDistance)));
avoidingObstaclesCombined[i] = ctx.MkOr(avoidingObstaclesX[i], avoidingObstaclesY[i]);
}
return(ctx.MkAnd(avoidingObstaclesCombined));
}
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(0)),
ctx.MkEq(t, ctx.MkReal("4.10")),
ctx.MkEq(a, ctx.MkReal(6))
};
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);
Console.WriteLine("Decimal Solution: ");
foreach (FuncDecl f in s.Model.ConstDecls)
{
Console.WriteLine(f.Name + " = " + ((RatNum)s.Model.ConstInterp(f)).ToDecimalString(10));
}
}
}
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));
}
}
public override bool Equals(object obj)
{
var that = obj as JointTransform;
Solver solver = Z3.Context.MkSolver();
solver.Push();
RealExpr x = Z3.Context.MkRealConst("x");
RealExpr y = Z3.Context.MkRealConst("y");
RealExpr z = Z3.Context.MkRealConst("z");
Z3Point3D joint = new Z3Point3D(x, y, z);
Z3Point3D thisJoint = this.TransformFunc(joint);
Z3Point3D thatJoint = that.TransformFunc(joint);
BoolExpr xEq = Z3.Context.MkEq(thisJoint.X, thatJoint.X);
BoolExpr yEq = Z3.Context.MkEq(thisJoint.Y, thatJoint.Y);
BoolExpr zEq = Z3.Context.MkEq(thisJoint.Z, thatJoint.Z);
BoolExpr equalsExpr = Z3.Context.MkAnd(xEq, yEq, zEq);
solver.Assert(Z3.Context.MkNot(equalsExpr));
Status status = solver.Check();
Statistics stats = solver.Statistics;
//Console.WriteLine("EqualsExpr: " + equalsExpr);
//Console.WriteLine("Proving: " + equalsExpr);
//switch (status)
//{
// case Status.UNKNOWN:
// Console.WriteLine("Unknown because:\n" + solver.ReasonUnknown);
// break;
// case Status.SATISFIABLE:
// throw new ArgumentException("Test Failed Expception");
// case Status.UNSATISFIABLE:
// Console.WriteLine("OK, proof:\n" + solver.Proof);
// break;
//}
bool result = false;
if (status == Status.UNSATISFIABLE)
{
result = true;
}
solver.Pop();
return(result);
}
public void Run()
{
Dictionary <string, string> cfg = new Dictionary <string, string>()
{
{ "AUTO_CONFIG", "true" }
};
using (Context ctx = new Context(cfg))
{
IntExpr x = ctx.MkIntConst("x");
RealExpr y = ctx.MkRealConst("y");
Console.WriteLine((ctx.MkAdd(x, ctx.MkInt(1))).Sort);
Console.WriteLine((ctx.MkAdd(y, ctx.MkReal(1))).Sort);
Console.WriteLine((ctx.MkGe(x, ctx.MkInt(2))).Sort);
}
}
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)));
Console.WriteLine(ctx.MkProbe("num-consts").Apply(g));
Console.WriteLine(ctx.MkProbe("size").Apply(g));
Console.WriteLine(ctx.MkProbe("num-exprs").Apply(g));
}
}
public void Run()
{
Dictionary <string, string> cfg = new Dictionary <string, string>()
{
{ "AUTO_CONFIG", "true" }
};
Context ctx = new Context(cfg);
RealExpr x = ctx.MkRealConst("x");
RealExpr y = ctx.MkRealConst("y");
Console.WriteLine(ctx.MkPower(ctx.MkAdd(x, y), ctx.MkReal(3)));
Console.WriteLine(ctx.MkPower(x, ctx.MkAdd(y, ctx.MkReal(3))));
}
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" }
};
Context ctx = new Context(cfg);
RealExpr x = ctx.MkRealConst("x");
RealExpr y = ctx.MkRealConst("y");
RealExpr z = ctx.MkRealConst("z");
RatNum two = ctx.MkReal(2);
Console.WriteLine(ctx.MkAdd(ctx.MkSub(ctx.MkMul(x, y), ctx.MkPower(y, two)), ctx.MkPower(z, two)));
Console.WriteLine(ctx.MkSub(ctx.MkAdd(ctx.MkMul(x, y), ctx.MkPower(y, two)), ctx.MkPower(z, two)));
Console.WriteLine(ctx.MkMul(ctx.MkAdd(x, y), z));
}
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");
Params ps = ctx.MkParams();
ps.Add(":arith-lhs", true);
Expr q = ctx.MkEq(x, ctx.MkAdd(y, ctx.MkReal(2)));
q = q.Simplify(ps);
Console.WriteLine(ps);
Console.WriteLine(q);
}
}
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");
Goal g = ctx.MkGoal();
g.Assert(ctx.MkGt(ctx.MkAdd(x, y, z), ctx.MkReal(0)));
Probe p = ctx.MkProbe("num-consts");
Console.WriteLine("num-consts: " + p.Apply(g));
Tactic t = ctx.FailIf(ctx.Gt(p, ctx.Const(2)));
try
{
t.Apply(g);
}
catch (Z3Exception ex)
{
Console.WriteLine("Tactic failed: " + ex.Message);
}
Console.WriteLine("trying again...");
g = ctx.MkGoal();
g.Assert(ctx.MkGt(ctx.MkAdd(x, y), ctx.MkReal(0)));
Console.WriteLine(t[g]);
}
}
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");
IntExpr y = ctx.MkIntConst("y");
RealExpr a, b, c;
a = ctx.MkRealConst("a");
b = ctx.MkRealConst("b");
c = ctx.MkRealConst("c");
IntExpr s, r;
s = ctx.MkIntConst("s");
r = ctx.MkIntConst("r");
TestDriver.CheckString(ctx.MkAdd(x, ctx.MkInt2Real(y), ctx.MkReal(1), ctx.MkAdd(a, ctx.MkInt2Real(s))),
"(+ x (to_real y) 1.0 a (to_real s))");
TestDriver.CheckString(ctx.MkAdd(ctx.MkInt2Real(y), c), "(+ (to_real y) c)");
}
}
public void Run()
{
using (Context ctx = new Context())
{
RealExpr x = ctx.MkRealConst("x");
RealExpr y = ctx.MkRealConst("y");
RealExpr z = ctx.MkRealConst("z");
FuncDecl f = ctx.MkFuncDecl("f", ctx.RealSort, ctx.RealSort);
Solver s = ctx.MkSolver();
s.Assert(ctx.MkGt(x, ctx.MkReal(10)),
ctx.MkEq(y, ctx.MkAdd(x, ctx.MkReal(3))),
ctx.MkLt(y, ctx.MkReal(15)),
ctx.MkGt((RealExpr)f[x], ctx.MkReal(2)),
ctx.MkNot(ctx.MkEq(f[y], f[x])));
Console.WriteLine(s.Check());
Model m = s.Model;
foreach (FuncDecl fd in m.Decls)
{
Console.Write(" " + fd.Name);
}
Console.WriteLine();
foreach (FuncDecl fd in m.Decls)
{
if (fd.DomainSize == 0)
{
Console.WriteLine(fd.Name + " -> " + m.ConstInterp(fd));
}
else
{
Console.WriteLine(fd.Name + " -> " + m.FuncInterp(fd));
}
}
Console.WriteLine(m.Evaluate(ctx.MkAdd(z, ctx.MkReal(1))));
Console.WriteLine(m.Evaluate(ctx.MkAdd(z, ctx.MkReal(1)), true));
Console.WriteLine(m.Evaluate(z));
FuncInterp fi = m.FuncInterp(f);
Console.WriteLine(fi.Else);
Console.WriteLine(fi.NumEntries);
Console.WriteLine(fi.Entries[0]);
Console.WriteLine(fi.Entries[0].NumArgs);
Console.WriteLine(fi.Entries[0].Args[0]);
Console.WriteLine(fi.Entries[0].Value);
ArrayExpr a = ctx.MkArrayConst("a", ctx.RealSort, ctx.RealSort);
s.Assert(ctx.MkGt((RealExpr)ctx.MkSelect(a, x), ctx.MkReal(10)),
ctx.MkGt((RealExpr)ctx.MkSelect(a, y), ctx.MkReal(20)));
Console.WriteLine(s);
Console.WriteLine(s.Check());
Console.WriteLine(s.Model);
Console.WriteLine(s.Model.Evaluate(a));
Console.WriteLine(s.Model.FuncInterp(a.FuncDecl));
}
}
static public BoolExpr MkBetween(this Context ctx, RealExpr E, RealExpr L, RealExpr U)
{
return(ctx.MkAnd(ctx.MkGe(E, L), ctx.MkLe(E, U)));
}
public void Run()
{
using (Context ctx = new Context())
{
RealExpr x = ctx.MkRealConst("x");
RealExpr y = ctx.MkRealConst("y");
RealExpr z = ctx.MkRealConst("z");
IntExpr a = ctx.MkIntConst("a");
IntExpr b = ctx.MkIntConst("b");
IntExpr c = ctx.MkIntConst("c");
ctx.UpdateParamValue(":pp-flat-assoc", "false");
Console.WriteLine(ctx.MkAdd(x, y, ctx.MkInt2Real(a)));
Console.WriteLine(ctx.MkAdd(x, ctx.MkReal(1)));
Console.WriteLine(ctx.MkAdd(ctx.MkReal(2), y));
Console.WriteLine(ctx.MkMul(x, y));
Console.WriteLine(ctx.MkAdd(ctx.MkInt(2), ctx.MkInt(3)));
Console.WriteLine(ctx.MkMul(ctx.MkReal(2), x));
Console.WriteLine(ctx.MkAdd(ctx.MkInt2Real((IntExpr)ctx.MkAdd(ctx.MkInt(2), ctx.MkInt(3))), x));
Console.WriteLine(ctx.MkAdd((RealExpr)ctx.MkInt2Real((IntExpr)ctx.MkAdd(ctx.MkInt(2), ctx.MkInt(3))).Simplify(), x));
Console.WriteLine(ctx.MkAdd(a, b, ctx.MkInt(1)));
Console.WriteLine(ctx.MkDiv(x, y));
Console.WriteLine(ctx.MkDiv(x, ctx.MkReal(2)));
Console.WriteLine(ctx.MkDiv(ctx.MkReal(2), y));
Console.WriteLine(ctx.MkDiv(a, ctx.MkInt(2)));
Console.WriteLine(ctx.MkDiv(ctx.MkAdd(a, b), ctx.MkInt(2)));
Console.WriteLine(ctx.MkDiv(ctx.MkInt(3), a));
Console.WriteLine(ctx.MkMod(a, b));
Console.WriteLine(ctx.MkMod(a, ctx.MkInt(2)));
Console.WriteLine(ctx.MkMod(ctx.MkInt(3), a));
Console.WriteLine(ctx.MkSub(a, ctx.MkInt(2)));
Console.WriteLine(ctx.MkUnaryMinus(a));
Console.WriteLine(ctx.MkUnaryMinus(x));
Console.WriteLine(ctx.MkSub(a, b));
Console.WriteLine(a.IsAdd);
Console.WriteLine(ctx.MkAdd(a, b).IsAdd);
Console.WriteLine(ctx.MkSub(a, b).IsAdd);
Console.WriteLine(ctx.MkInt(10).IsAdd);
Console.WriteLine(ctx.MkMul(a, b).IsMul);
Console.WriteLine(ctx.MkMul(x, ctx.MkInt2Real(b)).IsMul);
Console.WriteLine(ctx.MkAdd(a, b).IsMul);
Console.WriteLine(ctx.MkDiv(a, ctx.MkInt(2)).IsDiv);
Console.WriteLine(ctx.MkDiv(ctx.MkReal(3), x).IsDiv);
Console.WriteLine(ctx.MkDiv(x, y).IsDiv);
Console.WriteLine(ctx.MkDiv(a, ctx.MkInt(2)).IsIDiv);
Console.WriteLine(ctx.MkAdd(ctx.MkInt(2), ctx.MkInt(3)).Simplify().IsAdd);
Console.WriteLine();
Console.WriteLine(a is ArithExpr);
Console.WriteLine(ctx.MkInt(2) is ArithExpr);
Console.WriteLine(ctx.MkAdd(a, b) is ArithExpr);
Console.WriteLine(ctx.MkBoolConst("p") is ArithExpr);
Console.WriteLine(ctx.MkInt(2) is IntNum);
Console.WriteLine(ctx.MkInt(2) is RatNum);
Console.WriteLine(ctx.MkReal(2, 3));
Console.WriteLine(ctx.MkReal(2, 3).IsReal);
Console.WriteLine(ctx.MkReal(2, 3) is ArithExpr);
Console.WriteLine(ctx.MkReal(2, 3).IsConst);
Console.WriteLine(ctx.MkReal(2, 3).Simplify() is RatNum);
Console.WriteLine(ctx.MkReal(2, 3).Simplify().IsRatNum);
Console.WriteLine(ctx.MkPower(ctx.MkReal(2), ctx.MkReal(1, 2)).Simplify().IsAlgebraicNumber);
Console.WriteLine(ctx.MkPower(ctx.MkReal(2), ctx.MkReal(1, 2)).Simplify() is AlgebraicNum);
Console.WriteLine(ctx.MkPower(ctx.MkReal(2), ctx.MkReal(1, 2)).IsAlgebraicNumber);
Console.WriteLine(ctx.MkPower(ctx.MkReal(2), ctx.MkReal(1, 2)) is AlgebraicNum);
Console.WriteLine(ctx.MkPower(ctx.MkReal(2), ctx.MkReal(1, 2)));
Console.WriteLine(ctx.MkPower(ctx.MkReal(2), ctx.MkReal(1, 3)));
}
}
