knuckledragger 0.1.3__py3-none-any.whl

kdrag/__init__.py

@@ -0,0 +1,191 @@
+"""
+Knuckledragger is an attempt at creating a down to earth,
+highly automated interactive proof assistant in python.
+It is not attempting to be the most interesting, expressive,
+or flexible logic in the world.
+
+The goal is to support applications like software/hardware verification,
+calculus, equational reasoning, and numerical bounds.
+"""
+
+from . import smt
+from . import kernel
+from . import notation
+from . import utils
+from . import datatype
+from . import rewrite
+from . import tactics
+import functools
+
+
+Proof = kernel.Proof
+
+
+prove = tactics.prove
+
+
+axiom = kernel.axiom
+
+
+define = kernel.define
+
+FreshVar = kernel.FreshVar
+
+FreshVars = tactics.FreshVars
+
+QImplies = notation.QImplies
+
+QForAll = notation.QForAll
+
+QExists = notation.QExists
+
+
+cond = notation.cond
+
+
+Inductive = kernel.Inductive
+
+
+Struct = datatype.Struct
+
+
+NewType = datatype.NewType
+
+
+InductiveRel = datatype.InductiveRel
+
+
+Enum = datatype.Enum
+
+
+Calc = tactics.Calc
+
+
+Lemma = tactics.Lemma
+Theorem = tactics.Theorem
+PTheorem = tactics.PTheorem
+
+simp = rewrite.simp
+
+search = utils.search
+
+# TODO: Remove this
+R = smt.RealSort()
+Z = smt.IntSort()
+RSeq = Z >> R
+RFun = R >> R
+
+
+def seq(*args):
+    """
+    Helper to construct sequences.
+    >>> seq(1, 2, 3)
+    Concat(Unit(1), Concat(Unit(2), Unit(3)))
+    >>> seq(1)
+    Unit(1)
+    """
+    if len(args) == 0:
+        raise ValueError(
+            "seq() requires at least one argument. use smt.Empty(sort) instead."
+        )
+    elif len(args) == 1:
+        return smt.Unit(smt._py2expr(args[0]))
+    else:
+        return smt.Concat(*[smt.Unit(smt._py2expr(a)) for a in args])
+
+
+Nat = Inductive("Nat")
+Nat.declare("Z")
+Nat.declare("S", ("pred", Nat))
+Nat = Nat.create()
+
+
+def NatSort() -> smt.DatatypeSortRef:
+    global Nat
+    assert isinstance(Nat, smt.DatatypeSortRef)
+    return Nat
+
+
+@functools.cache
+def ListSort(Elt: smt.SortRef) -> smt.DatatypeSortRef:
+    """
+    >>> ListSort(smt.IntSort())
+    List_Int...
+    """
+    T = Inductive("List_" + Elt.name())
+    T.declare("Nil")
+    T.declare("Cons", ("head", Elt), ("tail", T))
+    return T.create()
+
+
+def list(*args: smt.ExprRef) -> smt.DatatypeRef:
+    """
+    Helper to construct List values
+    >>> list(1, 2, 3)
+    Cons(1, Cons(2, Cons(3, Nil)))
+    """
+    if len(args) == 0:
+        raise ValueError("list() requires at least one argument")
+    LT = ListSort(smt._py2expr(args[0]).sort())
+    acc = LT.Nil
+    for a in reversed(args):
+        acc = LT.Cons(a, acc)
+    return acc
+
+
+@functools.cache
+def OptionSort(T: smt.SortRef) -> smt.DatatypeSortRef:
+    """
+    Define an Option type for a given type T
+    >>> OInt = OptionSort(smt.IntSort())
+    >>> OInt.Some(1)
+    Some(1)
+    >>> OInt.None_
+    None_
+    >>> OInt.Some(1).val
+    val(Some(1))
+    """
+    Option = Inductive("Option_" + T.name())
+    Option.declare("None_")
+    Option.declare("Some", ("val", T))
+    return Option.create()
+
+
+# I guess I could make this a SortDispatch for regularity. I just don't see why I'd need to overload in any way but the default
+def Some(x: smt.ExprRef) -> smt.DatatypeRef:
+    """
+    Helper to create Option values
+    >>> Some(42)
+    Some(42)
+    >>> Some(42).sort()
+    Option_Int
+    """
+    x = smt._py2expr(x)
+    return OptionSort(x.sort()).Some(x)
+
+
+__all__ = [
+    "prove",
+    "axiom",
+    "define",
+    "Proof",
+    "FreshVar",
+    "FreshVars",
+    "QImplies",
+    "QForAll",
+    "QExists",
+    "cond",
+    "Struct",
+    "NewType",
+    "Inductive",
+    "Calc",
+    "Lemma",
+    "Theorem",
+    "PTheorem",
+    "R",
+    "Z",
+    "RSeq",
+    "RFun",
+    "simp",
+    "search",
+]

kdrag/all.py

@@ -0,0 +1,17 @@
+"""
+A convenience module to import commonly needed other modules as shorthands
+"""
+
+import kdrag as kd
+import kdrag.smt as smt
+
+# import kdrag.theories.real as real
+import kdrag.solvers as solvers
+import kdrag.theories as thy
+import kdrag.rewrite as rw
+import kdrag.tele as tele
+
+import kdrag.theories.option as option
+import kdrag.theories.list as list_
+import kdrag.theories.set as set_
+import kdrag.theories.seq as seq

kdrag/config.py

@@ -0,0 +1,19 @@
+"""
+Global configuration of Knuckledragger
+"""
+
+solver = None
+admit_enabled = True
+# timeout = 1000
+admit_level = 50
+
+
+# TODO: Someday, when it is annoyingly slow to check built in theories, we can add a flag to disable them
+# check_lib = True
+timing = False
+perf_log = []
+
+
+def perf_event(tag, data, time):
+    if timing:
+        perf_log.append((tag, data, time))

kdrag/contrib/absint/knownbit.py

@@ -0,0 +1,138 @@
+"""
+Known Bits Abstract Domain
+
+https://pypy.org/posts/2024/08/toy-knownbits.html
+https://arxiv.org/pdf/2105.05398 Sound, Precise, and Fast Abstract Interpretation with Tristate Numbers
+"""
+
+import kdrag as kd
+import kdrag.smt as smt
+import functools
+
+
+def Knowns(x):
+    return ~x.unknowns
+
+
+def Zeros(x):
+    return ~x.unknowns & ~x.ones
+
+
+def Concat(a, b):
+    """
+    >>> a = KB1.const(1) # 1
+    >>> b = KB1.const(0) # 0
+    >>> Concat(a, b)
+    KnownBits_2(Concat(ones(const(1)), ones(const(0))),
+            Concat(unknowns(const(1)), unknowns(const(0))))
+    """
+    sa = a.ones.size()
+    sb = b.ones.size()
+    return KB(sa + sb).T.mk(
+        smt.Concat(a.ones, b.ones), smt.Concat(a.unknowns, b.unknowns)
+    )
+
+
+class KnownBits:
+    def __init__(self, W):
+        self.W = W
+        KnownBits = kd.Struct(
+            f"KnownBits_{W}",
+            ("ones", smt.BitVecSort(W)),
+            ("unknowns", smt.BitVecSort(W)),
+        )
+        self.T = KnownBits
+        x, y, z = smt.Consts("x y z", KnownBits)
+        a, b, c = smt.Consts("a b c", smt.BitVecSort(W))
+
+        setof = kd.define(
+            "setof",
+            [x],
+            smt.Lambda([a], (~x.unknowns & a) == x.ones),
+        )
+        self.setof = setof
+        self.getitem = kd.notation.getitem.register(
+            KnownBits, lambda a, idx: setof(a)[idx]
+        )
+
+        kd.prove(KnownBits.mk(0, 0)[0], unfold=1)
+
+        self.wf = kd.notation.wf.define([x], (x.ones & x.unknowns) == 0)
+
+        const = kd.define("const", [a], KnownBits.mk(a, 0))
+        self.const = const
+        is_const = kd.define("is_const", [x], x.unknowns == 0)
+        self.is_const = is_const
+
+        self.set_const = kd.prove(smt.ForAll([a], const(a)[a]), unfold=1)
+
+        self.is_const_unique = kd.prove(
+            kd.QForAll(
+                [x], is_const(x), smt.Exists([a], kd.QForAll([b], x[b], a == b))
+            ),
+            unfold=1,
+        )
+
+        top = KnownBits.mk(0, -1)
+        self.set_top = kd.prove(smt.ForAll([a], top[a]), unfold=1)
+
+        zeros = kd.define("zeros", [x], Zeros(x))
+        self.zeros = zeros
+
+        invert = kd.notation.invert.define([x], KnownBits.mk(Zeros(x), x.unknowns))
+        self.invert = invert
+
+        self.invert_const = kd.prove(smt.ForAll([a], ~const(a) == const(~a)), unfold=1)
+        self.invert_top = kd.prove(~top == top, unfold=1)
+        self.invert_invol = kd.prove(kd.QForAll([x], invert(invert(x)) == x), unfold=1)
+        self.set_invert = kd.prove(kd.QForAll([x, a], x[a], (~x)[~a]), unfold=1)
+
+        _ones = x.ones & y.ones
+        _knowns = Zeros(x) | Zeros(y) | _ones
+        self.and_ = kd.notation.and_.define([x, y], KnownBits.mk(_ones, ~_knowns))
+
+        self.and_const = kd.prove(
+            kd.QForAll([a, b], const(a) & const(b) == const(a & b)), unfold=1
+        )
+        # and_top = kd.prove(kd.QForAll([x], x & top == ?), unfold=1)
+        self.and_comm = kd.prove(kd.QForAll([x, y], x & y == y & x), unfold=1)
+        self.and_assoc = kd.prove(
+            kd.QForAll([x, y, z], (x & y) & z == x & (y & z)), unfold=1
+        )
+        self.set_and = kd.prove(
+            kd.QForAll([x, y, a, b], x[a], y[b], (x & y)[a & b]), unfold=1
+        )
+
+        _ones = x.ones | y.ones
+        _zeros = Zeros(x) & Zeros(y)
+        _knowns = _ones | _zeros
+        self.or_ = kd.notation.or_.define([x, y], KnownBits.mk(_ones, ~_knowns))
+
+        self.or_const = kd.prove(
+            kd.QForAll([a, b], const(a) | const(b) == const(a | b)), unfold=1
+        )
+        # or_top = kd.prove(kd.QForAll([x], x | top == ?), unfold=1)
+        self.or_comm = kd.prove(kd.QForAll([x, y], x | y == y | x), unfold=1)
+        self.or_assoc = kd.prove(
+            kd.QForAll([x, y, z], (x | y) | z == x | (y | z)), unfold=1
+        )
+        self.set_or = kd.prove(
+            kd.QForAll([x, y, a, b], x[a], y[b], (x | y)[a | b]), unfold=1
+        )
+
+
+@functools.cache
+def KB(W):
+    return KnownBits(W)
+
+
+KB1 = KB(1)
+
+
+def test():
+    """
+    >>> True
+    True
+    >>> KB8 = KnownBits(8)
+    >>> KB1 = KnownBits(1)
+    """

kdrag/contrib/data_modulo/__init__.py

@@ -0,0 +1,6 @@
+"""
+Datastructures with symmetry
+- Sets
+- Multisets
+- Alpha
+"""

kdrag/contrib/expr/__init__.py

@@ -0,0 +1,113 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Context:
+    counter = 0
+
+
+_main_ctx = Context()
+
+
+def main_ctx():
+    return _main_ctx
+
+
+@dataclass
+class AstRef:
+    ctx: Context
+
+    def eq(self, other):
+        return self is other
+
+    def get_id(self):
+        return id(self)
+
+
+@dataclass
+class SortRef(AstRef):
+    _kind: object
+    _name: str
+
+    def kind(self):
+        return self._kind
+
+    def name(self):
+        return self._name
+
+
+@dataclass
+class TypeVarRef(AstRef):
+    pass
+
+
+@dataclass
+class FuncDeclRef(AstRef):
+    _name: str
+    _domain: tuple[SortRef, ...]
+    _range: SortRef
+
+    def name(self):
+        return self._name
+
+    def arity(self):
+        return len(self._domain)
+
+    def domain(self, i):
+        return self._domain[i]
+
+    def range(self):
+        return self._range
+
+    def __call__(self, *args):
+        assert len(args) == len(self._domain)
+        return ExprRef(ctx=self.ctx, _decl=self, _args=args)
+
+    # params. huh
+
+
+def Function(name, *sig, ctx=None):
+    assert len(sig) > 0
+    if ctx is None:
+        ctx = main_ctx()
+    return FuncDeclRef(ctx, name, sig[:-1], sig[-1])
+
+
+@dataclass
+class ExprRef(AstRef):
+    _decl: FuncDeclRef
+    _args: tuple[AstRef, ...]
+
+    def arg(self, i):
+        return self._args[i]
+
+    def children(self):
+        return list(self._args)
+
+    def decl(self):
+        return self._decl
+
+    def num_args(self):
+        return len(self._args)
+
+    def _sort(self):
+        return self._decl.range()
+
+    def __eq__(self, other):
+        raise NotImplementedError
+
+    def __ne__(self, other):
+        raise NotImplementedError
+
+
+def Const(name: str, sort: SortRef, ctx=None) -> ExprRef:
+    """ """
+    return Function(name, sort, ctx=ctx)()
+
+
+def Consts(names: str, sort: SortRef) -> list[ExprRef]:
+    return [Const(name, sort, ctx=sort.ctx) for name in names.split()]
+
+
+def FreshConst(sort: SortRef, prefix="c"):
+    return Const(prefix + "!" + str(sort.ctx.counter), sort)

kdrag/contrib/fast/.gitignore

@@ -0,0 +1 @@
+test

kdrag/contrib/fast/Makefile

@@ -0,0 +1,3 @@
+all: tests.c fast.c fast.h
+	gcc -Wextra -Wall -Werror -fanalyzer -g -fsanitize=address -fsanitize=undefined fast.c tests.c  -l z3 -o test
+	./test

kdrag/contrib/fast/__init__.py

@@ -0,0 +1,74 @@
+from cffi import FFI
+import tempfile
+import os
+import sys
+from pathlib import Path
+import z3
+
+ffibuilder = FFI()
+
+ffibuilder.cdef("""
+int myadd(int a, int b);
+const char* z3_version();
+typedef struct z3_config *Z3_config;
+typedef struct z3_context *Z3_context;
+typedef void *Z3_ast;
+typedef void *Z3_ast_vector;
+Z3_ast my_mk_true(Z3_context ctx);
+Z3_ast my_mk_and(Z3_context ctx, Z3_ast a, Z3_ast b);
+Z3_ast_vector KDRAG_get_consts(Z3_context ctx, Z3_ast t);
+""")
+z3lib = Path(z3.__file__).parent.absolute() / "lib"
+z3_include = Path(z3.__file__).parent.absolute() / "include"
+ffibuilder.set_source(
+    "_fast",
+    "",
+    sources=[str(Path(__file__).parent.absolute() / "fast.c")],
+    library_dirs=[str(z3lib)],
+    include_dirs=[str(z3_include)],
+    libraries=["z3"],
+)
+# shenangians to build in temp directory
+dir0 = os.getcwd()
+tmpdir = tempfile.mkdtemp()
+os.chdir(tmpdir)
+ffibuilder.compile(verbose=True)
+sys.path.insert(1, tmpdir)
+os.chdir(dir0)
+
+from _fast.lib import *  # noqa: E402, F403  # type: ignore
+
+
+def ctxptr(ctx: z3.Context):
+    return ffibuilder.cast("void *", ctx.ctx.value)  # type: ignore
+
+
+def astptr(ast: z3.AstRef):
+    return ffibuilder.cast("void *", ast.as_ast().value)  # type: ignore
+
+
+def intify(ptr):
+    return int(ffibuilder.cast("uintptr_t", ptr))
+
+
+def test():
+    """
+    >>> myadd(2, 3)
+    5
+    >>> ctx = ffibuilder.cast("void *", z3.main_ctx().ctx.value)
+    >>> ast = my_mk_true(ctx)
+    >>> value = intify(ast)
+    >>> z3.BoolRef(value)
+    True
+    >>> z3.BoolRef(intify(my_mk_and(ctx, ast, ast)))
+    And(True, True)
+    >>> z3.AstVector(intify(KDRAG_get_consts(ctx, ast)), z3.main_ctx())
+    [True]
+    >>> x = z3.Int("x")
+    >>> z3.AstVector(intify(KDRAG_get_consts(ctx, astptr(x + x + x))), z3.main_ctx())
+    [x]
+    """
+
+    # >>> intify(my_mk_and(ctx, ast, ast))
+    # >>> FFI().string(z3_version())
+    # >>> my_mk_true(ffibuilder.cast("Z3_context", z3.main_ctx().ctx.value))

kdrag/contrib/fast/fast.c

@@ -0,0 +1,76 @@
+#include "z3.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int myadd(int a, int b) { return a + b; }
+
+const char *hello = "hello from fast.c";
+const char *z3_version() {
+  puts(Z3_get_full_version());
+  char *test = (char *)malloc(sizeof(char) * 10);
+  if (!test)
+    return NULL;
+  test[0] = 'h';
+  test[1] = 'e';
+  test[2] = 'l';
+  test[3] = 'l';
+  test[4] = 'o';
+  test[5] = '\0';
+  strncpy(test, Z3_get_full_version(), 9);
+  return test; //
+               // return "hello"; // Z3_get_full_version();//hello;
+}
+
+Z3_ast my_mk_true(Z3_context ctx) { return Z3_mk_true(ctx); }
+
+Z3_ast my_mk_and(Z3_context ctx, Z3_ast a, Z3_ast b) {
+  Z3_ast args[2] = {a, b};
+  return Z3_mk_and(ctx, 2, args);
+}
+
+// https://stackoverflow.com/questions/27200320/maintenance-of-reference-counting-in-z3
+// https://github.com/Z3Prover/z3/blob/master/examples/c/test_capi.c
+Z3_ast_vector KDRAG_get_consts(Z3_context ctx, Z3_ast t) {
+  Z3_ast_vector res = Z3_mk_ast_vector(ctx);
+  Z3_ast_vector_inc_ref(ctx, res);
+  Z3_ast_vector todo = Z3_mk_ast_vector(ctx);
+  Z3_ast_vector_inc_ref(ctx, todo);
+  // todo: seen set
+  // Z3_ast_map seen = Z3_mk_ast_map(ctx);
+  // Z3_ast_map_inc_ref(ctx, seen);
+
+  Z3_ast_vector_push(ctx, todo, t);
+  Z3_inc_ref(ctx, t);
+  unsigned visited = 0;
+  while (visited < Z3_ast_vector_size(ctx, todo)) {
+    Z3_ast current = Z3_ast_vector_get(ctx, todo, visited);
+    if (Z3_is_app(ctx, current)) {
+      Z3_app app = Z3_to_app(ctx, current);
+      unsigned num_args = Z3_get_app_num_args(ctx, app);
+      if (num_args == 0) {  // possible constant
+        bool found = false; // already in res?
+        for (unsigned i = 0; i < Z3_ast_vector_size(ctx, res); i++) {
+          Z3_ast existing = Z3_ast_vector_get(ctx, res, i);
+          if (existing == current) {
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          Z3_inc_ref(ctx, current);
+          Z3_ast_vector_push(ctx, res, current);
+        }
+      } else { // push args to todo
+        for (unsigned j = 0; j < num_args; j++) {
+          Z3_ast arg = Z3_get_app_arg(ctx, app, j);
+          Z3_inc_ref(ctx, arg);
+          Z3_ast_vector_push(ctx, todo, arg);
+        }
+      }
+    }
+    Z3_dec_ref(ctx, current);
+    visited++;
+  }
+  Z3_ast_vector_dec_ref(ctx, todo);
+  return res;
+}

kdrag/contrib/fast/fast.h

@@ -0,0 +1,3 @@
+#include "z3.h"
+
+Z3_ast_vector KDRAG_get_consts(Z3_context ctx, Z3_ast t);

kdrag/contrib/fast/tests.c

@@ -0,0 +1,47 @@
+#include "fast.h"
+#include "z3.h"
+#include <assert.h>
+int main() {
+  Z3_config cfg = Z3_mk_config();
+  Z3_context ctx = Z3_mk_context_rc(cfg);
+  Z3_sort sort = Z3_mk_bool_sort(ctx);
+  Z3_symbol sym = Z3_mk_string_symbol(ctx, "x");
+
+  {
+    Z3_ast t = Z3_mk_const(ctx, sym, sort);
+    Z3_inc_ref(ctx, t);
+
+    {
+      Z3_ast_vector vec = KDRAG_get_consts(ctx, t);
+      unsigned size = Z3_ast_vector_size(ctx, vec);
+      assert(size == 1 && "there should be one constant");
+      for (unsigned i = 0; i < size; i++) {
+        Z3_ast ast = Z3_ast_vector_get(ctx, vec, i);
+        Z3_dec_ref(ctx, ast);
+      }
+      Z3_ast_vector_dec_ref(ctx, vec);
+    }
+
+    {
+      Z3_ast args[] = {t, t};
+      Z3_ast myand = Z3_mk_and(ctx, 2, args);
+      // Z3_inc_ref(ctx, myand);
+      Z3_ast_vector vec = KDRAG_get_consts(ctx, myand);
+      unsigned size = Z3_ast_vector_size(ctx, vec);
+      assert(size == 2 && "there should be two constants");
+      for (unsigned i = 0; i < size; i++) {
+        Z3_ast ast = Z3_ast_vector_get(ctx, vec, i);
+        assert(ast == t && "the constant should be t");
+        Z3_dec_ref(ctx, ast);
+      }
+      Z3_dec_ref(ctx, myand);
+      Z3_ast_vector_dec_ref(ctx, vec);
+    }
+
+    Z3_dec_ref(ctx, t);
+  }
+  Z3_del_context(ctx);
+  Z3_del_config(cfg);
+
+  return 0;
+}