beginners_guide_example_random_nae3sat.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "56f0b47e",
   "metadata": {},
   "source": [
    "# Example: Computing on the Dynex Platform with Python - NAE3SAT"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed479bbd",
   "metadata": {},
   "source": [
    "Dynex is the world’s first neuromorphic supercomputing blockchain based on the DynexSolve chip algorithm,\n",
    "a Proof-of-Useful-Work (PoUW) approach to solving real-world problems. This example demonstrates how to use the Dynex SDK to use Pyton to compute on the Dynex Platform with Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4c52a895",
   "metadata": {},
   "outputs": [],
   "source": [
    "import dynex\n",
    "import dimod"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afd0e043",
   "metadata": {},
   "source": [
    "## Building a Binary Quadratic Model "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "499a2526",
   "metadata": {},
   "source": [
    "Binary quadratic models (BQMs) are problems of the form:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72b2cd4e",
   "metadata": {},
   "source": [
    "<math xmlns=\"http://www.w3.org/1998/Math/MathML\" display=\"block\">\n",
    "  <mi>E</mi>\n",
    "  <mo stretchy=\"false\">(</mo>\n",
    "  <mrow data-mjx-texclass=\"ORD\">\n",
    "    <mi mathvariant=\"bold\">v</mi>\n",
    "  </mrow>\n",
    "  <mo mathvariant=\"bold\" stretchy=\"false\">)</mo>\n",
    "  <mo mathvariant=\"bold\">=</mo>\n",
    "  <munder>\n",
    "    <mo data-mjx-texclass=\"OP\">&#x2211;</mo>\n",
    "    <mrow data-mjx-texclass=\"ORD\">\n",
    "      <mi mathvariant=\"bold\">i</mi>\n",
    "    </mrow>\n",
    "  </munder>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">a</mi>\n",
    "    <mi mathvariant=\"bold\">i</mi>\n",
    "  </msub>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">v</mi>\n",
    "    <mi mathvariant=\"bold\">i</mi>\n",
    "  </msub>\n",
    "  <mo mathvariant=\"bold\">+</mo>\n",
    "  <munder>\n",
    "    <mo data-mjx-texclass=\"OP\">&#x2211;</mo>\n",
    "    <mrow data-mjx-texclass=\"ORD\">\n",
    "      <mi mathvariant=\"bold\">i</mi>\n",
    "      <mo mathvariant=\"bold\">&lt;</mo>\n",
    "      <mi mathvariant=\"bold\">j</mi>\n",
    "    </mrow>\n",
    "  </munder>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">b</mi>\n",
    "    <mrow data-mjx-texclass=\"ORD\">\n",
    "      <mi mathvariant=\"bold\">i</mi>\n",
    "      <mo mathvariant=\"bold\">,</mo>\n",
    "      <mi mathvariant=\"bold\">j</mi>\n",
    "    </mrow>\n",
    "  </msub>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">v</mi>\n",
    "    <mi mathvariant=\"bold\">i</mi>\n",
    "  </msub>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">v</mi>\n",
    "    <mi mathvariant=\"bold\">j</mi>\n",
    "  </msub>\n",
    "  <mo mathvariant=\"bold\">+</mo>\n",
    "  <mi mathvariant=\"bold\">c</mi>\n",
    "  <mstyle scriptlevel=\"0\">\n",
    "    <mspace width=\"2em\"></mspace>\n",
    "  </mstyle>\n",
    "  <mstyle scriptlevel=\"0\">\n",
    "    <mspace width=\"2em\"></mspace>\n",
    "  </mstyle>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">v</mi>\n",
    "    <mi mathvariant=\"bold\">i</mi>\n",
    "  </msub>\n",
    "  <mo>&#x2208;</mo>\n",
    "  <mo fence=\"false\" stretchy=\"false\">{</mo>\n",
    "  <mo mathvariant=\"bold\">&#x2212;</mo>\n",
    "  <mn mathvariant=\"bold\">1</mn>\n",
    "  <mo mathvariant=\"bold\">,</mo>\n",
    "  <mo mathvariant=\"bold\">+</mo>\n",
    "  <mn mathvariant=\"bold\">1</mn>\n",
    "  <mo fence=\"false\" stretchy=\"false\">}</mo>\n",
    "  <mtext mathvariant=\"bold\">&#xA0;or&#xA0;</mtext>\n",
    "  <mo fence=\"false\" stretchy=\"false\">{</mo>\n",
    "  <mn mathvariant=\"bold\">0</mn>\n",
    "  <mo mathvariant=\"bold\">,</mo>\n",
    "  <mn mathvariant=\"bold\">1</mn>\n",
    "  <mo fence=\"false\" stretchy=\"false\">}</mo>\n",
    "</math>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ce31898",
   "metadata": {},
   "source": [
    "where a,b,c are real values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc67c3a1",
   "metadata": {},
   "source": [
    "We need to define a quadratic model (QM) that represents our problem. The simplest way to build a binary quadratic model (BQM) is using dimod’s symbolic variables. For each mathematical variable in your BQM, we define a symbolic\n",
    "binary variable using dimod. Once the QM is defined, it is stored as a BinaryQuadraticModel object. This object stores the linear and quadratic coefficients of the mathematical expression, any constant term or offset, and\n",
    "the type of variables used to build the model. In this case, printing out the object bqmmodel that we have\n",
    "constructed reveals the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e528fcaf",
   "metadata": {},
   "source": [
    "## Random not-all-equal 3-satisfiability problem (NAE3SAT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e6cb2f0",
   "metadata": {},
   "source": [
    "Not-all-equal 3-satisfiability (NAE3SAT) is an NP-complete problem class that consists in satisfying a number of conjunctive clauses of three literals (variables, or their negations). For valid solutions, the literals in each clause should be not-all-equal; i.e. any assignment of values except (+1, +1, +1) or (-1, -1, -1) are valid for each clause.\n",
    "\n",
    "Each clause contributes -1 to the energy when the clause is satisfied, and +3 when unsatisfied. The energy H(s) for a spin assignment s is thus lower bounded by E(SAT) = -num_clauses, this lower bound matches the ground state energy in satisfiable instances. The number of violated clauses is \n",
    "(H(s)-E(SAT))/4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "15c60f0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BinaryQuadraticModel({0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}, {(1, 0): 1.0, (2, 0): -1.0, (2, 1): 0.0, (3, 0): -3.0, (3, 1): 2.0, (3, 2): 1.0, (4, 0): -3.0, (4, 1): -1.0, (4, 2): 0.0, (4, 3): 2.0}, 0.0, 'SPIN')\n"
     ]
    }
   ],
   "source": [
    "num_variables = 5;\n",
    "rho = 2.1;\n",
    "bqmodel = dimod.generators.random_nae3sat(num_variables, round(num_variables*rho))\n",
    "print(bqmodel)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b74b5e04",
   "metadata": {},
   "source": [
    "Define the Dynex BQM model based on our BQM:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "372cb654",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Variables([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bqmodel.variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "931cfac2",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = dynex.BQM(bqmodel);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4122925b",
   "metadata": {},
   "source": [
    "## Interacting with the Dynex Sampler "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e3c77de",
   "metadata": {},
   "source": [
    "To find the minimum energy state for a QM (the assignment of variable values that gives us the\n",
    "minimum energy value for our QM), the Dynex SDK provides samplers and solvers. A solver is\n",
    "a resource that runs a problem. Samplers are processes that run a problem many times to obtain\n",
    "a collection of samples, each of which is a possible solution to our problem. For convenience, we\n",
    "will generally refer to Dynex’s samplers as a whole, to include solvers as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "0cbcad35",
   "metadata": {},
   "outputs": [],
   "source": [
    "sampler = dynex.DynexSampler(model);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1548a123",
   "metadata": {},
   "source": [
    "Once we have established our sampler in our program, we can call it for our QM. Each type of QM\n",
    "model has its own method for interacting with the sampler, whether it be QUBO, BinaryQuadrticModel, or any other QM. We call the sampler to sample our QM using one of Dynex’s sample functions, depending on what type of QM we are using. For example, the code snippet below demonstrates how we can sample a BinaryQuadraticModel object named bqm using the Dynex Platform."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ade2765b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 0.00s #workers: 2 #chips: 64 #steps: 110000 global loc: 3 global energy: 4.535805\n",
      "FINISHED READ AFTER 0.00 SECONDS\n",
      "SAMPLESET LOADED\n"
     ]
    }
   ],
   "source": [
    "sampleset = sampler.sample(num_reads=32, annealing_time = 100);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6db670b2",
   "metadata": {},
   "source": [
    "After we have sampled our QM, the sampler returns a SampleSet object. This object contains all\n",
    "of the samples returned along with their corresponding energy value, number of chips, number of integration steps, and more. The additional information varies depending on which sampler is used. As users get more\n",
    "comfortable with the Dynex SDK and the variety of samplers available, it is often useful to take\n",
    "some time to explore the wealth of information provided in the SampleSet object. Some of the key properties and methods of a SampleSet that we access are the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1975c33e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'sample': ['0.502819', '-0.985740', '0.006763', '-0.999880', '-0.528928', '0.000000', '0.000000', '-1.000000', '1.000000', '1.000000', '-1.000000', '0.000000', '0.000000', '-1.000000', '1.000000', '1.000000', '-1.000000', '-1.000000', '1.000000', '1.000000', '-1.000000', '1.000000'], 'chips': 64, 'steps': 110000, 'loc': 3, 'energy': 4.535805}\n"
     ]
    }
   ],
   "source": [
    "print(sampleset[-1]) # sample with the lowest energy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba609414",
   "metadata": {},
   "source": [
    "The sample shows the corresponding energy values for our QM and additional information like total energy, number of chips or number of integration steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "11d4820e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0.502819', '-0.985740', '0.006763', '-0.999880', '-0.528928']\n"
     ]
    }
   ],
   "source": [
    "print(sampleset[-1]['sample'][:5]) # Energy levels for the first variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c324c57",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}