C# Context.MkBoolConst方法代码示例

    public void Run()
    {
        using (Context ctx = new Context())
        {
            BoolExpr p = ctx.MkBoolConst("p");
            BoolExpr q = ctx.MkBoolConst("q");
            Console.WriteLine(ctx.MkAnd(p, q));
            Console.WriteLine(ctx.MkOr(p, q));
            Console.WriteLine(ctx.MkAnd(p, ctx.MkTrue()));
            Console.WriteLine(ctx.MkOr(p, ctx.MkFalse()));
            Console.WriteLine(ctx.MkNot(p));
            Console.WriteLine(ctx.MkImplies(p, q));
            Console.WriteLine(ctx.MkEq(p, q).Simplify());
            Console.WriteLine(ctx.MkEq(p, q));

            BoolExpr r = ctx.MkBoolConst("r");

            Console.WriteLine(ctx.MkNot(ctx.MkEq(p, ctx.MkNot(ctx.MkEq(q, r)))));
            Console.WriteLine(ctx.MkNot(ctx.MkEq(ctx.MkNot(ctx.MkEq(p, q)), r)));
            Console.WriteLine(ctx.MkEq(p, ctx.MkTrue()));
            Console.WriteLine(ctx.MkEq(p, ctx.MkFalse()));
            Console.WriteLine(ctx.MkEq(p, ctx.MkTrue()).Simplify());
            Console.WriteLine(ctx.MkEq(p, ctx.MkFalse()).Simplify());
            Console.WriteLine(ctx.MkEq(p, p).Simplify());
            Console.WriteLine(ctx.MkEq(p, q).Simplify());
            Console.WriteLine(ctx.MkAnd(p, q, r));
            Console.WriteLine(ctx.MkOr(p, q, r));

            IntExpr x = ctx.MkIntConst("x");

            Console.WriteLine(x is BoolExpr);
            Console.WriteLine(p is BoolExpr);
            Console.WriteLine(ctx.MkAnd(p, q) is BoolExpr);
            Console.WriteLine(p is BoolExpr);
            Console.WriteLine(ctx.MkAdd(x, ctx.MkInt(1)) is BoolExpr);
            Console.WriteLine(p.IsAnd);
            Console.WriteLine(ctx.MkOr(p, q).IsOr);
            Console.WriteLine(ctx.MkAnd(p, q).IsAnd);
            Console.WriteLine(x.IsNot);
            Console.WriteLine(p.IsNot);
            Console.WriteLine(ctx.MkNot(p));
            Console.WriteLine(ctx.MkNot(p).IsDistinct);
            Console.WriteLine(ctx.MkEq(p, q).IsDistinct);
            Console.WriteLine(ctx.MkDistinct(p, q).IsDistinct);
            Console.WriteLine(ctx.MkDistinct(x, ctx.MkAdd(x, ctx.MkInt(1)), ctx.MkAdd(x, ctx.MkInt(2))).IsDistinct);

            Console.WriteLine();

            Console.WriteLine(ctx.MkBool(true));
            Console.WriteLine(ctx.MkBool(false));
            Console.WriteLine(ctx.BoolSort);

            Context ctx1 = new Context();
            Console.WriteLine(ctx1.MkBool(true));
            Console.WriteLine(ctx1.BoolSort);
            Console.WriteLine(ctx1.MkBool(true).Sort == ctx1.BoolSort);
            Console.WriteLine(ctx1.MkBool(true).Sort == ctx.BoolSort);
            Console.WriteLine(ctx1.MkBool(true).Sort != ctx.BoolSort);
        }
    }

    public void Run()
    {
        Dictionary<string, string> cfg = new Dictionary<string, string>() {
            { "AUTO_CONFIG", "true" } };

        using (Context ctx = new Context(cfg))
        {
            BoolExpr p1 = ctx.MkBoolConst("p1");
            BoolExpr p2 = ctx.MkBoolConst("p2");
            BoolExpr p3 = ctx.MkBoolConst("p3");

            IntExpr x = ctx.MkIntConst("x");
            IntExpr y = ctx.MkIntConst("y");

            Solver s = ctx.MkSolver();

            s.Assert(ctx.MkImplies(p1, ctx.MkGt(x, ctx.MkInt(10))),
                     ctx.MkImplies(p1, ctx.MkGt(y, x)),
                     ctx.MkImplies(p2, ctx.MkLt(y, ctx.MkInt(5))),
                     ctx.MkImplies(p3, ctx.MkGt(y, ctx.MkInt(0))));

            Console.WriteLine(s);
            Console.WriteLine(s.Check(p1, p2, p3));
            Console.WriteLine("Core: ");
            foreach (Expr e in s.UnsatCore)
                Console.WriteLine(e);

            Console.WriteLine(s.Check(p1, p3));
            Console.WriteLine(s.Model);
        }
    }

    public void Run()
    {
        using (Context ctx = new Context())
        {
            BoolExpr p = ctx.MkBoolConst("p");
            Console.WriteLine(ctx.MkNot(p));
            Console.WriteLine(ctx.MkNot(p));
            IntExpr x = ctx.MkIntConst("x");
            IntExpr y = ctx.MkIntConst("y");

            Console.WriteLine(ctx.MkAdd(x, ctx.MkInt(1)));
            Console.WriteLine(ctx.MkAdd(ctx.MkInt(1), x));
            Console.WriteLine(ctx.MkAdd(x, y));
            Console.WriteLine(ctx.MkMul(ctx.MkInt(2), x));
            Console.WriteLine(ctx.MkMul(x, ctx.MkInt(2)));
            Console.WriteLine(ctx.MkMul(x, y));
            Console.WriteLine(ctx.MkDiv(x, y));
            Console.WriteLine(ctx.MkMod(x, y));
            Console.WriteLine(ctx.MkEq(x, y));
            Console.WriteLine(ctx.MkDistinct(x, y, x));
            Console.WriteLine(ctx.MkNot(ctx.MkEq(x, y)));
            Console.WriteLine(ctx.MkEq(x, y));
            Console.WriteLine(ctx.MkAdd(x, ctx.MkInt(1)));
            Console.WriteLine(ctx.MkAdd(x, ctx.MkInt(1)));

            BoolExpr q = ctx.MkBoolConst("q");
            Console.WriteLine(ctx.MkNot(p));
            Console.WriteLine(ctx.MkNot(p));
            Console.WriteLine(ctx.MkAnd(p, q));
            Console.WriteLine(ctx.MkAnd(p, q));
            Console.WriteLine(ctx.MkEq(x, y));
        }
    }

    public void Run()
    {
        Dictionary<string, string> cfg = new Dictionary<string, string>() {
            { "AUTO_CONFIG", "true" } };

        using (Context ctx = new Context(cfg))
        {
            BoolExpr a = ctx.MkBoolConst("a");
            BoolExpr b = ctx.MkBoolConst("b");
            BoolExpr c = ctx.MkBoolConst("c");
            BoolExpr d = ctx.MkBoolConst("d");
            BoolExpr e = ctx.MkBoolConst("e");
            BoolExpr f = ctx.MkBoolConst("f");
            BoolExpr g = ctx.MkBoolConst("g");
            BoolExpr z = ctx.MkBoolConst("z");

            Console.WriteLine("Check 1");
            InstallCheck(ctx, new BoolExpr[] {
                                DependsOn(ctx, a, new BoolExpr[] { b, c, z }),
                                DependsOn(ctx, b, new BoolExpr[] { d }),
                                DependsOn(ctx, c, new BoolExpr[] { ctx.MkOr(d, e), ctx.MkOr(f, g) }),
                                Conflict(ctx, d, e),
                                Conflict(ctx, d, g),
                                a, z });

            Console.WriteLine("Check 2");
            InstallCheck(ctx, new BoolExpr[] {
                                DependsOn(ctx, a, new BoolExpr[] { b, c, z }),
                                DependsOn(ctx, b, new BoolExpr[] { d }),
                                DependsOn(ctx, c, new BoolExpr[] { ctx.MkOr(d, e), ctx.MkOr(f, g) }),
                                Conflict(ctx, d, e),
                                Conflict(ctx, d, g),
                                a, z, g });
        }
    }

    public void Run()
    {
        Dictionary<string, string> cfg = new Dictionary<string, string>() {
            { "AUTO_CONFIG", "true" } };

        using (Context ctx = new Context(cfg))
        {
            BoolExpr a = ctx.MkBoolConst("a");
            BoolExpr b = ctx.MkBoolConst("b");
            BoolExpr c = ctx.MkBoolConst("c");
            BoolExpr d = ctx.MkBoolConst("d");
            BoolExpr e = ctx.MkBoolConst("e");
            BoolExpr f = ctx.MkBoolConst("f");
            BoolExpr g = ctx.MkBoolConst("g");
            BoolExpr z = ctx.MkBoolConst("z");

            Solver s = ctx.MkSolver();

            s.Assert(DependsOn(ctx, a, new BoolExpr[] { b, c, z }));
            s.Assert(DependsOn(ctx, b, new BoolExpr[] { d }));
            s.Assert(DependsOn(ctx, c, new BoolExpr[] { ctx.MkOr(d, e), ctx.MkOr(f, g) }));
            s.Assert(Conflict(ctx, d, e));
            s.Assert(a);
            s.Assert(z);

            Console.WriteLine(s.Check());
            Console.WriteLine(s.Model);
        }
    }

    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 void Run()
 {
     using (Context ctx = new Context()) {
         var s = ctx.MkFixedpoint();
         BoolExpr a = ctx.MkBoolConst("a");
         BoolExpr b = ctx.MkBoolConst("b");
         BoolExpr c = ctx.MkBoolConst("c");
         s.RegisterRelation(a.FuncDecl);
         s.RegisterRelation(b.FuncDecl);
         s.RegisterRelation(c.FuncDecl);
         s.AddRule(ctx.MkImplies(a, b));
         s.AddRule(ctx.MkImplies(b, c));
         Console.WriteLine(s.Query(c));
         s.AddRule(a);
         Console.WriteLine(s.Query(c));
     }
 }

    public void Run()
    {
        Dictionary<string, string> cfg = new Dictionary<string, string>() {
            { "AUTO_CONFIG", "true" },
            { "PROOF_MODE", "2" } };

        using (Context ctx = new Context(cfg))
        {
            BoolExpr p = ctx.MkBoolConst("p");
            Solver s = ctx.MkSolver();
            s.Assert(p);
            s.Assert(ctx.MkNot(p));

            Console.WriteLine(s.Check());
            Console.WriteLine(s.Proof);
        }
    }

        /// <summary>
        /// Extract unsatisfiable core example with AssertAndTrack
        /// </summary>
        public static void UnsatCoreAndProofExample2(Context ctx)
        {
            Console.WriteLine("UnsatCoreAndProofExample2");

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

            BoolExpr p1 = ctx.MkBoolConst("P1");
            BoolExpr p2 = ctx.MkBoolConst("P2");
            BoolExpr p3 = ctx.MkBoolConst("P3");
            BoolExpr p4 = ctx.MkBoolConst("P4");

            solver.AssertAndTrack(f1, p1);
            solver.AssertAndTrack(f2, p2);
            solver.AssertAndTrack(f3, p3);
            solver.AssertAndTrack(f4, p4);
            Status result = solver.Check();

            if (result == Status.UNSATISFIABLE)
            {
                Console.WriteLine("unsat");
                Console.WriteLine("core: ");
                foreach (Expr c in solver.UnsatCore)
                {
                    Console.WriteLine("{0}", c);
                }
            }
        }

        /// <summary>
        /// Find a model for <code>x xor y</code>.
        /// </summary>
        public static void FindModelExample1(Context ctx)
        {
            Console.WriteLine("FindModelExample1");

            BoolExpr x = ctx.MkBoolConst("x");
            BoolExpr y = ctx.MkBoolConst("y");
            BoolExpr x_xor_y = ctx.MkXor(x, y);

            Model model = Check(ctx, x_xor_y, Status.SATISFIABLE);
            Console.WriteLine("x = {0}, y = {1}",
                              model.Evaluate(x),
                              model.Evaluate(y));
        }

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

        /// <summary>
        /// Extract unsatisfiable core example 
        /// </summary>
        public static void UnsatCoreAndProofExample()
        {
            Console.WriteLine("UnsatCoreAndProofExample");

            Dictionary<string, string> cfg = new Dictionary<string, string>() { { "PROOF_MODE", "2" } };

            using (Context ctx = new Context(cfg))
            {
                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[] assumptions = new BoolExpr[] { ctx.MkNot(p1), ctx.MkNot(p2), ctx.MkNot(p3), ctx.MkNot(p4) };
                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.Assert(ctx.MkOr(f1, p1));
                solver.Assert(ctx.MkOr(f2, p2));
                solver.Assert(ctx.MkOr(f3, p3));
                solver.Assert(ctx.MkOr(f4, p4));
                Status result = solver.Check(assumptions);

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

        internal ObjectTheoremResult Solve()
        {
            var settings = new Dictionary<string, string> {
                { "model", "true" },
                { "unsat_core", "true" }
            };

            using (var context = new Context(settings))
            {
                var stopwatch = Stopwatch.StartNew();

                Environment environment = GenerateEnvironment(context);

                BoolExpr[] assertions = GenerateConstraints(context, environment, _assertions);

                BoolExpr[] allAssertions = GenerateAllConstraints(context, environment, _allAssertions);

                Solver solver = context.MkSimpleSolver();

                int assertionCount = 0;
                foreach (var assertion in assertions.Concat(allAssertions))
                {
                    assertionCount++;
                    solver.Assert(assertion);
                }

                int assumptionCount = 0;
                var assumptions = new Dictionary<LambdaExpression, BoolExpr>();
                foreach (var assumption in _assumptions)
                {
                    var generator = new LambdaExpressionToConstraintGenerator(context, environment);

                    var assumptionExpr = generator.Visit(assumption);

                    var assumptionCheck = context.MkBoolConst(Guid.NewGuid().ToString());
                    solver.Assert(context.MkEq(assumptionExpr, assumptionCheck));

                    assumptionCount++;
                    assumptions.Add(assumption, assumptionCheck);
                }

                stopwatch.Stop();
                var constraintGenerationTimeSpan = stopwatch.Elapsed;

                var solverString = solver.ToString();
                var totalConstraintsCount = solverString.Split('\n').Count(l => l.StartsWith("  ("));

                Trace.WriteLine("Statistics:");
                Trace.WriteLine("assertionCount: " + assertionCount);
                Trace.WriteLine("assumptionCount: " + assumptionCount);
                Trace.WriteLine("totalConstraintsCount: " + totalConstraintsCount);
                Trace.WriteLine("constraintGenerationTimeSpan: " + constraintGenerationTimeSpan);

                var classCount = environment.Types.Count(t => !t.Key.IsValueType && t.Key.Name != "String");
                var propertyCount = environment.Types
                    .Where(t => !t.Key.IsValueType && t.Key.Name != "String")
                    .Select(p => p.Key.GetProperties())
                    .Count();

                stopwatch.Restart();
                Microsoft.Z3.Status status = solver.Check(assumptions.Values.ToArray());
                stopwatch.Stop();

                var solvingTimeSpan = stopwatch.Elapsed;
                Trace.WriteLine("solvingTimeSpan: " + solvingTimeSpan);

                if (status != Microsoft.Z3.Status.SATISFIABLE)
                {
                    if (solver.UnsatCore.Length > 0)
                    {
                        var result = new ObjectTheoremResult(context, environment, solver, status);
                        result.SetUnsatCore(assumptions, solver.UnsatCore);
                        return result;
                    }

                    return null;
                }

                var modelString = solver.Model.ToString();

                return new ObjectTheoremResult(context, environment, solver, status);
            }
        }