989 lines
51 KiB
Plaintext
989 lines
51 KiB
Plaintext
{
|
|
"nbformat": 4,
|
|
"nbformat_minor": 0,
|
|
"metadata": {
|
|
"colab": {
|
|
"provenance": [],
|
|
"authorship_tag": "ABX9TyMjeWJ3+JkP3KO4xuarMyeL",
|
|
"include_colab_link": true
|
|
},
|
|
"kernelspec": {
|
|
"name": "python3",
|
|
"display_name": "Python 3"
|
|
},
|
|
"language_info": {
|
|
"name": "python"
|
|
}
|
|
},
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "view-in-github",
|
|
"colab_type": "text"
|
|
},
|
|
"source": [
|
|
"<a href=\"https://colab.research.google.com/github/udlbook/udlbook/blob/main/Trees/SAT_Construction_Answers.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"<img src=\"data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<svg width="764.45" height="63.759" version="1.1" viewBox="0 0 764.45 63.759" xmlns="http://www.w3.org/2000/svg">
 <g transform="matrix(.73548 0 0 .73548 0 3.388)" stroke-width="1.3597">
  <rect x="5e-7" y="5e-7" width="77.387" height="77.387" ry="11.35" fill="#4469d8" opacity=".98" stroke-width="0"/>
  <text x="10.330567" y="65.761719" fill="#ffffff" font-family="Courier" font-size="93.483px" stroke-width="1.3597" style="line-height:1.25" xml:space="preserve"><tspan x="10.330567" y="65.761719" fill="#ffffff" font-family="Courier" stroke-width="1.3597">I </tspan></text>
  <rect x="96" y="5e-7" width="77.387" height="77.387" ry="11.35" fill="#4469d8" opacity=".98" stroke-width="0"/>
  <text x="106.33057" y="65.761719" fill="#ffffff" font-family="Courier" font-size="93.483px" stroke-width="1.3597" style="line-height:1.25" xml:space="preserve"><tspan x="106.33057" y="65.761719" fill="#ffffff" font-family="Courier" stroke-width="1.3597">C </tspan></text>
  <rect x="180" y="5e-7" width="77.387" height="77.387" ry="11.35" fill="#4469d8" opacity=".98" stroke-width="0"/>
  <text x="190.33057" y="65.761719" fill="#ffffff" font-family="Courier" font-size="93.483px" stroke-width="1.3597" style="line-height:1.25" xml:space="preserve"><tspan x="190.33057" y="65.761719" fill="#ffffff" font-family="Courier" stroke-width="1.3597">L </tspan></text>
  <rect x="264" y="5e-7" width="77.387" height="77.387" ry="11.35" fill="#4469d8" opacity=".98" stroke-width="0"/>
  <text x="274.33057" y="65.761719" fill="#ffffff" font-family="Courier" font-size="93.483px" stroke-width="1.3597" style="line-height:1.25" xml:space="preserve"><tspan x="274.33057" y="65.761719" fill="#ffffff" font-family="Courier" stroke-width="1.3597">I </tspan></text>
  <rect x="348" y="5e-7" width="77.387" height="77.387" ry="11.35" fill="#4469d8" opacity=".98" stroke-width="0"/>
  <text x="358.33057" y="65.761719" fill="#ffffff" font-family="Courier" font-size="93.483px" stroke-width="1.3597" style="line-height:1.25" xml:space="preserve"><tspan x="358.33057" y="65.761719" fill="#ffffff" font-family="Courier" stroke-width="1.3597">M </tspan></text>
  <rect x="432" y="5e-7" width="77.387" height="77.387" ry="11.35" fill="#4469d8" opacity=".98" stroke-width="0"/>
  <text x="442.33057" y="65.761719" fill="#ffffff" font-family="Courier" font-size="93.483px" stroke-width="1.3597" style="line-height:1.25" xml:space="preserve"><tspan x="442.33057" y="65.761719" fill="#ffffff" font-family="Courier" stroke-width="1.3597">B </tspan></text>
  <g transform="translate(2 1.5376)">
   <rect x="624" y="-1.5376" width="77.387" height="77.387" ry="11.35" fill="#4469d8" opacity=".98" stroke-width="0"/>
   <text x="634.33057" y="64.224167" fill="#ffffff" font-family="Courier" font-size="93.483px" stroke-width="1.3597" style="line-height:1.25" xml:space="preserve"><tspan x="634.33057" y="64.224167" fill="#ffffff" font-family="Courier" stroke-width="1.3597">T </tspan></text>
   <rect x="708" y="-1.5376" width="77.387" height="77.387" ry="11.35" fill="#4469d8" opacity=".98" stroke-width="0"/>
   <text x="718.33057" y="64.224167" fill="#ffffff" font-family="Courier" font-size="93.483px" stroke-width="1.3597" style="line-height:1.25" xml:space="preserve"><tspan x="718.33057" y="64.224167" fill="#ffffff" font-family="Courier" stroke-width="1.3597">R </tspan></text>
   <rect x="792" y="-1.5376" width="77.387" height="77.387" ry="11.35" fill="#4469d8" opacity=".98" stroke-width="0"/>
   <text x="802.33057" y="64.224167" fill="#ffffff" font-family="Courier" font-size="93.483px" stroke-width="1.3597" style="line-height:1.25" xml:space="preserve"><tspan x="802.33057" y="64.224167" fill="#ffffff" font-family="Courier" stroke-width="1.3597">E</tspan></text>
   <rect x="876" y="-1.5376" width="77.387" height="77.387" ry="11.35" fill="#4469d8" opacity=".98" stroke-width="0"/>
   <text x="886.33057" y="64.224167" fill="#ffffff" font-family="Courier" font-size="93.483px" stroke-width="1.3597" style="line-height:1.25" xml:space="preserve"><tspan x="886.33057" y="64.224167" fill="#ffffff" font-family="Courier" stroke-width="1.3597">E </tspan></text>
   <rect x="960" y="-1.5376" width="77.387" height="77.387" ry="11.35" fill="#4469d8" opacity=".98" stroke-width="0"/>
   <text x="970.33057" y="64.224167" fill="#ffffff" font-family="Courier" font-size="93.483px" stroke-width="1.3597" style="line-height:1.25" xml:space="preserve"><tspan x="970.33057" y="64.224167" fill="#ffffff" font-family="Courier" stroke-width="1.3597">S </tspan></text>
  </g>
  <g transform="matrix(1.0499 0 0 1.0499 -28.092 -.27293)" fill="#4469d8" stroke="#fdffff">
   <rect x="528" y="-1.5376" width="77.387" height="77.387" ry="11.35" opacity=".98" stroke-width="5.18"/>
   <g transform="matrix(.74592 0 0 .74367 530.84 1.6744)" stroke-width="5.2162" featureKey="inlineSymbolFeature-0">
    <g fill="#4469d8" stroke="#fdffff" stroke-width="5.2162">
     <g fill="#4469d8" stroke="#fdffff" stroke-width="5.2162">
      <path d="m47.659 81.427c0.358-7.981 1.333-15.917 1.152-23.917-0.01-0.425-0.544-0.843-0.94-0.54-2.356 1.801-4.811 3.219-7.664 4.104-3.649 1.132-7.703-2.328-5.814-5.981 0.758-1.466 2.146-2.708 3.447-3.672 0.467-0.346 0.358-1.176-0.315-1.165-3.154 0.054-10.835 1.149-10.042-4.386 0.481-3.365 6.29-5.458 8.917-6.84 0.333-0.175 0.435-0.73 0.127-0.981-6.663-5.431-3.069-14.647 5.731-12.788 0.272 0.058 0.563-0.033 0.706-0.287 2.235-3.995 4.276-8.063 7.106-11.688-0.356-0.147-0.712-0.294-1.067-0.442 0.294 3.116 2.036 5.269 4.337 7.272 2.459 2.142 7.634 4.27 8.085 7.845 0.481 3.821-6.549 4.356-6.054 7.588 0.33 2.147 1.354 3.423 3.021 4.74 1.052 0.831 1.968 1.405 3.017 2.329 1.818 2.036 1.596 4.223-0.667 6.561-1.486 0.252-2.927 0.138-4.32-0.341-0.556-0.144-0.945 0.435-0.706 0.918 1.412 2.842 3.23 5.449 3.529 8.707 0.821 8.969-7.237 1.748-8.13 0.875-0.813-0.793-1.6-1.561-2.486-2.27-0.623-0.498-1.514 0.38-0.885 0.884 3.399 2.717 6.507 7.782 11.132 4.42 4.323-3.142-0.524-10.114-2.08-13.246-0.235 0.306-0.471 0.612-0.706 0.918 3.9 1.01 8.231 0.447 7.941-4.452-0.117-1.973-1.259-3.644-2.8-4.778-1.468-1.081-6.729-4.234-3.68-6.41 1.261-0.899 2.453-1.826 3.548-2.929 2.294-2.311 1.726-4.94-0.326-7.105-3.535-3.732-9.97-5.682-10.521-11.525-0.044-0.47-0.692-0.921-1.067-0.442-1.267 1.622-6.265 11.724-7.841 11.391-2.234-0.472-4.485 0.06-6.418 1.186-4.105 2.391-3.919 7.903-1.738 11.448 0.122 0.199 1.517 2.084 1.782 1.944-1.682 0.885-3.351 1.737-4.951 2.768-1.664 1.072-4.177 3.262-3.904 5.54 0.671 5.619 7.144 4.902 11.409 4.829-0.105-0.388-0.21-0.776-0.315-1.165-3.56 2.636-8.58 11.381-0.562 12.174 2.34 0.231 4.247-0.259 6.423-1.142 0.883-0.358 1.698-0.845 2.525-1.311 0.775-0.437 1.976-2.122 2.008-0.692 0.166 7.357-0.865 14.714-1.194 22.056-0.036 0.804 1.214 0.801 1.25-2e-3z" fill="#4469d8" stroke="#fdffff" stroke-linejoin="round" stroke-width="5.2162"/>
     </g>
     <g fill="#4469d8" stroke="#fdffff" stroke-width="5.2162">
      <path d="m22.301 83.156c-0.441-6.032-1.072-12.618 0.266-18.564 0.138-0.613-0.578-1.042-1.045-0.608-1.743 1.625-3.443 2.831-5.732 3.604-6.34-3.393-7.913-6.373-4.717-8.939 0.988-0.856 2.034-1.633 3.139-2.329 0.287-0.191 0.397-0.544 0.225-0.855-0.658-1.178-1.392-2.163-2.251-3.191-4.397-5.264-0.382-9.414 4.759-10.875 0.271-0.077 0.455-0.322 0.459-0.603 0.036-2.864 0.313-5.642 1.094-8.407 1.865-6.606 10.255-9.181 13.143-1.487 0.28 0.748 1.489 0.424 1.205-0.332-2.517-6.706-9.574-7.649-13.918-2.003-2.305 2.996-2.61 7.466-2.759 11.084-0.035 0.85-3.839 2.269-4.496 2.694-1.034 0.669-2.219 2.098-2.45 3.312-0.808 4.233 1.103 6.056 3.512 9.323 0.405 0.548-5.327 5.252-5.317 7.279 0.016 3.468 2.455 5.64 5.605 6.645 3.404 1.086 7.127-1.932 9.386-4.037-0.349-0.203-0.697-0.405-1.045-0.608-1.368 6.079-0.762 12.734-0.311 18.896 0.056 0.8 1.306 0.806 1.248 1e-3z" fill="#4469d8" stroke="#fdffff" stroke-linejoin="round" stroke-width="5.2162"/>
     </g>
     <g fill="#4469d8" stroke="#fdffff" stroke-width="5.2162">
      <path d="m21.424 64.741c1.983 2.707 4.981 4.199 8.349 3.637 3.594-0.6 5.191-4.13 5.291-7.411 0.024-0.807-1.226-0.804-1.25 0-0.202 6.67-7.523 8.313-11.31 3.143-0.472-0.643-1.557-0.02-1.08 0.631z" fill="#4469d8" stroke="#fdffff" stroke-width="5.2162"/>
     </g>
     <g fill="#4469d8" stroke="#fdffff" stroke-width="5.2162">
      <path d="m74.661 80.878c2.869-5.406 3.251-12.191 2.679-18.182-0.036-0.381-0.375-0.742-0.791-0.603-1.482 0.496-9.677 1.84-5.634-4.557 0.251-0.397-0.075-0.952-0.54-0.94-4.913 0.123-9.233-0.937-9.57-6.683-0.047-0.801-1.297-0.806-1.25 0 0.201 3.426 1.375 5.828 4.622 7.214 1.514 0.646 3.278 0.7 4.894 0.751-0.658-0.021-0.338 3.074-0.216 3.489 0.625 2.13 4.101 2.773 5.896 2.466 2.606-0.446 1.551 3.288 1.477 5.177-0.15 3.833-0.832 7.82-2.646 11.236-0.378 0.713 0.701 1.345 1.079 0.632z" fill="#4469d8" stroke="#fdffff" stroke-width="5.2162"/>
     </g>
     <g fill="#4469d8" stroke="#fdffff" stroke-width="5.2162">
      <path d="m76.881 63.299c3.341-0.618 7.425-1.372 7.423-5.67 0-1.473-0.141-3.462-1.403-4.486 0.524 0.425 2.703-1.287 3.381-1.885 5.097-4.499 1.607-12.585-4.301-13.85-0.222-0.047 2.216-4.5 2.515-5.157 0.832-1.834 0.614-3.634-8e-3 -5.472-1.133-3.347-6.327-9.06-10.153-9.283-1.411-0.082-2.449-0.077-3.515 0.881-1.212 1.09 0.842 3.98-1.963 2.484-4.82-2.573-5.125 2.25-7.856 4.852-0.584 0.557 0.301 1.439 0.885 0.884 1.199-1.143 0.961-0.736 1.574-2.026 2.202-4.641 4.768-2.589 7.178-1.388 0.334 0.167 0.839 0.047 0.918-0.374 0.208-1.098 0.205-1.025 0.186-2.169 2.787-1.84 5.084-1.596 6.891 0.731 0.745 0.715 1.449 1.469 2.113 2.261 4.874 5.507 2.097 8.833-0.535 13.968-0.228 0.445 0.06 0.897 0.54 0.94 8.368 0.749 8.684 11.983 0.698 13.757-0.432 0.096-0.64 0.75-0.276 1.044 4.99 4.046-0.386 7.969-4.622 8.753-0.794 0.147-0.458 1.351 0.33 1.205z" fill="#4469d8" stroke="#fdffff" stroke-linejoin="round" stroke-width="5.2162"/>
     </g>
    </g>
   </g>
  </g>
 </g>
</svg>
\">"
|
|
],
|
|
"metadata": {
|
|
"id": "jv83sxEU2Ig0"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"# SAT Constructions\n",
|
|
"\n",
|
|
"The purpose of this Python notebook is to use investigate SAT constructions that impose constraints on sets of variables. We'll build constructions for ensuring all of the variables are the same, that only one of the variables is true, that at leats $K$ of the variables are true, that fewer than $K$ of the variables are true and that exactly $K$ of the variables are true.\n",
|
|
"\n",
|
|
"You can save a local copy of this notebook in your Google account and work through it in Colab (recommended) or you can download the notebook and run it locally using Jupyter notebook or similar.\n",
|
|
"\n",
|
|
"Contact me at iclimbtreesmail@gmail.com if you find any mistakes or have any suggestions."
|
|
],
|
|
"metadata": {
|
|
"id": "IsBSW40O20Hv"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"id": "WZYb15hc19es",
|
|
"colab": {
|
|
"base_uri": "https://localhost:8080/"
|
|
},
|
|
"outputId": "d95ed66f-a8f7-422a-c6f4-1401d6bd06a5"
|
|
},
|
|
"outputs": [
|
|
{
|
|
"output_type": "stream",
|
|
"name": "stdout",
|
|
"text": [
|
|
"Collecting z3-solver\n",
|
|
" Downloading z3_solver-4.14.1.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (602 bytes)\n",
|
|
"Downloading z3_solver-4.14.1.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (29.5 MB)\n",
|
|
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m29.5/29.5 MB\u001b[0m \u001b[31m20.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
|
|
"\u001b[?25hInstalling collected packages: z3-solver\n",
|
|
"Successfully installed z3-solver-4.14.1.0\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"!pip install z3-solver\n",
|
|
"from z3 import *\n",
|
|
"import numpy as np\n",
|
|
"from itertools import combinations"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"# Same\n",
|
|
"\n",
|
|
"Let's write a subroutine that returns a Boolean logic formula that constrains $N$ variables to be the same.\n",
|
|
"\n",
|
|
"$$ \\textrm{Same}[x_{1},x_{2},x_{3},\n",
|
|
"\\ldots x_{N}]:= (x_{1}\\land x_{2}\\land x_{3},\\ldots,x_N)\\lor(\\overline{x}_{1}\\land \\overline{x}_{2}\\land \\overline{x}_{3},\\ldots,\\overline{x}_N).$$"
|
|
],
|
|
"metadata": {
|
|
"id": "aVj9RmuB3ZWJ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"First let's define the variables. We'll choose $N=10$"
|
|
],
|
|
"metadata": {
|
|
"id": "Amv5G3VR3zIJ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"N=10\n",
|
|
"x = [ z3.Bool(\"x_{i}\".format(i=i)) for i in range(0,N) ]\n",
|
|
"print(x)"
|
|
],
|
|
"metadata": {
|
|
"id": "J-y3uhTs-LU7"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Now let's write the main routine. We can make use of the fact that the Z3 command 'Or' which combines together a list of literals with Or operations."
|
|
],
|
|
"metadata": {
|
|
"id": "4pY5yiDo-esv"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"# Routine that returns the SAT construction (a Boolean logic formula) for all literals in x being the same.\n",
|
|
"def same(x):\n",
|
|
" return Or(And(x), And([Not(xi) for xi in x]))"
|
|
],
|
|
"metadata": {
|
|
"id": "f0esE71E94fm"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Finally, let's test that our routine works. Here's generic routine that evaluates a vector of concrete values against a provided Boolean logic formula\n"
|
|
],
|
|
"metadata": {
|
|
"id": "EWTuxEvrAfnK"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"def check_expression(x, formula, literals):\n",
|
|
" # Create the solver\n",
|
|
" s = Solver()\n",
|
|
" # Add the constraint\n",
|
|
" s.add(formula(x))\n",
|
|
" # Add the literals\n",
|
|
" s.add(And([x[i] if literal else Not(x[i]) for i, literal in enumerate(literals)]))\n",
|
|
" # Check if it's SAT (creates the model)\n",
|
|
" sat_result = s.check()\n",
|
|
" if(sat_result==sat):\n",
|
|
" print(\"True\")\n",
|
|
" else:\n",
|
|
" print(\"False\")"
|
|
],
|
|
"metadata": {
|
|
"id": "vY5CD6lRArNP"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"check_expression(x, same, [False,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, same, [True,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, same, [False,False,False,True,False,False,True,False,True,False])\n",
|
|
"check_expression(x, same, [True,True,True,True,True,True,True,True,True,True])"
|
|
],
|
|
"metadata": {
|
|
"id": "Q3VMIDqfHEei"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"# Exactly One\n",
|
|
"\n",
|
|
"Now let's write a subroutine that returns a Boolean logic formula that is true when only one of the provided variables are the same.\n",
|
|
"\n",
|
|
"First, we write a formula that ensures at least one of the variables is true:\n",
|
|
"\n",
|
|
"$$\\textrm{AtLeastOne}[x_1,x_2,x_3]:= x_{1}\\lor x_{2} \\lor x_{3}, \\ldots, x_{N}.$$\n",
|
|
"\n",
|
|
"Then, we write a formula that ensures that no more than one is true. For each possible pair of literals, we ensure that they are not both true:\n",
|
|
"\n",
|
|
"$$\\textrm{NoMoreThanOne}[x_{1},x_{2},x_{3}]:= \\lnot (x_{1}\\land x_{2}) \\land \\lnot (x_{1}\\land x_{3}),\\ldots, \\land \\lnot (x_{n-1}\\land x_{N}) $$\n",
|
|
"\n",
|
|
"Finally, we **AND** together these two formulae:\n",
|
|
"\n",
|
|
"$$\\textrm{ExactlyOne}[x_1,x_2,x_3,\\ldots, x_N] = \\textrm{AtLeastOne}[x_1,x_2,x_3, \\ldots, x_N]\\land\\textrm{NoMoreThanOne}[x_1,x_2,x_3, \\ldots x_N]$$\n",
|
|
"\n",
|
|
"You might want to use the function \"combinations\" from itertools (imported above). Example usage:"
|
|
],
|
|
"metadata": {
|
|
"id": "0IIRG5ZWIZV6"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"test = [ z3.Bool(\"x_{i}\".format(i=i)) for i in range(0,4) ]\n",
|
|
"for comb in combinations(test, 2):\n",
|
|
" print(comb[0], comb[1])"
|
|
],
|
|
"metadata": {
|
|
"id": "joeZiDT3LV-r"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"def at_least_one(x):\n",
|
|
" return Or(x)\n",
|
|
"\n",
|
|
"def no_more_than_one(x):\n",
|
|
" clauses = True ;\n",
|
|
" for comb in combinations(x, 2):\n",
|
|
" clauses = And([clauses, Or([Not(comb[0]), Not(comb[1])]) ])\n",
|
|
" return clauses\n",
|
|
"\n",
|
|
"def exactly_one(x):\n",
|
|
" return And(at_least_one(x), no_more_than_one(x))"
|
|
],
|
|
"metadata": {
|
|
"id": "C0HGBOjI99Ex"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Let's test if this works:"
|
|
],
|
|
"metadata": {
|
|
"id": "2Y_1zYOZIoZI"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"check_expression(x, exactly_one, [False,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, exactly_one, [True,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, exactly_one, [False,False,False,True,False,False,True,False,True,False])\n",
|
|
"check_expression(x, exactly_one, [True,True,True,True,True,True,True,True,True,True])"
|
|
],
|
|
"metadata": {
|
|
"id": "31gqasHnM3c3"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"# At least K\n",
|
|
"\n",
|
|
"Finally, we'll build the construction that ensures that there at at least K elements that are true in a vector of length N.\n",
|
|
"\n",
|
|
"This one is a bit more complicated. We construct an NxK matrix of new literals $r_{i,j}$ Then we add the following constraints.\n",
|
|
"\n",
|
|
"1. Top left element $r_{0,0}$ is the first data element\n",
|
|
"\n",
|
|
"$$ r_{00} \\Leftrightarrow x_{1}$$\n",
|
|
"\n",
|
|
"2. Remaining elements $r_{0,1:}$ must be false\n",
|
|
"\n",
|
|
"$$ \\overline{r}_{0,j} \\quad\\quad \\forall j\\in\\{1,2,\\ldots K-1\\}$$\n",
|
|
"\n",
|
|
"3. Remaining elements $r_{i,0}$ in first column are true where x_i is true\n",
|
|
"\n",
|
|
"$$x_i \\Rightarrow r_{i,0} \\quad\\quad \\forall i\\in\\{1,2,\\ldots N-1\\}$$\n",
|
|
"\n",
|
|
"4. For rows 1:N-1, if the element above is true, this must be true\n",
|
|
"\n",
|
|
"$$ r_{i-1,j} \\Rightarrow r_{i,j}\\quad\\quad \\quad\\quad \\forall i\\in\\{1,2,\\ldots N-1\\}, j\\in\\{0,1,\\ldots,K-1\\}$$\n",
|
|
"\n",
|
|
"5. If x is true for this row and the element above and to the left is true then set this element to true.\n",
|
|
"\n",
|
|
"$$ (x_i \\land r_{i-1,j-1})\\Rightarrow r_{i,j} \\quad\\quad \\forall i\\in\\{1,2,\\ldots N-1\\}, j\\in\\{1,2,\\ldots,K-1\\} $$\n",
|
|
"\n",
|
|
"6. If x is false for this row and the element above is false then set to false\n",
|
|
"\n",
|
|
"$$ (\\overline{x}_{i} \\land \\overline{r}_{i-1,j}) \\Rightarrow \\overline{r}_{i,j} \\quad\\quad \\forall i\\in\\{1,2,\\ldots N-1\\}, j\\in\\{1,2,\\ldots,K-1\\} $$\n",
|
|
"\n",
|
|
"7. if x is false for this row and the element above and to the left is false then set to false:\n",
|
|
"\n",
|
|
"$$ (\\overline{x}_i \\land \\overline{r}_{i-1,j-1})\\Rightarrow \\overline{r}_{i,j} \\quad\\quad \\forall i\\in\\{1,2,\\ldots N-1\\}, j\\in\\{1,2,\\ldots,K-1\\} $$\n",
|
|
"\n",
|
|
"8. The bottom-right element of r must be true\n",
|
|
"\n",
|
|
"$$ r_{N-1,K-1}$$"
|
|
],
|
|
"metadata": {
|
|
"id": "MJqWOMBsQrCI"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"def at_least_k(x, K):\n",
|
|
" # Create nxk table of literals r_{i,j}\n",
|
|
" N = len(x) ;\n",
|
|
" r = [[ z3.Bool(\"r_{%d,%d}\"%((i,j))) for j in range(0,K) ] for i in range(0,N) ]\n",
|
|
"\n",
|
|
" #1. Top left element $r_{0,0}$ is the first data element\n",
|
|
"\n",
|
|
" clauses = (r[0][0] == x[0])\n",
|
|
"\n",
|
|
" #2. Remaining elements $r_{0,1:}$ must be false\n",
|
|
"\n",
|
|
" clauses = And(clauses, And([ Not(r[0][j]) for j in range(1,K) ]))\n",
|
|
"\n",
|
|
" #3. Remaining elements $r_{i,0}$ in first column are true where x_i is true\n",
|
|
" clauses = And(clauses, And([Implies(x[i],r[i][0]) for i in range(1,N)]))\n",
|
|
"\n",
|
|
" #4. For rows 1:n-1, if the element above is true, this must be true\n",
|
|
"\n",
|
|
" for i in range(1,N):\n",
|
|
" for j in range(0,K):\n",
|
|
" clauses = And(clauses, Implies(r[i-1][j], r[i][j]))\n",
|
|
"\n",
|
|
" #5. If x is true for this row and the element above and to the left is true then set this element to true.\n",
|
|
" #6. If x is false for this row and the element above is false then set to false\n",
|
|
" #7. if x is false for this row and the element above and to the left is false then set to false:\n",
|
|
" for i in range(1,N):\n",
|
|
" for j in range(1,K):\n",
|
|
" clauses = And(clauses, Implies(And(x[i], r[i-1][j-1]), r[i][j]))\n",
|
|
" clauses = And(clauses, Implies(And(Not(x[i]), Not(r[i-1][j])), Not(r[i][j])))\n",
|
|
" clauses = And(clauses, Implies(And(Not(x[i]), Not(r[i-1][j-1])), Not(r[i][j])))\n",
|
|
"\n",
|
|
" #8. The bottom-right element of r must be true\n",
|
|
" clauses = And(clauses, r[N-1][K-1])\n",
|
|
"\n",
|
|
" return clauses"
|
|
],
|
|
"metadata": {
|
|
"id": "aTcc1Ad0M9NX"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"#This function defined for convenience so that check_expression works\n",
|
|
"def at_least_three(x):\n",
|
|
" return at_least_k(x,3)\n",
|
|
"\n",
|
|
"check_expression(x, at_least_three, [False,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, at_least_three, [True,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, at_least_three, [False,False,False,True,False,False,True,False,True,False])\n",
|
|
"check_expression(x, at_least_three, [True,True,True,True,True,True,True,True,True,True])"
|
|
],
|
|
"metadata": {
|
|
"id": "ESnui2V7YBQC"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Optional: write functions to test if there are:\n",
|
|
"\n",
|
|
"* Fewer than $K$ elements\n",
|
|
"* Exactly $N$ elements\n",
|
|
"\n"
|
|
],
|
|
"metadata": {
|
|
"id": "PwgpncA5g0-C"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"def fewer_than_k(x, K):\n",
|
|
" # Create nxk table of literals r_{i,j}\n",
|
|
" N = len(x) ;\n",
|
|
" r = [[ z3.Bool(\"r_{%d,%d}\"%((i,j))) for j in range(0,K) ] for i in range(0,N) ]\n",
|
|
"\n",
|
|
" #1. Top left element $r_{0,0}$ is the first data element\n",
|
|
"\n",
|
|
" clauses = (r[0][0] == x[0])\n",
|
|
"\n",
|
|
" #2. Remaining elements $r_{0,1:}$ must be false\n",
|
|
"\n",
|
|
" clauses = And(clauses, And([ Not(r[0][j]) for j in range(1,K) ]))\n",
|
|
"\n",
|
|
" #3. Remaining elements $r_{i,0}$ in first column are true where x_i is true\n",
|
|
" clauses = And(clauses, And([Implies(x[i],r[i][0]) for i in range(1,N)]))\n",
|
|
"\n",
|
|
" #4. For rows 1:n-1, if the element above is true, this must be true\n",
|
|
" for i in range(1,N):\n",
|
|
" for j in range(0,K):\n",
|
|
" clauses = And(clauses, Implies(r[i-1][j], r[i][j]))\n",
|
|
"\n",
|
|
" #5. If x is true for this row and the element above and to the left is true then set this element to true.\n",
|
|
" #6. If x is false for this row and the element above is false then set to false\n",
|
|
" #7. if x is false for this row and the element above and to the left is false then set to false:\n",
|
|
" for i in range(1,N):\n",
|
|
" for j in range(1,K):\n",
|
|
" clauses = And(clauses, Implies(And(x[i], r[i-1][j-1]), r[i][j]))\n",
|
|
" clauses = And(clauses, Implies(And(Not(x[i]), Not(r[i-1][j])), Not(r[i][j])))\n",
|
|
" clauses = And(clauses, Implies(And(Not(x[i]), Not(r[i-1][j-1])), Not(r[i][j])))\n",
|
|
"\n",
|
|
" #8. The bottom-right element of r must be false\n",
|
|
" clauses = And(clauses, Not(r[N-1][K-1]))\n",
|
|
"\n",
|
|
" return clauses"
|
|
],
|
|
"metadata": {
|
|
"id": "RS31wg5Ig0f-"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"#This function defined for convenience so that check_expression works\n",
|
|
"def fewer_than_three(x):\n",
|
|
" return fewer_than_k(x,3)\n",
|
|
"\n",
|
|
"check_expression(x, fewer_than_three, [False,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, fewer_than_three, [True,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, fewer_than_three, [False,False,False,True,False,False,True,False,True,False])\n",
|
|
"check_expression(x, fewer_than_three, [True,True,True,True,True,True,True,True,True,True])"
|
|
],
|
|
"metadata": {
|
|
"id": "Sy67NXs7hqDS"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"def exactly_k(x, K):\n",
|
|
" # Create n x (k+1) table of literals r_{i,j}\n",
|
|
" N = len(x) ;\n",
|
|
" r = [[ z3.Bool(\"r_{%d,%d}\"%((i,j))) for j in range(0,K+1) ] for i in range(0,N) ]\n",
|
|
"\n",
|
|
" #1. Top left element $r_{0,0}$ is the first data element\n",
|
|
"\n",
|
|
" clauses = (r[0][0] == x[0])\n",
|
|
"\n",
|
|
" #2. Remaining elements $r_{0,1:}$ must be false\n",
|
|
"\n",
|
|
" clauses = And(clauses, And([ Not(r[0][j]) for j in range(1,K+1) ]))\n",
|
|
"\n",
|
|
" #3. Remaining elements $r_{i,0}$ in first column are true where x_i is true\n",
|
|
" clauses = And(clauses, And([Implies(x[i],r[i][0]) for i in range(1,N)]))\n",
|
|
"\n",
|
|
" #4. For rows 1:n-1, if the element above is true, this must be true\n",
|
|
" for i in range(1,N):\n",
|
|
" for j in range(0,K+1):\n",
|
|
" clauses = And(clauses, Implies(r[i-1][j], r[i][j]))\n",
|
|
"\n",
|
|
" #5. If x is true for this row and the element above and to the left is true then set this element to true.\n",
|
|
" #6. If x is false for this row and the element above is false then set to false\n",
|
|
" #7. if x is false for this row and the element above and to the left is false then set to false:\n",
|
|
" for i in range(1,N):\n",
|
|
" for j in range(1,K+1):\n",
|
|
" clauses = And(clauses, Implies(And(x[i], r[i-1][j-1]), r[i][j]))\n",
|
|
" clauses = And(clauses, Implies(And(Not(x[i]), Not(r[i-1][j])), Not(r[i][j])))\n",
|
|
" clauses = And(clauses, Implies(And(Not(x[i]), Not(r[i-1][j-1])), Not(r[i][j])))\n",
|
|
"\n",
|
|
" #8. The bottom-right element of r must be\n",
|
|
" clauses = And(clauses, r[N-1][K-1])\n",
|
|
" clauses = And(clauses, Not(r[N-1][K]))\n",
|
|
"\n",
|
|
" return clauses"
|
|
],
|
|
"metadata": {
|
|
"id": "Fzaa1NoaicKT"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"#This function defined for convenience so that check_expression works\n",
|
|
"def exactly_three(x):\n",
|
|
" return exactly_k(x,3)\n",
|
|
"\n",
|
|
"check_expression(x, exactly_three, [False,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, exactly_three, [True,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, exactly_three, [False,False,False,True,False,False,True,False,True,False])\n",
|
|
"check_expression(x, exactly_three, [True,True,True,True,True,True,True,True,True,True])"
|
|
],
|
|
"metadata": {
|
|
"id": "L_xwfybUkKhw"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Now that we've finished, I'll let you into a secret. Z3 actually contains routines for (AtLeast, FewerThanOrEqualToo, and Exactly)"
|
|
],
|
|
"metadata": {
|
|
"id": "H3lipx8akmHp"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"def at_least_k_z3(x,K):\n",
|
|
" return PbGe([(i,1) for i in x],K)\n",
|
|
"\n",
|
|
"def at_least_three_z3(x):\n",
|
|
" return at_least_k_z3(x,3)\n",
|
|
"\n",
|
|
"check_expression(x, at_least_three_z3, [False,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, at_least_three_z3, [True,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, at_least_three_z3, [False,False,False,True,False,False,True,False,True,False])\n",
|
|
"check_expression(x, at_least_three_z3, [True,True,True,True,True,True,True,True,True,True])"
|
|
],
|
|
"metadata": {
|
|
"id": "Yho3WtG0luM6"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"def fewer_than_k_z3(x,K):\n",
|
|
" return PbLe([(i,1) for i in x],K-1)\n",
|
|
"\n",
|
|
"def fewer_than_three_z3(x):\n",
|
|
" return fewer_than_k_z3(x,3)\n",
|
|
"\n",
|
|
"check_expression(x, fewer_than_three_z3, [False,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, fewer_than_three_z3, [True,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, fewer_than_three_z3, [False,False,False,True,False,False,True,False,True,False])\n",
|
|
"check_expression(x, fewer_than_three_z3, [True,True,True,True,True,True,True,True,True,True])"
|
|
],
|
|
"metadata": {
|
|
"id": "ZjAMpiNFmJPc"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"def exactly_k_z3(x,K):\n",
|
|
" return PbEq([(i,1) for i in x],K)\n",
|
|
"\n",
|
|
"def exactly_three_z3(x):\n",
|
|
" return exactly_k_z3(x,3)\n",
|
|
"\n",
|
|
"check_expression(x, exactly_three_z3, [False,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, exactly_three_z3, [True,False,False,False,False,False,False,False,False,False])\n",
|
|
"check_expression(x, exactly_three_z3, [False,False,False,True,False,False,True,False,True,False])\n",
|
|
"check_expression(x, exactly_three_z3, [True,True,True,True,True,True,True,True,True,True])"
|
|
],
|
|
"metadata": {
|
|
"id": "EgG6jGAskUze"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"# Connected components\n",
|
|
"\n",
|
|
"Finally, let's develop a construction that tells us if the elements of an undirected graph are connected. Consider the two adjacency matrices:\n",
|
|
"\n",
|
|
"\\begin{equation}\n",
|
|
"A_1 = \\begin{bmatrix}1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n",
|
|
" 1 & 1 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n",
|
|
" 0 & 1 & 1 & 1 & 0 & 0 & 0 & 0 \\\\\n",
|
|
" 0 & 0 & 1 & 1 & 1 & 0 & 0 & 0 \\\\\n",
|
|
" 0 & 0 & 0 & 1 & 1 & 1 & 0 & 0 \\\\\n",
|
|
" 0 & 0 & 0 & 0 & 1 & 1 & 1 & 0 \\\\\n",
|
|
" 0 & 0 & 0 & 0 & 0 & 1 & 1 & 1 \\\\\n",
|
|
" 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 \\\\\n",
|
|
" \\end{bmatrix} \\quad\\quad\n",
|
|
" A_2 = \\begin{bmatrix}1 & 1 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n",
|
|
" 1 & 1 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n",
|
|
" 0 & 1 & 1 & 1 & 0 & 0 & 0 & 0 \\\\\n",
|
|
" 1 & 0 & 1 & 1 & 1 & 0 & 0 & 0 \\\\\n",
|
|
" 0 & 0 & 0 & 1 & 1 & 1 & 0 & 0 \\\\\n",
|
|
" 0 & 0 & 0 & 0 & 1 & 1 & 0 & 0 \\\\\n",
|
|
" 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 \\\\\n",
|
|
" 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 \\\\\n",
|
|
" \\end{bmatrix}\n",
|
|
"\\end{equation}\n",
|
|
"\n",
|
|
"Each matrix represents the edges in a graph containing eight nodes. Elements $(i,j)$ and $(j,i)$ will be set to one if there is an edge between nodes $i$ and $j$. The diagonal elements are all set to one.\n",
|
|
"\n",
|
|
"For matrix $A_{1}$ the nodes are all connected; node 1 connects to node 2, which connects to node 3, and so on up to node 8. \n",
|
|
"\n",
|
|
"For matrix $A_{2}$ however, the nodes are not all connected. Nodes 7 and 8 are connected to each other but not connected any of the other nodes.\n",
|
|
"\n",
|
|
"We can test this by multiplying any adjacency matrix of size $N\\times N$ by itself $N-1$ times (or more). If the resulting matrix contains all non-zero elements then the graph was fully connected. If there are any zeros, then the graph is not fully connected. Let's try that for these two matrices.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "CZQygtit0D9Q"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"A1 = np.array([[1,1,0,0,0,0,0,0],\\\n",
|
|
" [1,1,1,0,0,0,0,0],\\\n",
|
|
" [0,1,1,1,0,0,0,0],\\\n",
|
|
" [0,0,1,1,1,0,0,0],\\\n",
|
|
" [0,0,0,1,1,1,0,0],\\\n",
|
|
" [0,0,0,0,1,1,1,0],\\\n",
|
|
" [0,0,0,0,0,1,1,1],\\\n",
|
|
" [0,0,0,0,0,0,1,1],])\n",
|
|
"\n",
|
|
"A2 = np.array([[1,1,0,1,0,0,0,0],\\\n",
|
|
" [1,1,1,0,0,0,0,0],\\\n",
|
|
" [0,1,1,1,0,0,0,0],\\\n",
|
|
" [1,0,1,1,1,0,0,0],\\\n",
|
|
" [0,0,0,1,1,1,0,0],\\\n",
|
|
" [0,0,0,0,1,1,0,0],\\\n",
|
|
" [0,0,0,0,0,0,1,1],\\\n",
|
|
" [0,0,0,0,0,0,1,1],])\n",
|
|
"\n",
|
|
"\n",
|
|
"print(\"Matrix A1 is fully connected. Product does not contain any zeros :\\n\\n\",A1@A1@A1@A1@A1@A1@A1)\n",
|
|
"print(\"\\nMatrix A2 is not fully connected. Product contains zeros :\\n\\n\",A2@A2@A2@A2@A2@A2@A2)"
|
|
],
|
|
"metadata": {
|
|
"colab": {
|
|
"base_uri": "https://localhost:8080/"
|
|
},
|
|
"id": "ywLO1nan2_6K",
|
|
"outputId": "4704aab6-a155-4bd3-857d-d4a6c3b38947"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": [
|
|
{
|
|
"output_type": "stream",
|
|
"name": "stdout",
|
|
"text": [
|
|
"Matrix A1 is fully connected. Product does not contain any zeros :\n",
|
|
"\n",
|
|
" [[127 196 189 133 70 27 7 1]\n",
|
|
" [196 316 329 259 160 77 28 7]\n",
|
|
" [189 329 386 356 266 161 77 27]\n",
|
|
" [133 259 356 393 357 266 160 70]\n",
|
|
" [ 70 160 266 357 393 356 259 133]\n",
|
|
" [ 27 77 161 266 356 386 329 189]\n",
|
|
" [ 7 28 77 160 259 329 316 196]\n",
|
|
" [ 1 7 27 70 133 189 196 127]]\n",
|
|
"\n",
|
|
"Matrix A2 is not fully connected. Product contains zeros :\n",
|
|
"\n",
|
|
" [[ 652 609 651 800 441 191 0 0]\n",
|
|
" [ 609 575 609 728 382 154 0 0]\n",
|
|
" [ 651 609 652 800 441 191 0 0]\n",
|
|
" [ 800 728 800 1016 609 287 0 0]\n",
|
|
" [ 441 382 441 609 421 227 0 0]\n",
|
|
" [ 191 154 191 287 227 134 0 0]\n",
|
|
" [ 0 0 0 0 0 0 64 64]\n",
|
|
" [ 0 0 0 0 0 0 64 64]]\n"
|
|
]
|
|
}
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"In fact we could do this a bit more efficiently, by first calculating $B = A^2$ and then computing $C = B^2 = A^4$ and finally $D=C^2 = A^8$. In this way, we only need $\\log[N]$ multiplications to check the graph is connected."
|
|
],
|
|
"metadata": {
|
|
"id": "SRQTzwSn4zFD"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"B1 = A1@A1\n",
|
|
"C1 = B1@B1\n",
|
|
"D1 = C1@C1\n",
|
|
"print(\"Matrix A1 is fully connected. Product does not contain any zeros :\\n\\n\",D1)\n",
|
|
"\n",
|
|
"B2 = A2@A2\n",
|
|
"C2 = B2@B2\n",
|
|
"D2 = C2@C2\n",
|
|
"print(\"\\nMatrix A2 is not fully connected. Product contains zeros :\\n\\n\",D2)"
|
|
],
|
|
"metadata": {
|
|
"colab": {
|
|
"base_uri": "https://localhost:8080/"
|
|
},
|
|
"id": "xVbt1Fud61tG",
|
|
"outputId": "15b4e5ce-47ef-474c-9abc-455388616a75"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": [
|
|
{
|
|
"output_type": "stream",
|
|
"name": "stdout",
|
|
"text": [
|
|
"Matrix A1 is fully connected. Product does not contain any zeros :\n",
|
|
"\n",
|
|
" [[ 323 512 518 392 230 104 35 8]\n",
|
|
" [ 512 841 904 748 496 265 112 35]\n",
|
|
" [ 518 904 1071 1008 783 504 265 104]\n",
|
|
" [ 392 748 1008 1106 1016 783 496 230]\n",
|
|
" [ 230 496 783 1016 1106 1008 748 392]\n",
|
|
" [ 104 265 504 783 1008 1071 904 518]\n",
|
|
" [ 35 112 265 496 748 904 841 512]\n",
|
|
" [ 8 35 104 230 392 518 512 323]]\n",
|
|
"\n",
|
|
"Matrix A2 is not fully connected. Product contains zeros :\n",
|
|
"\n",
|
|
" [[2061 1912 2060 2544 1432 632 0 0]\n",
|
|
" [1912 1793 1912 2328 1264 536 0 0]\n",
|
|
" [2060 1912 2061 2544 1432 632 0 0]\n",
|
|
" [2544 2328 2544 3225 1912 896 0 0]\n",
|
|
" [1432 1264 1432 1912 1257 648 0 0]\n",
|
|
" [ 632 536 632 896 648 361 0 0]\n",
|
|
" [ 0 0 0 0 0 0 128 128]\n",
|
|
" [ 0 0 0 0 0 0 128 128]]\n"
|
|
]
|
|
}
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Obviously, we are working in the world of Boolean variables, so we cannot do full matrix multiplication, but we there is a binary equivalent of matrix multiplication which use AND and OR operations instead of multiplications and additions, respectively. To make this happen, we just define the matrices as boolean and multiply matrices together using the dot product operator between the matrix transpose and itself $\\textrm{dot}[A^T, A]$"
|
|
],
|
|
"metadata": {
|
|
"id": "2brsB9m54aGo"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"A1Bool = A1.astype(bool)\n",
|
|
"B1 = np.dot(A1Bool.T, A1Bool)\n",
|
|
"C1 = np.dot(B1.T, B1)\n",
|
|
"D1 = np.dot(C1.T, C1)\n",
|
|
"\n",
|
|
"print(\"Matrix A1 is fully connected. Product does not contain any zeros :\\n\\n\",D1)\n",
|
|
"\n",
|
|
"A2Bool = A2.astype(bool)\n",
|
|
"B2 = np.dot(A2Bool.T, A2Bool)\n",
|
|
"C2 = np.dot(B2.T, B2)\n",
|
|
"D2 = np.dot(C2.T, C2)\n",
|
|
"print(\"\\nMatrix A2 is not fully connected. Product contains false values :\\n\\n\",D2)"
|
|
],
|
|
"metadata": {
|
|
"colab": {
|
|
"base_uri": "https://localhost:8080/"
|
|
},
|
|
"id": "o_jvXGDV4Wer",
|
|
"outputId": "da2b933d-27df-40d9-88cb-de2a4a28b032"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": [
|
|
{
|
|
"output_type": "stream",
|
|
"name": "stdout",
|
|
"text": [
|
|
"\n",
|
|
"Matrix A1 is fully connected. Product does not contain any zeros :\n",
|
|
"\n",
|
|
" [[ True True True True True True True True]\n",
|
|
" [ True True True True True True True True]\n",
|
|
" [ True True True True True True True True]\n",
|
|
" [ True True True True True True True True]\n",
|
|
" [ True True True True True True True True]\n",
|
|
" [ True True True True True True True True]\n",
|
|
" [ True True True True True True True True]\n",
|
|
" [ True True True True True True True True]]\n",
|
|
"Matrix A2 is not fully connected. Product contains false values :\n",
|
|
"\n",
|
|
" [[ True True True True True True False False]\n",
|
|
" [ True True True True True True False False]\n",
|
|
" [ True True True True True True False False]\n",
|
|
" [ True True True True True True False False]\n",
|
|
" [ True True True True True True False False]\n",
|
|
" [ True True True True True True False False]\n",
|
|
" [False False False False False False True True]\n",
|
|
" [False False False False False False True True]]\n"
|
|
]
|
|
}
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Now let's write a SAT routine to check if an adjacency matrix represents a fully-connected graph"
|
|
],
|
|
"metadata": {
|
|
"id": "TxctcAsX8rh0"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"def is_fully_connected(s, adjacency):\n",
|
|
" # Size of the adjacency matrix\n",
|
|
" n_components = len(adjacency)\n",
|
|
" # We'll construct a N x N x log[N] array of variables\n",
|
|
" # The NxN variables in the first layer represent A, the variables in the second layer represent B and so on\n",
|
|
" n_layers = math.ceil(math.log(n_components,2))+1\n",
|
|
" connected = [[[ z3.Bool(\"conn_{%d,%d,%d}\"%((i,j,n))) for n in range(0, n_layers)] for j in range(0, n_components) ] for i in range(0, n_components) ]\n",
|
|
"\n",
|
|
" # Constraint 1\n",
|
|
" # The value in the top layer of the connected structure is equal to the adjacency matrix\n",
|
|
" for i in range(n_components):\n",
|
|
" for j in range(n_components):\n",
|
|
" s.add(connected[i][j][0]==adjacency[i][j])\n",
|
|
"\n",
|
|
" # Constraint 2\n",
|
|
" # Value at position [i,j] in layer n is value at position [i,j] of the binary matrix product of layer n-1 with itself\n",
|
|
" for n in range(1,n_layers):\n",
|
|
" for i in range(n_components):\n",
|
|
" for j in range(n_components):\n",
|
|
" matrix_entry_ij = False\n",
|
|
" for k in range(n_components):\n",
|
|
" matrix_entry_ij = Or(matrix_entry_ij, And(connected[i][k][n-1],connected[k][j][n-1]))\n",
|
|
" s.add(connected[i][j][n]==matrix_entry_ij)\n",
|
|
"\n",
|
|
" # Constraint 3 -- any row of column of the matrix should be full of ones at the end (everything is connected)\n",
|
|
" for i in range(n_components):\n",
|
|
" s.add(connected[i][0][n_layers-1])\n",
|
|
"\n",
|
|
" return s"
|
|
],
|
|
"metadata": {
|
|
"id": "JpfVC-Rg0LiC"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"Finally, let's write a routine that tests the adjacency of the two matrices above using a SAT solver."
|
|
],
|
|
"metadata": {
|
|
"id": "slbVVZH6-_Jl"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"def test_is_fully_connected(A):\n",
|
|
" # Set up the SAT solver\n",
|
|
" s = Solver()\n",
|
|
"\n",
|
|
" # Convert the input matrix to z3 Boolean values\n",
|
|
" n_components = A.shape[0]\n",
|
|
" adjacency= [[ z3.Bool(\"a_{%d,%d}\"%((i,j))) for j in range(0, n_components) ] for i in range(0, n_components) ]\n",
|
|
" for i in range(n_components):\n",
|
|
" for j in range(n_components):\n",
|
|
" if A[i,j]!=0:\n",
|
|
" s.add(adjacency[i][j])\n",
|
|
" else:\n",
|
|
" s.add(Not(adjacency[i][j]))\n",
|
|
"\n",
|
|
" # Run the routine\n",
|
|
" s = is_fully_connected(s, adjacency)\n",
|
|
"\n",
|
|
" # Check if it's SAT (creates the model)\n",
|
|
" sat_result = s.check()\n",
|
|
" print(sat_result)\n",
|
|
"\n",
|
|
" # If it was SAT then print out the layers of the 3D structure\n",
|
|
" if sat_result == z3.sat:\n",
|
|
" result = s.model()\n",
|
|
" c_vals = np.array([[[int(bool(result[z3.Bool(\"conn_{%d,%d,%d}\" % (i, j,n))])) for n in range(0, n_components-1)] for j in range(0,n_components) ] for i in range(0,n_components) ] )\n",
|
|
" for n in range(math.ceil(math.log(n_components,2))+1):\n",
|
|
" print(\"Layer:\",n)\n",
|
|
" print(c_vals[:,:,n])"
|
|
],
|
|
"metadata": {
|
|
"id": "0veuGhg_--EJ"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"test_is_fully_connected(A1)"
|
|
],
|
|
"metadata": {
|
|
"colab": {
|
|
"base_uri": "https://localhost:8080/"
|
|
},
|
|
"id": "rk83toMaAkQX",
|
|
"outputId": "75fe712d-1565-4509-9a2e-06e2bea19971"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": [
|
|
{
|
|
"output_type": "stream",
|
|
"name": "stdout",
|
|
"text": [
|
|
"sat\n",
|
|
"Layer: 0\n",
|
|
"[[1 1 0 0 0 0 0 0]\n",
|
|
" [1 1 1 0 0 0 0 0]\n",
|
|
" [0 1 1 1 0 0 0 0]\n",
|
|
" [0 0 1 1 1 0 0 0]\n",
|
|
" [0 0 0 1 1 1 0 0]\n",
|
|
" [0 0 0 0 1 1 1 0]\n",
|
|
" [0 0 0 0 0 1 1 1]\n",
|
|
" [0 0 0 0 0 0 1 1]]\n",
|
|
"Layer: 1\n",
|
|
"[[1 1 1 0 0 0 0 0]\n",
|
|
" [1 1 1 1 0 0 0 0]\n",
|
|
" [1 1 1 1 1 0 0 0]\n",
|
|
" [0 1 1 1 1 1 0 0]\n",
|
|
" [0 0 1 1 1 1 1 0]\n",
|
|
" [0 0 0 1 1 1 1 1]\n",
|
|
" [0 0 0 0 1 1 1 1]\n",
|
|
" [0 0 0 0 0 1 1 1]]\n",
|
|
"Layer: 2\n",
|
|
"[[1 1 1 1 1 0 0 0]\n",
|
|
" [1 1 1 1 1 1 0 0]\n",
|
|
" [1 1 1 1 1 1 1 0]\n",
|
|
" [1 1 1 1 1 1 1 1]\n",
|
|
" [1 1 1 1 1 1 1 1]\n",
|
|
" [0 1 1 1 1 1 1 1]\n",
|
|
" [0 0 1 1 1 1 1 1]\n",
|
|
" [0 0 0 1 1 1 1 1]]\n",
|
|
"Layer: 3\n",
|
|
"[[1 1 1 1 1 1 1 1]\n",
|
|
" [1 1 1 1 1 1 1 1]\n",
|
|
" [1 1 1 1 1 1 1 1]\n",
|
|
" [1 1 1 1 1 1 1 1]\n",
|
|
" [1 1 1 1 1 1 1 1]\n",
|
|
" [1 1 1 1 1 1 1 1]\n",
|
|
" [1 1 1 1 1 1 1 1]\n",
|
|
" [1 1 1 1 1 1 1 1]]\n"
|
|
]
|
|
}
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"test_is_fully_connected(A2)"
|
|
],
|
|
"metadata": {
|
|
"colab": {
|
|
"base_uri": "https://localhost:8080/"
|
|
},
|
|
"id": "DRzo_XrCAlrz",
|
|
"outputId": "1afa9bfb-8ce0-4c9b-bdd6-20e3aed5e128"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": [
|
|
{
|
|
"output_type": "stream",
|
|
"name": "stdout",
|
|
"text": [
|
|
"unsat\n"
|
|
]
|
|
}
|
|
]
|
|
}
|
|
]
|
|
} |