tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Welcome to Knuckledragger!\n",
    "\n",
    "This tutorial can be used online at \n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](http://colab.research.google.com/github/philzook58/knuckledragger/blob/main/tutorial.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "test_skip"
    ]
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "git clone https://github.com/philzook58/knuckledragger.git\n",
    "cd knuckledragger\n",
    "python3 -m pip install -e ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "test_skip"
    ]
   },
   "outputs": [],
   "source": [
    "! cd knuckledragger && ./install.sh # get and build external solvers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intro to Z3\n",
    "\n",
    "Knuckledragger is heavily based around the prexisting SMT solver Z3. Knowing about Z3 is useful even if you aren't interested \n",
    "\n",
    "You can find a tutorial notebook and video I made here https://github.com/philzook58/z3_tutorial\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from z3 import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then declare our variables, state a set of constraints we wish to hold, and then call the convenience function solve to get a solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[y = 0, x = 7]\n"
     ]
    }
   ],
   "source": [
    "x = Int('x')\n",
    "y = Int('y')\n",
    "solve(x > 2, y < 10, x + 2*y == 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use z3 to prove properties and theorems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "p &rArr; p"
      ],
      "text/plain": [
       "Implies(p, p)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = Bool(\"p\")\n",
    "my_true_thm = Implies(p, p)\n",
    "my_true_thm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "proved\n"
     ]
    }
   ],
   "source": [
    "prove(my_true_thm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the property is not true, smt can supply a counterexample. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "q &rArr; p"
      ],
      "text/plain": [
       "Implies(q, p)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = Bool(\"q\")\n",
    "my_false_thm = Implies(q, p)\n",
    "my_false_thm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "counterexample\n",
      "[p = False, q = True]\n"
     ]
    }
   ],
   "source": [
    "prove(my_false_thm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Why Knuckledragger?\n",
    "\n",
    "Z3 is a tour de force. It's beautiful. However, it falls short of solving or verifying many kinds of problems we may be interested in.\n",
    "\n",
    "1. It may in principle be able to solve something, but times out\n",
    "2. Many mathematical and verification questions involve induction, which Z3 does not have strong built in support for. In general automating this is a tough problem\n",
    "3. We may want to spell out what Z3 can do for use automatically, to make sure we understand\n",
    "4. Z3 may not have good built in understanding of problem domains other systems like Mathematica and sympy do\n",
    "5. A systematic approach to hide or abstract things z3 should not care about\n",
    "\n",
    "For all these reasons, we may want a principled way to use Z3 to confirm \n",
    "\n",
    "In comes Knuckledragger.\n",
    "\n",
    "In principle, Knuckledragger is designed to be extremely minimalist. It can be implemented as a small number of idioms. There is a library however.\n",
    "\n",
    "1. Lots of little niceties. Pretty printing, useful combinators, tactics. The more easily you can write your statements, the more likely they are to correspond to what's in your head\n",
    "2. A library of axiomatized theories\n",
    "3. A bit of rigidity to guide you towards proofs that are more likely to be sound. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def axiom(thm):\n",
    "    return thm\n",
    "\n",
    "def lemma(thm,by=[]):\n",
    "    prove(Implies(And(by), thm))\n",
    "    return thm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Distinguishing between theorems to be proven and theorems that have been proven\n",
    "2. It is convenient and builds confidence to record a trace of the result coming in through these functions. These traces are recorded in a `Proof` tree which exactly reflects the call tree to `lemma` and `axiom` that produced to the Proof."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class Proof:\n",
    "    thm: z3.BoolRef\n",
    "    reasons: list[\"Proof\"]\n",
    "\n",
    "def axiom(thm):\n",
    "    return Proof(thm,[])\n",
    "\n",
    "def lemma(thm,by=[]):\n",
    "    assert all(isinstance(x,Proof) for x in by)\n",
    "    prove(Implies(And(by), thm))\n",
    "    return Proof(thm,by)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is in essence the contents of `knuckledragger.kernel`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Knuckledragger\n",
    "\n",
    "But this has been packaged up for you in the `knuckledragger` package alongside many other goodies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import kdrag as kd\n",
    "import kdrag.smt as smt # z3 is re-exported as kdrag.smt\n",
    "# or from kdrag.all import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = smt.DeclareSort(\"G\")\n",
    "inv = smt.Function(\"inv\", G, G)\n",
    "mul = smt.Function(\"mul\", G, G, G)\n",
    "kd.notation.mul.register(G, mul) # enables e * inv(e) notation\n",
    "e = smt.Const(\"e\", G)\n",
    "x,y,z = smt.Consts(\"x y z\", G)\n",
    "mul_assoc = kd.axiom(smt.ForAll([x,y,z], x * (y * z) == (x * y) * z))\n",
    "mul_id = kd.axiom(smt.ForAll([x], x * e == x))\n",
    "mul_inv = kd.axiom(smt.ForAll([x], x * inv(x) == e))\n",
    "\n",
    "group_db = [mul_assoc, mul_id, mul_inv]\n",
    "def glemma(thm,by=[]):\n",
    "    return kd.lemma(thm,by + group_db)\n",
    "\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}