{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Monoidal categories in lambeq"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "In order to use the advanced features of ``lambeq`` and extend it, an understanding of :term:`monoidal categories <monoidal category>` and how it is implemented in the :py:mod:`lambeq.backend` is required.\n",
    "\n",
    ":download:`Download code <../_code/monoidal.ipynb>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Categories\n",
    "\n",
    "A *category* consists of a collection of *objects* $A, B, C, \\ldots$ and a collection of *morphisms* between objects of the form $f: A \\to B, g: B \\to C, h: C \\to D, \\ldots$, such that:\n",
    "\n",
    "* Morphisms with matching types compose. For example, $f: A \\to B$ and $g: B \\to C$ can compose to make $g \\circ f: A \\to C$, but not $f \\circ g$.\n",
    "* Morphisms compose in an associative way: $(h \\circ g) \\circ f = h \\circ (g \\circ f)$\n",
    "* Each object has an identity arrow: $1_B \\circ f = f = f \\circ 1_A$\n",
    "\n",
    "These definitions are implicitly encoded in this *commutative diagram*: any directed path between two specific objects represents equal morphisms.\n",
    "<center>\n",
    "    <img src=\"../_static/images/comm-diagram.png\" alt=\"drawing\" width=\"130\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "For *free* :term:`categories <category>`: we first define generating objects with the :py:class:`~lambeq.backend.grammar.Ty` class and generating morphisms with the :py:class:`~lambeq.backend.grammar.Box` class, then build composite morphisms by freely combining the generating morphisms using backward composition ``>>`` (then)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lambeq.backend.grammar import Box, Id, Ty\n",
    "\n",
    "A, B, C, D = map(Ty, 'ABCD')\n",
    "\n",
    "f = Box('f', A, B)\n",
    "g = Box('g', B, C)\n",
    "h = Box('h', C, D)\n",
    "\n",
    "# the codomain of f and domain of g match, so f and g compose\n",
    "f >> g\n",
    "assert f.cod == g.dom == B\n",
    "\n",
    "# associativity\n",
    "assert f >> (g >> h) == f >> g >> h == (f >> g) >> h\n",
    "\n",
    "# identity\n",
    "assert Id(A) >> f == f.to_diagram() == f >> Id(B)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "As mentioned above, in ``lambeq`` the generating morphisms are defined using the :py:class:`~lambeq.backend.grammar.Box` class. When morphisms are composed, they combine to become an :py:class:`~lambeq.backend.grammar.Diagram`. This explains the need for the :py:meth:`.grammar.Box.to_diagram` call above as `f` was declared as a :py:class:`.grammar.Box` instance and cannot be directly tested for equality with a :py:class:`.grammar.Diagram` instance. Compared to traditional category theory notation, ``lambeq`` prefers to use backwards composition ``>>``, where ``f >> g`` should be read as \"``f`` followed by ``g``\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# only arrows that 'type-check' can be composed\n",
    "diagram = f >> g >> h"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "A :py:class:`~lambeq.backend.grammar.Diagram` behaves like a ``List[Diagram]``: it can be indexed, sliced, or even reversed. Reversing a morphism actually performs the *dagger* operation, which is the abstract notion of a dagger in quantum mechanics and linear algebra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|Ty() @ [f; Ty(A) -> Ty(B)] @ Ty()| >> |Ty() @ [g; Ty(B) -> Ty(C)] @ Ty()| >> |Ty() @ [h; Ty(C) -> Ty(D)] @ Ty()|\n",
      "Indexing: |Ty() @ [f; Ty(A) -> Ty(B)] @ Ty()|\n",
      "Slicing: |Ty() @ [g; Ty(B) -> Ty(C)] @ Ty()| >> |Ty() @ [h; Ty(C) -> Ty(D)] @ Ty()|\n",
      "Reversing (dagger): |Ty() @ [h†; Ty(D) -> Ty(C)] @ Ty()| >> |Ty() @ [g†; Ty(C) -> Ty(B)] @ Ty()| >> |Ty() @ [f†; Ty(B) -> Ty(A)] @ Ty()|\n"
     ]
    }
   ],
   "source": [
    "print(diagram)\n",
    "print(f'Indexing:', diagram[0])\n",
    "print(f'Slicing:', diagram[1:])\n",
    "print(f'Reversing (dagger):', diagram[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monoidal categories\n",
    "\n",
    "A *monoidal category* is a category equipped with the *monoidal product* $\\otimes$ and *monoidal unit* $I$ and has the following properties:\n",
    "\n",
    "* objects can be combined to return another object (e.g $A \\otimes B$)\n",
    "* morphisms can be combined to return another morphism ($(f: A \\to B) \\otimes (g: C \\to D) = f \\otimes g: A \\otimes C \\to B \\otimes D$).\n",
    "* $\\otimes$ is associative on objects: $(A \\otimes B) \\otimes C = A \\otimes (B \\otimes C)$\n",
    "* $\\otimes$ is associative on morphisms: $(f \\otimes g) \\otimes h = f \\otimes (g \\otimes h)$\n",
    "* $I$ is the identity on objects for $\\otimes$: $A \\otimes I= A = I \\otimes A$\n",
    "* $1_I$ is the identity on arrows for $\\otimes$: $f \\otimes 1_I = f = 1_I \\otimes f$"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "For :term:`monoidal categories <monoidal category>`: again, the generating objects are defined with the :py:class:`~lambeq.backend.grammar.Ty` class, and the generating morphisms with the :py:class:`~lambeq.backend.grammar.Box` class; the composite objects are built using ``@`` and the composite morphisms using ``>>``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lambeq.backend.grammar import Box, Id, Ty\n",
    "\n",
    "A, B, C = Ty('A'), Ty('B'), Ty('C')\n",
    "\n",
    "f = Box('f', A, B)\n",
    "g = Box('g', B, C)\n",
    "h = Box('h', B, A)\n",
    "\n",
    "# combining types\n",
    "A @ B\n",
    "# combining boxes\n",
    "f @ g\n",
    "\n",
    "# associativity\n",
    "assert (A @ B) @ C == A @ B @ C == A @ (B @ C)\n",
    "assert (f @ g) @ h == f @ g @ h == f @ (g @ h) \n",
    "\n",
    "# monoidal unit\n",
    "assert A @ Ty() == A == Ty() @ A\n",
    "assert f @ Id(Ty()) == f.to_diagram() == Id(Ty()) @ f"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ":term:`Monoidal categories <monoidal category>` have an elegant graphical calculus, which allow them to be drawn and manipulated graphically. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|Ty() @ [x; Ty(A) -> Ty(A)] @ Ty(A)| >> |Ty() @ [y; Ty(A) @ Ty(A) -> Ty(B)] @ Ty()|\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = Box('x', A, A)\n",
    "y = Box('y', A @ A, B)\n",
    "\n",
    "diagram = x @ Id(A) >> y\n",
    "print(repr(diagram))\n",
    "diagram.draw(figsize=(5, 3))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "A :py:class:`~lambeq.backend.grammar.Ty` can be indexed, sliced, or even reversed, just like a ``List[Ty]``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A @ B @ C\n",
      "Ty(A) @ Ty(B) @ Ty(C)\n",
      "Indexing: A\n",
      "Slicing: B @ C\n",
      "Reversing: C @ B @ A\n"
     ]
    }
   ],
   "source": [
    "t = A @ B @ C\n",
    "\n",
    "print(t)\n",
    "print(repr(t))\n",
    "\n",
    "print('Indexing:', t[0])\n",
    "print(f'Slicing:', t[1:])\n",
    "print(f'Reversing:', t[::-1])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "Again, a :py:class:`.grammar.Diagram` behaves like a ``List[Diagram]``, so it can be indexed, sliced, and reversed. Reversing a diagram performs the dagger operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|Ty() @ [x; Ty(A) -> Ty(A)] @ Ty(A)| >> |Ty() @ [y; Ty(A) @ Ty(A) -> Ty(B)] @ Ty()|\n",
      "Indexing: |Ty() @ [x; Ty(A) -> Ty(A)] @ Ty(A)|\n",
      "Slicing: |Ty() @ [y; Ty(A) @ Ty(A) -> Ty(B)] @ Ty()|\n",
      "Reversing (dagger): |Ty() @ [y†; Ty(B) -> Ty(A) @ Ty(A)] @ Ty()| >> |Ty() @ [x†; Ty(A) -> Ty(A)] @ Ty(A)|\n",
      "\n",
      "Dagger operation:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(diagram)\n",
    "print(f'Indexing:', diagram[0])\n",
    "print(f'Slicing:', diagram[1:])\n",
    "print(f'Reversing (dagger):', diagram[::-1])\n",
    "\n",
    "from lambeq.backend.drawing import draw_equation\n",
    "\n",
    "print('\\nDagger operation:')\n",
    "# boxes are drawn as trapeziums to demonstrate the reflection along the horizontal axis\n",
    "draw_equation(diagram, diagram[::-1], symbol='->', figsize=(8, 3), asymmetry=0.2)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "A :term:`monoidal category` equipped with a :py:class:`~lambeq.backend.grammar.Swap` is known as a :term:`symmetric monoidal category`. Nested swaps can be defined using the :py:meth:`~lambeq.backend.grammar.Diagram.swap` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 100x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from lambeq.backend.grammar import Diagram, Swap\n",
    "\n",
    "Swap(A, B).draw(figsize=(1, 1), draw_as_pregroup=False)\n",
    "Diagram.swap(A @ B, C).draw(figsize=(2, 2), draw_as_pregroup=False)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ".. note::\n",
    "\n",
    "   In a strict mathematical sense, the associativity and unit rules of :math:`\\otimes` in a :term:`monoidal category` only hold up to *isomorphism*. As a consequence, this definition requires extra morphisms such as unitors and associators, as well as complicated coherence conditions. Instead, ``lambeq`` strictly enforces the rules to hold up to equality, so such coherence conditions are unnecessary. This greatly simplifies its practical use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rigid monoidal categories\n",
    "\n",
    "A *rigid category* is a monoidal category where every object $A$ has a *left adjoint* $A^l$ and *right adjoint* $A^r$. The left adjoint of the right adjoint of a type is equal to the type itself, and vice versa: $(A^r)^l = A = (A^l)^r$"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "In the ``lambeq``, the :term:`adjoint` of a type :py:class:`~lambeq.backend.grammar.Ty` is obtained using the ``.l`` and ``.r`` properties:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A.l is represented as Ty(A).l\n",
      "A.r is represented as Ty(A).r\n"
     ]
    }
   ],
   "source": [
    "from lambeq.backend.grammar import Box, Id, Ty\n",
    "\n",
    "A = Ty('A')\n",
    "\n",
    "print(A.l, 'is represented as', repr(A.l))\n",
    "print(A.r, 'is represented as', repr(A.r))\n",
    "\n",
    "assert A.r.l == A == A.l.r"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "The key property of a :term:`rigid category` is the existence of :term:`cups <cup>` and :term:`caps <cap>` between an object and its :term:`adjoint`: these are special morphisms that are drawn as bent wires in diagrammatic notation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from lambeq.backend.grammar import Cap, Cup\n",
    "\n",
    "\n",
    "draw_equation(Cup(A.r, A.r.r), Cup(A, A.r), Cup(A.l, A), symbol='...', figsize=(8, 1))\n",
    "draw_equation(Cap(A.l, A.l.l), Cap(A, A.l), Cap(A.r, A), symbol='...', figsize=(8, 1))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ":term:`Cups <cup>` and :term:`caps <cap>` satisfy the so-called :term:`snake equations`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Snake Equations - For any object A :\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snake1 = Id(A) @ Cap(A.r, A) >> Cup(A, A.r) @ Id(A)\n",
    "snake2 = Cap(A, A.l) @ Id(A) >> Id(A) @ Cup(A.l, A)\n",
    "\n",
    "assert snake1.normal_form() == Id(A) == snake2.normal_form()\n",
    "print('Snake Equations - For any object', A, ':')\n",
    "draw_equation(snake1, Id(A), snake2, figsize=(8, 2))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ".. Note::\n",
    "\n",
    "   The :py:meth:`.grammar.Diagram.normal_form` method used above also applies on standard monoidal diagrams. \n",
    "\n",
    "Nested :term:`cups <cup>` and :term:`caps <cap>` can be created using the :py:meth:`.grammar.Diagram.cups` and :py:meth:`.grammar.Diagram.caps` methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAC3CAYAAACsaM6NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAYXElEQVR4nO3df0yU9wHH8c/9gAMRUKkI+LP+Ap04J+q6Gn9FVzHo1orW1VDn5mY10aqJy2yWpVnWLpuNWdKgc8GzjNo60aXpZJnOOquLdWNSEZyOLf6q8sOfgJw/4O64/WG4FQEFHuG5O96v5Mn9eO45Pjw+j/e5793zYPH5fD4BAAAAnWQ1OwAAAACCG4USAAAAhlAoAQAAYAiFEgAAAIZQKAEAAGAIhRIAAACGUCgBAABgCIUSAAAAhlAoAQAAYAiFEgAAAIZQKAEAAGAIhRIAAACGUCgBAABgCIUSAAAAhlAoAQAAYAiFEgAAAIZQKAEAAGAIhRIAAACGUCgBAABgCIUSAAAAhlAoAQAAYAiFEgAAAIYEbKF89913tWHDBrNjhBSn06mVK1eaHQMAAIQYu9kB2lJaWqqSkhKzY4SUf//73zp69KjZMQAAQIgJ2BHKJzlx4oRsNpsyMjLMjhL0li9fLovF4p/i4uKUnp5OoQcAAO0StIXS6XRq7dq1OnbsmCoqKsyOE/TS09NVWVmpyspKHT58WHa7XfPnzzc7FgAACAJBWShdLpf27Nmj1atXKyMjQ7m5uWZHCnoOh0MJCQlKSEjQhAkTtGnTJl25ckU3btwwOxoAAAhwQVko8/PzlZKSouTkZGVlZWnnzp3y+XxmxwoZLpdLu3bt0siRIxUXF2d2HAAAEOAC9qCcx3E6ncrKypL08KPa2tpaHT16VDNnzjQ3WBArKChQ7969JUl3795VYmKiCgoKZLUG5XsOAADQjYKuLZSVlamwsFCvvPKKJMlut2vJkiVyOp0mJwtus2bNUnFxsYqLi1VYWKi5c+dq3rx5unz5stnRAABAgAu6EUqn0ymPx6OkpCT/fT6fTw6HQ9nZ2YqNjTUxXfCKiorSyJEj/bd37Nih2NhY5eTk6K233jIxGQAACHRBNULp8XiUl5enLVu2+EfTiouLdfr0aSUlJWn37t1mRwwZFotFVqtV9+/fNzsKAAAIcEE1QllQUKDq6mqtWLGixUhkZmamnE6nVq1aZVK64FZfX6+qqipJUnV1tbKzs+VyubRgwQKTkwEAgEAXVCOUTqdTc+bMafVj7czMTJ08eZKTcXfSgQMHlJiYqMTERH3961/XP//5T+3du5cDnQAAwBMF1Qjl/v3725w3ZcoUTh3USbm5uZzLEwAAdFpQjVACAAAg8FAoAQAAYAiFEgAAAIZQKAEAAGAIhRIAAACGUCgBAABgCIUSAAAAhlAoAQAAYAiFEgAAAIZQKAEAAGAIhRIAAACGUCgBAABgCIUSAAAAhlAoAQAAYAiFEgAAAIZQKAEAAGAIhRIAAACGUCgBAABgCIUSAAAAhlAoAQAAYIjd7AAA0Bqfzyev16uGhgY1NDTI7Xb7rz962+12y+PxyOfztTo1NjZ2at6T5tvtdrndblkslmaT1WptcV9757d3XlhYmMLDw/2Xj7tutTJ2AKBrUSiBHsrn8+nBgweqra1VbW2t7t271+7y1tHHdfY5Al1ycrLKysrMjvFENputXcWzs/M6+jiHw6Ho6GjFxsYqJiZGdjsvRUCwYy8GgtCjZbC1qaam5rHza2tr5Xa7O/yz21ssHi0ZUVFRHVqmIyUlLCxMdrv9qY4GtmfZL/97dNeoaNM8j8fTobLemYJ/79491dTUdGh5r9fb4W0qKipKsbGx7Z769OnT7DalFDAfeyAQINxutyoqKnTlyhVdvXrVf1leXq7bt293qAw2jf58eRowYIBGjx7d5ov0lwtfW4WuqbQBbWlsbPQXzLZKZ319ve7cufPYNzu3bt3ShQsXmt1XX1/f5s9trZTGx8dr0KBBGjRokAYPHuy/jIuLYzsGnjIKJdBNfD6fLly4oFOnTunSpUstimNVVZV8Pp//8TExMf4XwyeVwS+P2ERHR8tms5n4m6Ins1qtcjgccjgcT/256+vrOzQaf/HiRR07dkzl5eXyeDz+54mIiGi1aCYnJ2vixInq06fPU88OhDoKJdAFmsrjyZMnVVRUpKKiIn3++eeqqamR9P+yOHjwYI0fP14ZGRktXuBiYmLM/SWAAONwOBQfH6/4+PgOLdfY2Khr1641ewPXdHnhwoUWpXPEiBFKS0tTWlqaJk2aRMkE2oFCCTwlDQ0N+vjjj/Xee+/pxIkT/vI4ZMgQpaWlaePGjf4Xqf79+5sbFuhBrFarEhMTlZiYqMmTJ7f6GK/Xq//+97/N3gT+/Oc/l8vlkvSwZKanp+u1115Tampqd8YHggKFEjCopqZG77zzjpxOp65du6apU6dSHoEgY7PZlJKSopSUFGVlZUl6WDL/85//qKioSIWFhcrPz9fWrVs1depUrV+/XosWLTI5NRA4KJSAATU1NXrhhRd09uxZLV++XKtWrdK4cePMjgXgKbDZbBozZozGjBmjrKwsbdmyRR9//LG2bdumxYsXa/PmzfrRj35kdkwgIHC2W8CAAwcOqLy8XH/729+UnZ1NmQRCWFhYmBYtWqTDhw9rzZo1ysvL04MHD8yOBQQECiVgwPnz5+X1evW1r33N7CgAuonFYtHcuXN15swZ1dbWmh0HCAgUSgAAABhCoQQAAIAhFEoAAAAYQqEEAACAIRRKoAssX75cFovFP8XFxSk9PV0lJSVmRwPQhdj30VNRKIEukp6ersrKSlVWVurw4cOy2+2aP39+u5dvaGjownQAuorRfR8IRpzYHOgiDodDCQkJkqSEhARt2rRJ06ZN040bN1r96zkzZ87UuHHjZLfbtWvXLqWmpurIkSPdHRuAQR3d94FQwAgl0A1cLpd27dqlkSNHKi4urs3H/e53v1N4eLiOHz+u7du3d2NCAF2hvft+qHn99deVl5dndoyQsmnTJv3mN78xO0abGKEEukhBQYF69+4tSbp7964SExNVUFAgq7Xt93GjRo3S5s2buysigC7QmX0/1Bw8eFAOh8PsGCHlyJEjGj9+vNkx2tRztm6gm82aNUvFxcUqLi5WYWGh5s6dq3nz5uny5cttLpOWltaNCQF0hc7s+z3JiRMnZLPZlJGRYXaUkBAoB4JRKIEuEhUVpZEjR2rkyJGaPHmyduzYobt37yonJ+exywAIbp3Z93sSp9OptWvX6tixY6qoqDA7TkgIhAPBKJRAN7FYLLJarbp//77ZUQB0I/b9/3O5XNqzZ49Wr16tjIwM5ebmmh0pJDQdCJaQkKAJEyZo06ZNunLlim7cuNFtGSiUQBepr69XVVWVqqqqdO7cOa1du1Yul0sLFiyQJM2ePVvZ2dkmpwTwtD1p3+/J8vPzlZKSouTkZGVlZWnnzp3y+XxmxwopZh0IxkE5QBc5cOCAEhMTJUnR0dFKSUnR3r17NXPmTEnS+fPndfPmTRMTAugKT9r3ezKn06msrCxJDz+mra2t1dGjR1k3BgXCgWAUSqAL5ObmPvGjnEuXLjW7/emnn3ZZHgDdoz37fk9VVlamwsJCffTRR5Iku92uJUuWyOl0UigNmjVrlv+UQtXV1dq2bZvmzZunwsJCDR06tFsyUCh7kJiYGE6q+5RZLBYNGTLE7BgAEPCcTqc8Ho+SkpL89/l8PjkcDmVnZys2NtbEdMGt6UCwJjt27FBsbKxycnL01ltvdUsGCmUPEhUVpVOnTqmurk7R0dFmxwkJZ86ckdvtNjsGALTgdrtVW1vbrsf269evSz8e9Xg8ysvL05YtW/TCCy80m/fiiy9q9+7dWrVqVZf9/J7GjAPBOCinB3nxxRdltVq1du1as6OEhEOHDmn37t169dVXzY4CAC0cP35c/fv3b9f0xRdfdGmWgoICVVdXa8WKFRo3blyzKTMzU06ns0t/fqgLhAPBGKHsQYYPH67s7GwtX75cUVFRevvtt9WnTx+zYwUdn8+nDz/8UOvWrdM3v/lNrV+/3uxIANDCV7/6VR06dKhdj2362+Ndxel0as6cOa1+rJ2ZmanNmzerpKQkoP8STCALhAPBKJQ9zLJly1RdXa2f/vSn2rt3r95++2195zvf4SPwdmhsbNRnn32mn/zkJzp27JgWL16s7OzsHvXn1AAEj759+2rOnDlmx5Ak7d+/v815U6ZM4dRBBgTKgWC8EvYwFotF69evV1lZmebMmaOVK1cqPj5eCxcu1O7du1VXV2d2xIDSVCI3bNigoUOHatq0abp27Zr+8pe/KD8/X/Hx8WZHBIBWNTQ0+D8GfdLk9XrNjosgxwhlD5WUlKQPP/xQv/jFL7Rv3z7t3btXS5culdVq1ahRo5SamtpsGj58eMiPxN28eVOlpaXNpn/9619yuVxKTEzUokWLtHjxYk2dOjXk1wWA4PfZZ59p1qxZ7XrsxYsXNWzYsK4NhJBGoezhhg0bpo0bN2rjxo26fPmyDh065C9T7777rm7duiVJ6tWrl77yla8oNTVVAwcOVN++fdW3b1/169fPf71pioyMlMViMfk3e8jtdqumpkbV1dUtptu3b+vmzZs6d+6cSktLVVlZKUkKDw/X2LFjlZqaqkWLFum5557T888/T4kEEFQC6TuUCH0USvgNHTpUP/jBD/y3fT6fqqqqmo3YFRcX6+DBg6qurta9e/dafZ7w8PBmBfPR0ulwOGSz2WS322Wz2Zpdb7qMjIzUgwcP5PV65fV65fF42rysra1ttSxWV1fL5XK1mtFut/uzJScn6/vf/77Gjx+v1NRUjRo1SnY7u0ZP4/V6/dtSTU2NHjx44N/OWtv2vF6vLBaLvF5vm9tx03W73a7evXv794FevXoFzJsuhK5A+g4lQh+vmmiTxWJRYmKiEhMTW5w3THr4/ZzWRv5aK3aXL19WcXGxqqur1dDQ0OaLdNMXs6dMmaLCwkL/z3pcAY2JifG/UCcmJmrs2LGPLbR9+/ZVVFQUL+ghqumNUHl5+RO3zy9vp3fu3OnwgQHJyckqKyvrcMawsLAW2+Tjttd+/frp2WefVVRUVId/FgB0BwolOi08PFwDBgzQgAEDntpzNjY2+gtmU3m0Wq2UP7TK5XLpzJkzKi0tVUlJiX8k/fbt280eZ7Va1adPn2YlLS4uTqNGjWqz2EVERLQ54th02fQ1iMeNZHo8Hnk8HtXV1T221JaXl+vMmTP+24+OrlssFo0YMaLZd5vHjx+vESNGyGazdds6B4DWUCgRUKxWq6xWq8LCwsyOggB048YNffTRR/rzn/+s06dP6+LFi5IebjejR49WamqqNmzYoNTUVA0ZMsRfDqOjo4PuO7But9tfLm/duqWysjJ/Yd6+fbuuX78uSYqMjNTYsWM1efJkZWZmaubMmXxlA0C3438dAAHt/v372rVrl/Lz83XkyBH5fD5NmzZNCxcu9H/vdcyYMYqIiDA76lMVFham+Ph4/6mpnn/++Wbzr1+/3uz7zQcPHtT27dv1zDPP6KWXXtJ3v/tdTZ061YzoAHogCiWAgFVQUKB169bp0qVLmjVrlrZu3aqXXnqJ839Kio+P1+zZszV79mxJD787+vnnn2vv3r3Kz89XTk6OXn75ZW3ZskWDBg0yOS2AUBdcnwEB6BG8Xq9efvllLViwQCNGjNDZs2f1ySef6LXXXqNMtsFisSgtLU2//OUvdf78eeXl5eno0aNKSUnRvn37zI4HIMRRKAEEnF/96lfat2+fPvjgAx08eFDJyclmRwoqFotFr776qsrKyjR37lx973vf0/nz582OBSCEUSgBBJSysjK9+eabeuONN7R06VKO8DcgNjZW7733nuLj47Vy5Uqz4wAIYRRKAAHlzJkzio+P1xtvvGF2lJAQExOjNWvW6MaNG/y9ZgBdhkIJIKBUVlbq1q1b6t27t9lRQkb//v1VWloqt9ttdhQAIYpCCQAAAEMolAAAADCEQgkAAABDKJQAAAAwhEIJIKicOHFCNptNGRkZZkcJGaxTAEZRKAEEFafTqbVr1+rYsWOqqKjo0LIc5dw6I+sUACQKJYAg4nK5tGfPHq1evVoZGRnKzc1t87GXLl2SxWLRnj17NGPGDEVEROiDDz7ovrBBoiPrFADaQqEEEDTy8/OVkpKi5ORkZWVlaefOnfL5fI9dZtOmTVq3bp3OnTunuXPndlPS4NGZdQo8yTvvvKNXXnnF7Bgh5Wc/+5lWrFhhdow22c0OAADt5XQ6lZWVJUlKT09XbW2tjh49qpkzZ7a5zPr167Vw4cJuShh8OrNOgSf51re+ZXaEkJOenm52hMdihBJAUCgrK1NhYaF/1MNut2vJkiVyOp2PXW7SpEndES8odXadAsCjGKEEEBScTqc8Ho+SkpL89/l8PjkcDmVnZys2NrbV5aKiororYtDp7DoFgEcxQgkg4Hk8HuXl5WnLli0qLi72T6dPn1ZSUpJ2795tdsSgwzoF8DQxQgkg4BUUFKi6ulorVqxoMWqWmZkpp9OpiRMnatmyZTp8+LAGDhxoUtLg0Z51umrVKpPSAQg2jFACCHhOp1Nz5sxp9SPYzMxMnTx5Un//+99VVlbGuSbbqT3rtKSkxIRkAIIRI5QAAt7+/fvbnDdlyhT/aW5ef/11//3Dhg3j9DeP0d51CgDtEbAjlH379lV0dLTZMQB0M7fbrSFDhpgdAwDQAQFbKBMSEvTXv/5V77//Pu+UgR7i/Pnz2rp1K0dmA0CQCdhCuW7dOi1dulTLli1TSkqKfv3rX+v27dtmxwLwlHm9Xv3pT3/SggULNHr0aDU0NOgPf/iD2bEAAB0QsIXSZrPp/fff16effqqJEyfqxz/+sZKSkvSNb3xDa9asUW5urkpLS+XxeMyOCqADKioq9Mc//lFvvvmm5s+fr6SkJM2fP18VFRX67W9/q7Nnz2r48OFmxwQAdEBAH5RjsVg0Y8YMzZgxQ9evX9fvf/97/eMf/9Ann3yibdu2yefzKTIyUhMmTFBaWpomTpyoZ599VoMHD9bAgQMVERFh9q8A9EiNjY26du2arl69qi+++EIlJSUqKipSUVGRqqqqJEn9+/dXWlqafvjDH+rb3/62Jk2aJIvFYnJyAEBnBHSh/LL4+PhmR3DW1dXp1KlTKioq0smTJ3Xo0CFt3bq12fctn3nmGQ0ePFiDBg3SoEGD/NebLgcOHKjIyEgzfh0gaHm9Xn9ZvHLliq5evdrienl5ebNPD5rK44oVK5SWlqa0tDQNHjyYAgkAISJoCuWjoqOjNX36dE2fPt1/371791q8uDVdHj9+XFevXm3xPUyHw6HY2NhmU58+fVrc97jJ4XB0968PdIrX61VdXZ1qa2v9U01NTbPbT5rq6uqaPWdERIT/Tdvw4cM1ffr0Fm/e4uLiKI8AEMKCtlC2plevXho9erRGjx7d5mPu3r2r8vJyXblyReXl5W2+mF69erXZ7Xv37rX5nBEREY8tnL169VJ4eLjCw8MVFhbmv/7o7Y5eb7rNC3Xw8Pl88nq9amhoUENDg9xut//6o7c7er2hoUH19fW6c+dOm9v1o2Xwy+x2e6tvqkaNGtVimx4wYABlEQDgF1KFsj2ioqKeWDpb43a7defOnQ6N7DSV0vv377daBLxe71P5nex2u6FC+qTrVqtVFoul2dTafe2Z195lw8PD1dDQIJ/P12xqbGxscV975nVk2aZ/p84UuvY87mlp69/xy8WvtTLY1hQZGUkxBAB0So8rlJ0VFhamuLg4xcXFPbXn9Hq9nS4vT6Pg1NXVPfEx9fX1bRax9ha0zpgyZYoKCws7tWxnS2zT1N7SHR4ert69e3dpmW/rus1mo/wBAAIGhdJENptNNputRxyN3pky2tGRz6YJAAB0LwolugVlDwCA0BWwJzYHAABAcKBQAgAAwBAKJQAAAAyhUAIAAMAQCiUAAAAMoVACAADAEAolAAAADKFQAgAAwBAKJQAAAAyhUAIAAMAQCiUAAAAMoVACAADAEAolAAAADKFQAgAAwBAKJQAAAAyhUAIAAMAQCiUAAAAMoVACAADAEAolAAAADKFQAgAAwBAKJQAAAAyhUAIAAMAQCiUAAAAMoVACAADAEAolAAAADKFQAgAAwBAKJQAAAAyhUAIAAMAQCiUAAAAMoVACAADAEAolAAAADKFQAkCIe+6555STkyO73W52lJAxfvx45eTkKCYmxuwoQECw+Hw+n9khAAAAELwYoQQAAIAhFEoAAAAYQqEEAACAIRRKAAAAGEKhBAAAgCEUSgAAABhCoQQAAIAhFEoAAAAYQqEEAACAIRRKAAAAGEKhBAAAgCEUSgAAABhCoQQAAIAhFEoAAAAYQqEEAACAIRRKAAAAGEKhBAAAgCEUSgAAABhCoQQAAIAhFEoAAAAYQqEEAACAIRRKAAAAGPI/JevmmdHqZEYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from lambeq.backend.grammar import Diagram\n",
    "\n",
    "A, B = Ty('A'), Ty('B')\n",
    "\n",
    "nested_cup = Diagram.cups(A @ B, (A @ B).r)\n",
    "nested_cap = Diagram.caps((A @ B).r, A @ B)\n",
    "\n",
    "nested_snake = Id(A @ B) @ nested_cap >> nested_cup @ Id(A @ B)\n",
    "\n",
    "assert nested_snake.normal_form() == Id(A @ B)\n",
    "draw_equation(nested_snake, nested_snake.normal_form())"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}