sage/rubiksnake/rubiksnake.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b002e065",
   "metadata": {},
   "outputs": [],
   "source": [
    "%autosave 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2f981a0",
   "metadata": {},
   "source": [
    "# Rubik's Snakes\n",
    "\n",
    "## Objet du problème\n",
    "\n",
    "Une figure de [*Rubik's snake*](https://fr.wikipedia.org/wiki/Rubik%27s_Snake) $s$ est donnée ;\n",
    "en *notation officielle*,  \n",
    "$s=$ `1R1-2L3-2R3-3L3-4L1-3R3-4R3-5L3-5R1-6L1-6R1-7R3-7L1-8L3-9L3-8R1-9R3-10L3-12R1-12L1-11L1-10R3`  \n",
    "par exemple, ou en *notation simplifiée* : pour le même exemple,  \n",
    "$s=$ `113133311313311131330310`  \n",
    "sachant que le dernier chiffre, ici `0`, n'est pas significatif (sauf si la figure est cyclique).\n",
    "\n",
    "On se propose \n",
    "\n",
    "1. de calculer la notation simplifiée de la figure si elle est donnée en notation officielle ;\n",
    "2. de déterminer si la figure est cyclique  et si elle est physiquement réalisable (dans l'exemple précédent : oui et oui) ;\n",
    "3. d'en obtenir une représentation graphique ; \n",
    "4. et de fournir une aide à sa réalisation \"à la main\".\n",
    "\n",
    "## Méthode\n",
    "\n",
    "<img src=\"data:image/png;base64,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\"/>\n",
    "\n",
    "Au départ, le snake est déployé en ligne droite. On effectue les rotations voulues de gauche à droite tout en lisant le mot $s$ (en notation simplifiée).  \n",
    "Chaque prisme $P$ a trois faces carrées : une grande et deux petites. appelons *face d'entrée* la petite face carrée de gauche et *face de sortie* la petite face carrée de droite (c'est la face d'entrée du prisme suivant).  \n",
    "On représente un prisme par les 4 sommets $(p_0,p_1,p_2,p_3)$ de sa face d'entrée, ordonnés de manière que $[p_0,p_1]$ soit l'arête intersection des 2 petites faces carrées et que les deux points $q_{0,1}=p_{1,0}+(p_1-p_0)\\wedge(p_3-p_0)$ forment l'arête parallèle à $[p_0,p_1]$  de la face de sortie (ces arêtes sont supposées de longueur $1$).  \n",
    "Ainsi $(q_0,q_1,q_2=p_0,q_3=p_1)$ représente le prisme $Q$ situé après $P$ (avant toute rotation) ; et une rotation de $Q$ par rapport à $P$ est une permutation circulaire sur les $q_i$.\n",
    "\n",
    "#### 1. Conversion notation officielle $\\rightarrow$ notation simplifiée\n",
    "Facile\n",
    "\n",
    "####  2. Cyclicité et réalisabilité\n",
    "La figure est cyclique si, à une rotation près, la face de sortie du dernier prisme coïncide avec la face d'entrée du premier.\n",
    "\n",
    "Noter que chaque prisme est contenu dans un cube comme sur la figure suivante\n",
    "\n",
    "<img src=\"data:image/png;base64,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\"/>\n",
    "\n",
    "et que 2 prismes s'intersectent (la figure n'est alors pas réalisable) s'ils partagent le même cube, à moins que les 2 prismes soient différents et qu'ils partagent la même grande face carrée (à eux deux, ils occupent tout le cube).\n",
    "\n",
    "#### 3. Graphisme\n",
    "\n",
    "Les points précédents n'utilisent que `Python` mais les procédures graphiques sont implémentées en `Sage`  pour profiter de ses  possibilités d'animation des images 3D, c'est pourquoi le présent Notebook nécessite un noyau `sagemath`.\n",
    "\n",
    "Le calcul de la représentaton graphique de la figure est dés lors affaire de technique et ne présente pas de difficulté particulière.\n",
    "\n",
    "#### 4. Aide\n",
    "\n",
    "Pour réaliser physiquement la figure (supposée réalisable, bien entendu), \n",
    "1. soit on dispose de la représentation officielle de la figure et il suffit de la suivre,\n",
    "2. soit on travaille avec la représentation simplifiée $s$ ;\n",
    "\n",
    "Dans ce deuxième cas, en principe,  on lit $s$ de gauche à droite en effectuant sur le snake matériel, au fur et à mesure, les rotations correspondantes. Dans beaucoup de cas, cela suffit. Mais il peut arriver que l'on soit bloqué à une étape du processus. \n",
    "\n",
    "Prenons par exemple $s=$ `300220321232321230020012`. \n",
    "\n",
    "On commence par réaliser `3002`, c'est à dire \n",
    "- une rotation d'un quart de tour du deuxième prisme autour du premier dans le sens inverse des aiguilles d'une montre\n",
    "- suivi d'une rotation d'un demi tour du cinquième prisme autour du quatrième.\n",
    "\n",
    "L'étape suivante (le `2` en cinquième position dans $s$) consisterait à effectuer une rotation d'un demi tour du sixième prisme autour du cinquième mais cela est rendu impossible par le fait que `300220000000000000000000` n'est pas réalisable. Dans ces conditions, on laisse tomber cette étape et on continue la lecture de $s$ tout en remettant à plus tard les étapes irréalisables. On réalise ainsi   \n",
    "$s_1=$ `300200321230301230020010` et il reste à réaliser  \n",
    "$s_2=$ `000020000002020000000000`, ce qui se fait sans problème.  \n",
    "Ainsi l'aide à la réalisation de la figure consiste ici à afficher la suite de chaines $s_1,s_2$\n",
    "\n",
    "D'une part, cette suite peut être plus longue ($s_1,s_2,\\ldots$) et, d'autre part, il se peut, qu'elle n'aboutisse pas : on tombe sur une chaine $s_k$ dont aucune des rotations correspondantes n'est réalisable. Dans ce cas, on annonce que le procédé a failli et on affiche $s_k$. Il faut alors se débrouiller pour exécuter les rotations données par $s_k$ sans casser l'objet.\n",
    "\n",
    "Enfin, on propose deux méthodes graphiques, correspondant aux deux cas ci-dessus, qui présentent, graphiquement donc, chaque rotation à réaliser.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "752b16cc",
   "metadata": {},
   "source": [
    "## Implémentation\n",
    "\n",
    "Un Rubik's Snake est représenté par la classe `RubikSnake`:\n",
    "\n",
    "$R=$ `RubikSnake`$(s, $ colors = colors7$)$ où $s$ est une représentation officielle ou simplifiée et `colors` est la liste des couleurs des prismes. Alors :\n",
    "\n",
    "$R$ `.s` $=$ représentation simplifiée de $R$\n",
    "\n",
    "$R$ `.cyclique`$=$ `True`|`False`\n",
    "\n",
    "$R$ `.realisable()` $=$ `True`|`False`\n",
    "\n",
    "$R$ `.plot(dilatation = 1., horizontal = 1, **kwargs)`\n",
    "- si `dilatation` $<1$ les prismes apparaissent plus petits\n",
    "- si `horizontal` $=n$, la vue est calculée pour que la face de sortie du $n^{\\text e}$ prisme apparaisse horizontale\n",
    "- les autre arguments sont passés à la méthode `plot` de `sage`, par exemple `alpha` ($<1$) pour la transparence\n",
    "\n",
    "$R$ `.aide()` affiche $s_1,s_2,\\ldots$ \n",
    "\n",
    "Aide graphique :\n",
    "\n",
    "Dans une cellule, écrire et executer :\n",
    "\n",
    "```python\n",
    "R=RubikSnake(...)\n",
    "#print(R.s + '\\n' + '-' * 20)\n",
    "#R.aide()\n",
    "G = R.aideGraphique1()\n",
    "```\n",
    "\n",
    "Dans la cellule suivante, écrire :\n",
    "\n",
    "```python\n",
    "try:\n",
    "    next(G)\n",
    "except StopIteration:\n",
    "    pass\n",
    "```\n",
    "\n",
    "et l'exécuter autant de fois que nécessaire pour voir apparaitre les différentes rotations à réaliser en vue de construire la figure.\n",
    "\n",
    "Pour la deuxième méthode, remplacer la ligne `G = R.aideGraphique1()` par `G = R.aideGraphique2()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "931c26e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "colors2 = [Color('#5770B7'), Color('#43B3A3')]\n",
    "colors7 = [\"yellow\", \"orange\", \"red\", \"purple\", \"darkblue\", \"deepskyblue\", \"lightgreen\"]\n",
    "\n",
    "class RubikSnake:\n",
    "\n",
    "    def __init__(self, s, colors = colors7):\n",
    "        \n",
    "        def rotation(m): # renvoie la face m tournée de pi/2\n",
    "            return np.array([m[3], m[0], m[1], m[2]])\n",
    "        \n",
    "        if '-' in s:\n",
    "            # s est en notation officielle\n",
    "            self.s_officiel = s \n",
    "            u = list(map(lambda t: (int(t[:-2]),t[-2],int(t[-1])), s.split('-')))\n",
    "            n = max([t[0] for t in u])\n",
    "            t = list('0' * 2 * n)\n",
    "            for k, d, c in u:\n",
    "                if d == 'R':\n",
    "                    t[2 * k - 2] = str(c)\n",
    "                else:\n",
    "                    t[2 * k - 3] = str(4 - c)\n",
    "            self.s = ''.join(t) # notation simplifiée\n",
    "        else:\n",
    "            # s est déjà en notation simplifiée\n",
    "            self.s_officiel = None\n",
    "            self.s = s\n",
    "            \n",
    "        self.colors = colors\n",
    "        m0 = np.array([[1,0,0],[1,1,0],[0,1,0],[0,0,0]]) # 1ere face\n",
    "        m = m0            # face courante\n",
    "        self.prismes = [] # liste des prismes\n",
    "        for i, k in enumerate(self.s):\n",
    "            aux =  m[1] + np.cross(m[1] - m[0], m[3] - m[0])\n",
    "            m_succ = np.array([aux, aux + m[0] - m[1], m[0], m[1]]) # face suivante\n",
    "            self.prismes.append([m[0], m[1], m[2], m[3], m_succ[0], m_succ[1]])\n",
    "            m = m_succ\n",
    "            for _ in range(int(k)): \n",
    "                m = rotation(m)\n",
    "        self.cyclique = False\n",
    "        for i in range(4):\n",
    "            if (m == m0).all(): \n",
    "                self.cyclique = True\n",
    "                self.s = self.s[:-1] + str(mod(int(self.s[-1]) + i, 4))\n",
    "            m = rotation(m)\n",
    "            \n",
    "    def realisable(self):\n",
    "        \n",
    "        # Pour chaque prisme, calcul du centre du cube le contenant\n",
    "        prismes = [(p, p[2] + p[3] + p[4] + p[5]) for p in self.prismes]\n",
    "        \n",
    "        for i, (p, g) in enumerate(prismes):\n",
    "            for p1, g1 in prismes[:i]:\n",
    "                if (g == g1).all() and (p[0] + p[1] + p1[0] + p1[1] != g).any():\n",
    "                    return False\n",
    "        return True\n",
    "        \n",
    "    def plot(self, dilatation = 1., horizontal = 1, _y = None, **kwargs):\n",
    "        \n",
    "        def dilate(l, d):\n",
    "                g = sum(l) / len(l)\n",
    "                return list(map(lambda v: g + d * (v - g), l))\n",
    "        \n",
    "        def fleche(x, v, radius, **kwargs):\n",
    "\n",
    "            from sage.plot.plot3d.shapes import Cone\n",
    "\n",
    "            height = (sum(v**2))**.5\n",
    "            k = height * np.array([0,0,1])\n",
    "            return Cone(radius, height, closed = False, **kwargs).rotate(k + v, pi).translate(x)\n",
    "      \n",
    "        def tourner(i,p):\n",
    "            g = .5 * (p[0] + p[4])\n",
    "            u, v = p[0] - g, p[1] - g\n",
    "            w = 2. * np.cross(u, v)\n",
    "            k = np.array([0,0,1])\n",
    "            axe = w + k\n",
    "            axe = axe if axe.any() else u           \n",
    "            U = p[1] - p[0]\n",
    "            t = -pi/4 if (U[0] and axe[0] == 0.) or (U[1] and axe[2] == 0.) or (U[2] and axe[1] == 0.) else pi/4\n",
    "            return (axe, pi), t\n",
    "        \n",
    "        G = Graphics()\n",
    "        rotation = None\n",
    "        for i, p in enumerate(self.prismes):\n",
    "            \n",
    "            kwargs['color'] = self.colors[mod(i,len(self.colors))]\n",
    "            G += Polyhedron(vertices = dilate(p, dilatation)).plot(**kwargs)\n",
    "            if horizontal == i + 1 and _y is None:\n",
    "                rotation = tourner(i, p)\n",
    "            if _y is not None and _y[i] != '0':\n",
    "                if rotation is None:\n",
    "                    rotation = tourner(i, p)\n",
    "                c =  self.colors[mod(i + 1,len(self.colors))]\n",
    "                g = .5 * (p[0] + p[4])\n",
    "                u, v = 1.5 * (p[0] - g), 1.5 * (p[1] - g)\n",
    "                t = var('t')\n",
    "                G += parametric_plot3d(list(g + cos(t) * u + sin(t) * v), (t, 0, 2*pi),\n",
    "                        linewidth = 5, color = c)\n",
    "                a = .4 if _y[i] == '3' else -.4\n",
    "                b = .085\n",
    "                for x,V in [(g + u, a * v - b * u),\n",
    "                            (g + v, -a * u - b * v),\n",
    "                            (g - u, -a * v + b *u),\n",
    "                            (g - v, a * u + b * v)]:\n",
    "                    G += fleche(x, V, .1, color = c) + text3d(\n",
    "                        '2' if _y[i] == '2' else '1', x - .5 * V, color = c, fontsize = 30)\n",
    "        if rotation is None:\n",
    "            rotation = ([0,0,1], 0), 0\n",
    "        im = G.rotate(*rotation[0]).rotate([0,0,1],rotation[1])\n",
    "        \n",
    "        im.show(frame = False)\n",
    "\n",
    "    def _realisation(self, graphique = False, **kwargs):\n",
    "        n = len(self.s)\n",
    "        x = '0' * n\n",
    "        while x[:-1] != self.s[:-1]:\n",
    "            chgt = False\n",
    "            y = ''\n",
    "            z = ''\n",
    "            for i, k in enumerate(self.s[:-1]):\n",
    "                if x[i] == k:\n",
    "                    y += '0'\n",
    "                    z += '0'\n",
    "                else:\n",
    "                    aux = x[:i] + k + x[i+ 1:]\n",
    "                    r = RubikSnake(aux, colors = self.colors)\n",
    "                    if r.realisable():\n",
    "                        if graphique:\n",
    "                            yield RubikSnake(x, colors = self.colors).plot(_y = '0' * i + k + '0' * (n - i - 1), **kwargs)\n",
    "                        x = aux\n",
    "                        chgt = True\n",
    "                        y += k\n",
    "                        z += '0'\n",
    "                    else:\n",
    "                        y += '0'\n",
    "                        z += k\n",
    "            if chgt and not graphique:\n",
    "                print(y + '0')\n",
    "            if x[:-1] != self.s[:-1] and not chgt:\n",
    "                print('SITUATION DIFFICILE')\n",
    "                if graphique:\n",
    "                    yield RubikSnake(x, colors = self.colors).plot(_y = z + '0', **kwargs)\n",
    "                    yield self.plot(**kwargs)\n",
    "                else:\n",
    "                    print(z + '0')\n",
    "                break\n",
    "        if graphique:\n",
    "            yield self.plot(**kwargs)\n",
    "                \n",
    "\n",
    "    def aide(self):\n",
    "        try:\n",
    "            next(self._realisation())\n",
    "        except StopIteration:\n",
    "            pass\n",
    "    \n",
    "    def aideGraphique2(self, **kwargs):\n",
    "        return self._realisation(graphique = True, **kwargs)\n",
    "    \n",
    "    def aideGraphique1(self, **kwargs):\n",
    "        if self.s_officiel is None:\n",
    "            print('Représentation officielle de la figure INCONNUE')\n",
    "            print('Appliquez aideGraphique2')\n",
    "        else:\n",
    "            u = list(map(lambda t: (int(t[:-2]),t[-2],int(t[-1])), s.split('-')))\n",
    "            n = len(self.s)\n",
    "            x = '0' * n \n",
    "            for h, d, c in u:\n",
    "                i, k = (2 * h - 2, str(c)) if d == 'R' else (2 * h - 3, str(4 - c))\n",
    "                aux = x[:i] + k + x[i+ 1:]\n",
    "                r = RubikSnake(aux, colors = self.colors)\n",
    "                if not r.realisable(): print('NON REALISABLE')\n",
    "                yield RubikSnake(x, colors = self.colors).plot(_y = '0' * i + k + '0' * (n - i - 1), **kwargs)\n",
    "                x = aux\n",
    "            yield RubikSnake(x, colors = self.colors).plot(**kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47b21cfb",
   "metadata": {},
   "source": [
    "## Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dabd286f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def all(self, **kwargs):\n",
    "    print(self.s, 'est' if self.cyclique else \"n'est pas\",'cyclique')\n",
    "    print(self.s, 'est' if self.realisable() else \"n'est pas\",'realisable')\n",
    "    print('Aide :')\n",
    "    self.aide()\n",
    "    self.plot(**kwargs)\n",
    "\n",
    "RubikSnake.all = all    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a80eee3",
   "metadata": {},
   "source": [
    "Modifier `s` dans la cellule suivante pour d'autres tests. Voir [le site de Thomas Volter](http://thomas-wolter.de/rubik_easy_en.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3668f43e",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "s = '1R1-2R2-3L2-4L1-5L2-5R3-6L1-4R1-6R1-7L3-7R2-12R2-12L3-11R1-11L1-10R3-10L2-9R1-9L3-8R3-8L1'\n",
    "R = RubikSnake(s, colors = colors2)\n",
    "R.all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7c32833",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "G = R.aideGraphique2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26462e80",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cellule à exécuter plusieurs fois après avoir exécuté la cellule précédente\n",
    "\n",
    "try:\n",
    "    next(G)\n",
    "except StopIteration:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b05b54b1",
   "metadata": {},
   "source": [
    "La cellule suivante peut recevoir du code Python ou Sage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "162b7bee",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 10.1",
   "language": "sage",
   "name": "sagemath"
  },
  "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}