/// <summary>
/// Simplifies the goal.
/// </summary>
/// <remarks>Essentially invokes the `simplify' tactic on the goal.</remarks>
public Goal Simplify(Params p = null)
{
Tactic t = Context.MkTactic("simplify");
ApplyResult res = t.Apply(this, p);
if (res.NumSubgoals == 0)
{
throw new Z3Exception("No subgoals");
}
else
{
return(res.Subgoals[0]);
}
}
/// <summary>
/// Simplifies the goal.
/// </summary>
/// <remarks>Essentially invokes the `simplify' tactic on the goal.</remarks>
public Goal Simplify(Params p = null)
{
Tactic t = Context.MkTactic("simplify");
ApplyResult res = t.Apply(this, p);
if (res.NumSubgoals == 0)
{
return(Context.MkGoal());
}
else
{
return(res.Subgoals[0]);
}
}
/// <summary>
/// Create a tactic that applies <paramref name="t1"/> to a given goal if the probe
/// <paramref name="p"/> evaluates to true and <paramref name="t2"/> otherwise.
/// </summary>
public Tactic Cond(Probe p, Tactic t1, Tactic t2)
{
Contract.Requires(p != null);
Contract.Requires(t1 != null);
Contract.Requires(t2 != null);
Contract.Ensures(Contract.Result<Tactic>() != null);
CheckContextMatch(p);
CheckContextMatch(t1);
CheckContextMatch(t2);
return new Tactic(this, Native.Z3_tactic_cond(nCtx, p.NativeObject, t1.NativeObject, t2.NativeObject));
}
/// <summary>
/// Create a tactic that applies <paramref name="t1"/> to a Goal and
/// then <paramref name="t2"/> to every subgoal produced by <paramref name="t1"/>.
/// </summary>
public Tactic AndThen(Tactic t1, Tactic t2, params Tactic[] ts)
{
Contract.Requires(t1 != null);
Contract.Requires(t2 != null);
Contract.Requires(ts == null || Contract.ForAll(0, ts.Length, j => ts[j] != null));
Contract.Ensures(Contract.Result<Tactic>() != null);
CheckContextMatch(t1);
CheckContextMatch(t2);
CheckContextMatch(ts);
IntPtr last = IntPtr.Zero;
if (ts != null && ts.Length > 0)
{
last = ts[ts.Length - 1].NativeObject;
for (int i = ts.Length - 2; i >= 0; i--)
last = Native.Z3_tactic_and_then(nCtx, ts[i].NativeObject, last);
}
if (last != IntPtr.Zero)
{
last = Native.Z3_tactic_and_then(nCtx, t2.NativeObject, last);
return new Tactic(this, Native.Z3_tactic_and_then(nCtx, t1.NativeObject, last));
}
else
return new Tactic(this, Native.Z3_tactic_and_then(nCtx, t1.NativeObject, t2.NativeObject));
}
/// <summary>
/// Create a tactic that applies <paramref name="t"/> using the given set of parameters <paramref name="p"/>.
/// </summary>
/// <remarks>Alias for <c>UsingParams</c></remarks>
public Tactic With(Tactic t, Params p)
{
Contract.Requires(t != null);
Contract.Requires(p != null);
Contract.Ensures(Contract.Result<Tactic>() != null);
return UsingParams(t, p);
}
/// <summary>
/// Create a tactic that applies <paramref name="t"/> to a given goal if the probe
/// <paramref name="p"/> evaluates to true.
/// </summary>
/// <remarks>
/// If <paramref name="p"/> evaluates to false, then the new tactic behaves like the <c>skip</c> tactic.
/// </remarks>
public Tactic When(Probe p, Tactic t)
{
Contract.Requires(p != null);
Contract.Requires(t != null);
Contract.Ensures(Contract.Result<Tactic>() != null);
CheckContextMatch(t);
CheckContextMatch(p);
return new Tactic(this, Native.Z3_tactic_when(nCtx, p.NativeObject, t.NativeObject));
}
/// <summary>
/// Create a tactic that applies <paramref name="t"/> using the given set of parameters <paramref name="p"/>.
/// </summary>
public Tactic UsingParams(Tactic t, Params p)
{
Contract.Requires(t != null);
Contract.Requires(p != null);
Contract.Ensures(Contract.Result<Tactic>() != null);
CheckContextMatch(t);
CheckContextMatch(p);
return new Tactic(this, Native.Z3_tactic_using_params(nCtx, t.NativeObject, p.NativeObject));
}
/// <summary>
/// Create a tactic that applies <paramref name="t"/> to a goal for <paramref name="ms"/> milliseconds.
/// </summary>
/// <remarks>
/// If <paramref name="t"/> does not terminate within <paramref name="ms"/> milliseconds, then it fails.
/// </remarks>
public Tactic TryFor(Tactic t, uint ms)
{
Contract.Requires(t != null);
Contract.Ensures(Contract.Result<Tactic>() != null);
CheckContextMatch(t);
return new Tactic(this, Native.Z3_tactic_try_for(nCtx, t.NativeObject, ms));
}
/// <summary>
/// Create a tactic that applies <paramref name="t1"/> to a Goal and
/// then <paramref name="t2"/> to every subgoal produced by <paramref name="t1"/>.
/// </summary>
/// <remarks>
/// Shorthand for <c>AndThen</c>.
/// </remarks>
public Tactic Then(Tactic t1, Tactic t2, params Tactic[] ts)
{
Contract.Requires(t1 != null);
Contract.Requires(t2 != null);
Contract.Requires(ts == null || Contract.ForAll(0, ts.Length, j => ts[j] != null));
Contract.Ensures(Contract.Result<Tactic>() != null);
return AndThen(t1, t2, ts);
}
/// <summary>
/// Create a tactic that keeps applying <paramref name="t"/> until the goal is not
/// modified anymore or the maximum number of iterations <paramref name="max"/> is reached.
/// </summary>
public Tactic Repeat(Tactic t, uint max = uint.MaxValue)
{
Contract.Requires(t != null);
Contract.Ensures(Contract.Result<Tactic>() != null);
CheckContextMatch(t);
return new Tactic(this, Native.Z3_tactic_repeat(nCtx, t.NativeObject, max));
}
/// <summary>
/// Create a tactic that applies <paramref name="t1"/> to a given goal and then <paramref name="t2"/>
/// to every subgoal produced by <paramref name="t1"/>. The subgoals are processed in parallel.
/// </summary>
public Tactic ParAndThen(Tactic t1, Tactic t2)
{
Contract.Requires(t1 != null);
Contract.Requires(t2 != null);
Contract.Ensures(Contract.Result<Tactic>() != null);
CheckContextMatch(t1);
CheckContextMatch(t2);
return new Tactic(this, Native.Z3_tactic_par_and_then(nCtx, t1.NativeObject, t2.NativeObject));
}
/// <summary>
/// Create a tactic that first applies <paramref name="t1"/> to a Goal and
/// if it fails then returns the result of <paramref name="t2"/> applied to the Goal.
/// </summary>
public Tactic OrElse(Tactic t1, Tactic t2)
{
Contract.Requires(t1 != null);
Contract.Requires(t2 != null);
Contract.Ensures(Contract.Result<Tactic>() != null);
CheckContextMatch(t1);
CheckContextMatch(t2);
return new Tactic(this, Native.Z3_tactic_or_else(nCtx, t1.NativeObject, t2.NativeObject));
}
/// <summary>
/// Creates a solver that is implemented using the given tactic.
/// </summary>
/// <remarks>
/// The solver supports the commands <c>Push</c> and <c>Pop</c>, but it
/// will always solve each check from scratch.
/// </remarks>
public Solver MkSolver(Tactic t)
{
Contract.Requires(t != null);
Contract.Ensures(Contract.Result<Solver>() != null);
return new Solver(this, Native.Z3_mk_solver_from_tactic(nCtx, t.NativeObject));
}
static ApplyResult ApplyTactic(Context ctx, Tactic t, Goal g)
{
Console.WriteLine("\nGoal: " + g);
ApplyResult res = t.Apply(g);
Console.WriteLine("Application result: " + res);
Status q = Status.UNKNOWN;
foreach (Goal sg in res.Subgoals)
if (sg.IsDecidedSat) q = Status.SATISFIABLE;
else if (sg.IsDecidedUnsat) q = Status.UNSATISFIABLE;
switch (q)
{
case Status.UNKNOWN:
Console.WriteLine("Tactic result: Undecided");
break;
case Status.SATISFIABLE:
Console.WriteLine("Tactic result: SAT");
break;
case Status.UNSATISFIABLE:
Console.WriteLine("Tactic result: UNSAT");
break;
}
return res;
}
static void SolveTactical(Context ctx, Tactic t, Goal g, Status sat)
{
Solver s = ctx.MkSolver(t);
Console.WriteLine("\nTactical solver: " + s);
foreach (BoolExpr a in g.Formulas)
s.Assert(a);
Console.WriteLine("Solver: " + s);
if (s.Check() != sat)
throw new TestFailedException();
}
