C# Z3Provider.MkAnd方法代码示例

        public void SFAtest2()
        {
            Z3Provider solver = new Z3Provider();
            string a = @"^[A-Za-z0-9][email protected](([A-Za-z0-9\-])+\.)+([A-Za-z\-])+$"; //.Net regex
            string b = @"^\d.*$";                                            //.Net regex
            //corresponding SFAs
            var A = new SFAz3(solver, solver.CharacterSort, solver.RegexConverter.Convert(a));
            var B = new SFAz3(solver, solver.CharacterSort, solver.RegexConverter.Convert(b));

            A.AssertTheory(); //assert the theories of both SFAs to the solver
            B.AssertTheory();

            //declare a new uninterpreted constant of sort List<character>
            Expr inputConst = solver.MkFreshConst("input", A.InputListSort);

            //get a solution for input so that it is accepted by A but not by B
            var assertion = solver.MkAnd(A.MkAccept(inputConst),
                                         solver.MkNot(B.MkAccept(inputConst)));
            var model = solver.MainSolver.GetModel(assertion, inputConst);
            string input = model[inputConst].StringValue;  //actual witness in L(A)-L(B)
        }

        internal override Automaton<Expr> getAutomata(Z3Provider z3p, List<string> variables, Expr universe, Expr var, Sort sort)
        {
            uint set1bit = (uint)variables.IndexOf(set1);
            uint set2bit = (uint)variables.IndexOf(set2);

            //Sort for pairs (input theory, BV)
            var bv = z3p.Z3.MkBitVecSort(BVConst.BVSIZE);
            var pairSort = z3p.MkTupleSort(sort, bv);

            //Create the predicate for the two singleton sets
            var pred = z3p.MkBvUlt(z3p.MkProj(1, var),
                z3p.Z3.MkInt2BV(BVConst.BVSIZE,
                    (IntExpr)z3p.MkInt((int)(Math.Pow(2.0, variables.Count)))
                ));
            pred = z3p.MkAnd(pred, universe);
            var b1 = z3p.MkBvExtract(set1bit, set1bit, z3p.MkProj(1, var));
            var b2 = z3p.MkBvExtract(set2bit, set2bit, z3p.MkProj(1, var));

            var bit0 = z3p.Z3.MkInt2BV(1,
                    (IntExpr)z3p.MkInt(0));
            var bit1 = z3p.Z3.MkInt2BV(1,
                    (IntExpr)z3p.MkInt(1));

            var pred0 = z3p.MkAnd(pred, z3p.MkBvUle(b1, bit0));
            pred0 = z3p.MkAnd(pred, z3p.MkBvUle(b2, bit0));
            var pred1 = z3p.MkAnd(pred, z3p.MkBvUge(b1, bit1));
            pred0 = z3p.MkAnd(pred, z3p.MkBvUle(b2, bit0));
            var pred2 = z3p.MkAnd(pred, z3p.MkBvUle(b1, bit0));
            pred0 = z3p.MkAnd(pred, z3p.MkBvUge(b2, bit1));

            //Create the automaton with one state and one transition
            var less = Automaton<Expr>.Create(0, new int[] { 2 }, new Move<Expr>[] { 
                new Move<Expr>(0, 0, pred0),
                new Move<Expr>(0, 1, pred1),
                new Move<Expr>(1, 1, pred0),
                new Move<Expr>(1, 2, pred2),
                new Move<Expr>(2, 2, pred0) 
            });

            //Minimize and output
            return less;
        }

        public void TestSTbSimplify()
        {
            string utf8decode_bek = @"
            function fuse(r,c) = ((r << 6) | (c & 0x3F));
            function one(c) = ((0 <= c) && (c <= 0x7F));
            function C2_DF(c) = ((0xC2 <= c) && (c <= 0xDF));
            function E1_EF(c) = ((0xE1 <= c) && (c <= 0xEF));
            function A0_BF(c) = ((0xA0 <= c) && (c <= 0xBF));
            function x80_BF(c) = ((0x80 <= c) && (c <= 0xBF));
            function x80_9F(c) = ((0x80 <= c) && (c <= 0x9F));
            program utf8decode(input){
              return iter(c in input)[q := 0; r := 0;]
              {
            case (q == 0):
              if (one(c))                  {yield (c);}
              else if (C2_DF(c))           {q := 2; r := (c & 0x1F);}    // ------ 2 bytes --------
              else if (c == 0xE0)          {q := 4; r := (c & 0x0F);}    // ------ 3 bytes --------
              else if (c == 0xED)          {q := 5; r := (c & 0x0F);}    // ------ 3 bytes --------
              else if (E1_EF(c))           {q := 3; r := (c & 0x0F);}    // ------ 3 bytes --------
              else {raise InvalidInput;}

            case (q == 2):
              if (x80_BF(c))                 {q := 0; yield(fuse(r,c)); r := 0;}
              else {raise InvalidInput;}

            case (q == 3):
              if (x80_BF(c))                 {q := 2; r := fuse(r,c);}
              else {raise InvalidInput;}

            case (q == 4):
              if (A0_BF(c))                  {q := 2; r := fuse(r,c);}
              else {raise InvalidInput;}

            case (q == 5):
              if (x80_9F(c))                 {q := 2; r := fuse(r,c);}
              else {raise InvalidInput;}

            end case (!(q == 0)):
              raise InvalidInput;
              };
            }
            ";

            Z3Provider solver = new Z3Provider(BitWidth.BV16);
            var dec = BekConverter.BekToSTb(solver, utf8decode_bek);
            var utf8decode = dec.ExploreBools();

            Sort bv32 = solver.MkBitVecSort(32);
            Sort outSort = solver.MkTupleSort(solver.StringSort, bv32);
            var initReg = solver.MkTuple(solver.GetNil(solver.StringSort), solver.MkNumeral(0,bv32));
            var regVar = solver.MkVar(1,outSort);
            var reg1 = solver.MkProj(1, regVar);
            var reg0 = solver.MkProj(0, regVar);
            STb<FuncDecl, Expr, Sort> parse = new STbModel(solver, "Parse", solver.CharacterSort, outSort, outSort, initReg, 0);

            var letter = solver.MkOr(//solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('\xC0'), solver.CharVar),
                                     //                    solver.MkCharLe(solver.CharVar, solver.MkCharExpr('\xFF'))),
                                     solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('a'), solver.CharVar),
                                                         solver.MkCharLe(solver.CharVar, solver.MkCharExpr('z'))),
                                     solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('A'), solver.CharVar),
                                                         solver.MkCharLe(solver.CharVar, solver.MkCharExpr('Z'))));

            //var not_letter = solver.MkNot(letter);

            var digit = solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('0'), solver.CharVar),
                                                         solver.MkCharLe(solver.CharVar, solver.MkCharExpr('9')));

            var nl = solver.MkEq(solver.CharVar, solver.MkCharExpr('\n'));

            var space = solver.MkEq(solver.CharVar, solver.MkCharExpr(' '));

            //var not_nl = solver.MkNot(nl);

            var _0 = solver.MkNumeral((int)'0', bv32);

            //var z = solver.Z3.MkFreshConst("z", solver.CharacterSort);

            //var constr = solver.MkNot(solver.Z3.MkExists(new Expr[] { z }, nl.Substitute(solver.CharVar, z)));
            ////var constr = nl.Substitute(solver.CharVar, z);

            //solver.Z3S.Push();
            //solver.Z3S.Assert((BoolExpr)solver.MkNot(constr));
            //var status = solver.Check();
            //var m = solver.Z3S.Model;
            //var zval = m.Evaluate(z, true);
            //solver.Z3S.Pop();

            var loop_0 = new BaseRule<Expr>(Sequence<Expr>.Empty, regVar, 0);
            var brule0_1 = new BaseRule<Expr>(Sequence<Expr>.Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 1);
            var rule0 = new IteRule<Expr>(letter, brule0_1, new IteRule<Expr>(space, loop_0, UndefRule<Expr>.Default));
            parse.AssignRule(0, rule0);

            var brule1_2 = new BaseRule<Expr>(Sequence<Expr>.Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 2);
            var brule_4 = new BaseRule<Expr>(Sequence<Expr>.Empty, regVar, 4);
            var rule1 = new IteRule<Expr>(letter, brule1_2, new IteRule<Expr>(space, brule_4, UndefRule<Expr>.Default));
            parse.AssignRule(1, rule1);

            var brule2_3 = new BaseRule<Expr>(Sequence<Expr>.Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 4);
            var rule2 = new IteRule<Expr>(letter, brule2_3, new IteRule<Expr>(space, brule_4, UndefRule<Expr>.Default));
            parse.AssignRule(2, rule2);
//.........这里部分代码省略.........

        public void TestCssCombinedCodepoint()
        {
            var kkkk = 0x7FFF - 65532;
            Z3Provider solver = new Z3Provider();
            Sort bv64 = solver.MkBitVecSort(64);
            Sort bv16 = solver.CharacterSort;

            Expr hs = solver.MkConst("hs", bv16);
            Expr ls = solver.MkConst("ls", bv16);

            Expr res = solver.MkConst("res", bv64);

            Expr maxVal = solver.MkNumeral(0x10FFFF, bv64); //max 16 bit nr

            Expr x = solver.ConvertBitVector(hs, bv64);
            Expr y = solver.ConvertBitVector(ls, bv64);
            Expr _0x10000 = solver.MkNumeral(0x10000, bv64);
            Expr _0xD800 = solver.MkNumeral(0xD800, bv64);
            Expr _0x400 = solver.MkNumeral(0x400, bv64);
            Expr _0xDC00 = solver.MkNumeral(0xDC00, bv64);

            ushort tmpLS = ((ushort)0xdfff) - ((ushort)0xdc00);

            for (int i = 0xdc00; i <= 0xdfff; i++ )
            {
                int j = (i - 0xdc00) >> 8;
                int k = (i >> 8) & 3;
                Assert.AreEqual<int>(j, k);
            }

            int tmpHS = (((int)0xdbff) - ((int)0xd800)) * ((int)0x400);
            //int tmpHS = (((int)0xdbff) - ((int)0xd800)) << 10;

            int tmpHSLS = tmpLS + tmpHS;

            int maxcodepoint = tmpHSLS + 0x10000;

            Expr cp = solver.MkCharAdd(_0x10000,
                       solver.MkCharAdd(solver.MkCharMul(solver.MkCharSub(x, _0xD800), _0x400),
                                        solver.MkCharSub(y, _0xDC00)));

            Expr ls_is_lowSurrogate =
                solver.MkAnd(solver.MkCharGe(ls, solver.MkNumeral(0xdc00, bv16)),
                                solver.MkCharLe(ls, solver.MkNumeral(0xdfff, bv16)));

            Expr hs_is_highSurrogate =
                solver.MkAnd(solver.MkCharGe(hs, solver.MkNumeral(0xd800, bv16)),
                                solver.MkCharLe(hs, solver.MkNumeral(0xdbff, bv16)));

            Expr assert = solver.Simplify(solver.MkAnd(
                ls_is_lowSurrogate,
                hs_is_highSurrogate,
                solver.MkEq(res, cp)));

            //string s = solver.PrettyPrint(assert);

            solver.MainSolver.Assert(assert);

            var model = solver.MainSolver.GetModel(solver.MkCharLt(maxVal, res), hs, ls, res);

            Assert.IsNull(model);

            //if (model != null)
            //{
            //    int hsVal = solver.GetNumeralInt(model[hs].Value);
            //    int lsVal = solver.GetNumeralInt(model[ls].Value);
            //    long resval = solver.GetNumeralUInt(model[res].Value);
            //    Assert.AreEqual<long>(CssCombinedCodepoint(hsVal, lsVal), resval);
            //}
        }