{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1e4f56fe",
   "metadata": {},
   "source": [
    "# Devoir à la maison : permutations\n",
    "\n",
    "## Consignes\n",
    "\n",
    "1. Ce devoir est à rendre pour le **jeudi 30 avril 2026, dernier délai**, par email à julien.lavauzelle@univ-paris8.fr.\n",
    "2. Vous devez rendre votre travail sous le format suivant :\n",
    "  - un document au format **.ipynb** correspondant à cette page, que vous téléchargez puis remplissez ;\n",
    "  - si vous en avez besoin, un autre document au format **.pdf** qui contient des réponses ou commentaires additionnels.\n",
    "3. Sauf exception, le travail **doit** être effectué par **groupe de deux**. Vous **devez** m'envoyer votre composition de binôme par email avant le **dimanche 19 avril**, dernier délai.\n",
    "4. **Important :** une fois votre travail rendu, chacun des membres du binôme doit être capable **d'expliquer précisément** chacune des lignes des réponses que vous avez rendues. Vous serez convoqué·es pour expliquer votre travail lors d'une séance le **jeudi 07 mai 2026**.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "## Partie A : représentations de permutations\n",
    "\n",
    "\n",
    "Soit $n \\ge 1$. Pour rappel, on appelle **permutation** de $\\{0, \\dots, n-1\\}$ une application bijective $\\sigma : \\{0, \\dots, n-1\\} \\to \\{0, \\dots, n-1\\}$. On note $S_n$ l'ensemble de ces permutations.\n",
    "\n",
    "En informatique, une permutation $\\sigma \\in S_n$ peut être **représentée** par la liste de ses images, c'est-à-dire par la liste $[\\, \\sigma(0), \\sigma(1), \\dots, \\sigma(n-1)\\, ]$. Mais toutes les listes de longueur $n$ ne correspondent pas à une permutation ! En effet, une liste `L` de longueur $n$ correspond à une permutation si et seulement si elle contient exactement une fois tous les entiers compris entre $0$ et $n-1$.\n",
    "\n",
    "\n",
    "\n",
    "**Question 1.** Écrire une fonction `est_une_permutation(L)` qui prend en entrée une liste d'entiers `L`, et qui teste si cette liste représente une permutation au sens défini plus haut. La fonction retournera la valeur booléenne du test. Puis, afficher l'exécution de la fonction sur deux listes de longueur $n = 6$ : l'une pour lequel la liste représente bien une permutation, l'autre non."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02e778f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1f729f9",
   "metadata": {},
   "source": [
    "L'application identité, qui laisse invariant tous les éléménts de $\\{0, \\dots, n-1 \\}$, est une permutation. Elle est notée ${\\rm id} \\in S_n$.\n",
    "\n",
    "\n",
    "**Question 2.** Écrire une fonction `permutation_identite(n)` qui retourne la permutation identité de $S_n$. Puis, afficher la permuation identité de $S_6$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "731c62ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dccd2c1",
   "metadata": {},
   "source": [
    "Toute permutation est inversible pour la composition : si $\\sigma \\in S_n$, alors il existe $\\psi \\in S_n$ telle que $\\sigma \\circ \\psi = \\psi \\circ \\sigma = {\\rm id}$. La permutation $\\psi$ est alors la seule à vérifier cette propriété, et elle est notée $\\sigma^{-1}$. On a ainsi :\n",
    "\n",
    "$$\n",
    "\\forall (i,j) \\in \\{0, \\dots, n-1\\}, \\sigma(i) = j \\iff \\sigma^{-1}(j) = i\\,. \n",
    "$$\n",
    "\n",
    "\n",
    "**Question 3.** Écrire une fonction `inverse_permutation(L)` qui prend en entrée une permutation représentée par une liste `L`, et qui retourne la liste correspondant à son inverse. Puis, afficher la permutation inverse de la permutation représentée par `[0, 3, 2, 5, 1, 4]`, et vérifier à la main que l'on obtient bien le bon résultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8365dc30",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ffa7f5a",
   "metadata": {},
   "source": [
    "L'ensemble des permutations de $S_n$ est munie d'une loi de composition notée $\\circ$, et définie comme la composition des permutations. Autrement dit, pour tout $(\\sigma, \\phi) \\in S_n^2$ et pour tout $i \\in \\{0, \\dots, n-1\\}$, on a $(\\sigma \\circ \\phi)(i) := \\sigma(\\phi(i))$. On parle aussi parfois du **produit** des permutations $\\sigma$ et $\\phi$, même si cette opération n'est pas commutative a priori.\n",
    "\n",
    "\n",
    "**Question 4.** Écrire une fonction `produit_permutation(L, M)` qui prend en entrée deux permutations $f$ et $g$ représentées par deux listes `L` et `M`, et qui retourne la liste correspondant à leur composition $f \\circ g$. Puis, afficher le produit de la permutation de la question 3 et de son inverse, et vérifier que l'on obtient bien l'identité."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "962fd011",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb22ff55",
   "metadata": {},
   "source": [
    "**Question 5.** Écrire une fonction `permutation_aleatoire(n)` qui prend en entrée un entier $n$, et retourne une permutation de $\\{0, \\dots, n-1\\}$ tirée uniformément. Puis, tirer uniformément deux permutations aléatoires (pour $n=10$) et en faire le produit. Vérifier à la main le résultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e162b9b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56fdf43c",
   "metadata": {},
   "source": [
    "Soit $\\sigma \\in S_n$ une permutation. La matrice $M := {\\rm Mat}(\\sigma)$ associée à $\\sigma$ est la matrice à coefficients dans $\\{0, 1\\}$, de taille $n \\times n$, telle que pour tout $v = (v_0, \\dots, v_{n-1}) \\in \\mathbb{R}^n$, le vecteur $u = M v$ a pour coordonnées\n",
    "\n",
    "$$\n",
    "     u_i = v_{\\sigma(i)}, \\quad \\forall i \\in \\{ 0, \\dots, n-1 \\}\n",
    "$$\n",
    "\n",
    "\n",
    "Autrement dit, c'est la matrice $M$ telle que pour tout $(i,j) \\in \\{0, \\dots, n-1\\}$, on a :\n",
    "\n",
    "$$\n",
    "M_{i,j} = \\left\\{ \\begin{array}{ll} 1 &\\text{ si } i = \\sigma(j)\\\\ 0 & \\text{ sinon.} \\end{array}\\right.\n",
    "$$\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "**Question 6.** Écrire une fonction `matrice_permutation(L)` qui prend en entrée une permutation de $\\{0, \\dots, n-1\\}$ représentée sous forme d'une liste `L`, et qui retourne la matrice qui la représente. Puis, construire une permutation de longueur $6$, sa matrice de permutation $M$, et le vecteur ${\\bf v} = (1, 2, 3, 4, 5, 6)$, et vérifier que $M {\\bf v}$ est un bien le vecteur issu de ${\\bf v}$ dont on a permuté les coordonnées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8578d24",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "261a60e3",
   "metadata": {},
   "source": [
    "**Question 7.** Vérifier que la représentation matricielle respecte bien le produit et l'inverse déjà implémentés. C'est-à-dire, vérifier que le produit de deux matrices de permutation est égal à la matrice de la composition de deux permutations, puis que l'inverse d'une matrice de permutation est bien la matrice de l'inverse de la permutation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e9800e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6765a31a",
   "metadata": {},
   "source": [
    "**Question 8.** Écrire une fonction `permutation_par_matrice(M)`, qui est la fonction réciproque de `matrice_permutation(L)`. C'est-à-dire, cette fonction doit prendre en entrée une matrice `M` (que l'on supposera correspondre à une permutation $\\sigma \\in S_n$), et retourner la représentain sous forme de liste `L` de la permutation $\\sigma$. Tester la fonction sur un exemple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca8f54ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11d4da7c",
   "metadata": {},
   "source": [
    "## Partie B : propriétés et décompositions\n",
    "\n",
    "\n",
    "Soit $\\sigma \\in S_n$. Une **inversion** pour $\\sigma$ est un couple $(i, j) \\in \\{0, \\dots, n-1\\}$, avec $i < j$, tel que $\\sigma(i) > \\sigma(j)$. La **signature** de $\\sigma$, souvent notée $\\varepsilon(\\sigma)$, est égale $(-1)^k$ où $k$ est le nombre d'inversions de $\\sigma$. Autrement dit, $\\varepsilon(\\sigma) = 1$ si ce nombre est pair, et $-1$ sinon.\n",
    "\n",
    "\n",
    "**Question 9.** Écrire une fonction `signature(L)` qui calcule la signature d'une permutation représentée par une liste `L`, en comptant le nombre d'inversions. Tester la fonction sur `L = [0, 2, 4, 3, 1]` (de signature $1$), `L = [1, 2, 3, 0]` (de signature $-1$) et sur la permutation identité."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1899f15",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bd7a6d5",
   "metadata": {},
   "source": [
    "**Question 10.** Écrire une fonction `signature2(L)` qui calcule la valeur de \n",
    "\n",
    "$$\n",
    "    \\prod_{0 \\le i < j \\le n-1} \\frac{\\sigma(j)-\\sigma(i)}{j-i}\n",
    "$$\n",
    "\n",
    "pour la signature représentée par `L`. Puis, vérifier sur une centaine d'exemples tirés aléatoirement que la valeur obtenue est la même que celle de `signature(L)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "470d3991",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b88ebfb4",
   "metadata": {},
   "source": [
    "**Question 11.** Vérifier sur un exemple que la signature d'un produit de signature est le produit des signatures, et que la signature de l'inverse d'une permutation est égale à celle de la permutation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ed2742b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ce76185",
   "metadata": {},
   "source": [
    "## Partie C : polynômes de Dickson\n",
    "\n",
    "\n",
    "Avec Sagemath, l'anneau $\\mathbb{Z}/n\\mathbb{Z}$ des entiers réduits modulo $n$ peut être construit via l'instruction `Zmod(n)`.\n",
    "\n",
    "**Question 12.** Pour l'entier $n = 13$, construire l'anneau $\\mathbb{Z}/n\\mathbb{Z}$, puis l'anneau des polynômes à une variable et à coefficients dans $\\mathbb{Z}/n\\mathbb{Z}$. Enfin, construire la variable $X$ correspondant à cet anneau de polynômes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a027f8a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c64bbc1",
   "metadata": {},
   "source": [
    "Les **polynômes de Dickson** sont des polynômes qui peuvent être définis sur $\\mathbb{Z}/n\\mathbb{Z}$, avec $n$ un nombre premier, et qui fournissent des permutations de $\\mathbb{Z}/n\\mathbb{Z} \\simeq \\{0, \\dots, n-1\\}$. Ces polynômes sont paramétrés par un entier $k \\ge 0$ appelé ordre, et par un élément $a \\in \\mathbb{Z}/n\\mathbb{Z}$, et sont ainsi notés $D_{k,a}(X)$. Il sont définis par récurrence, pour tout $a \\in \\mathbb{Z}/n\\mathbb{Z}$, par $D_{0,a}(X) = 2$, $D_{1,a}(X) = X$ et pour tout $k \\ge 0$ : \n",
    "\n",
    "$$\n",
    "D_{k+2,a}(X) = X D_{k+1,a}(X) - a D_{k,a}(X)\n",
    "$$\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "**Question 13.** Écrire une fonction `dickson(k, a)` qui, étant donné $a \\in \\mathbb{Z}/n\\mathbb{Z}$ et $k \\ge 0$,  calcule le polynôme de Dickson $D_{k,a}(X)$ suivant la relation de récurrence donnée plus haut. Puis, vérifier pour un $a$ choisi arbitrairement que $D_{2,a}(X) = X^2 -2a$, $D_{5,a}(X) = X^5 - 5a X^3 + 5a^2 X$.\n",
    "\n",
    "_Indication : pour que votre implémentation s'exécute pour de grandes valeurs de $k$, il es conseillé d'employer une méthode itérative plutôt que récursive._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9f78a22",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b04f4f46",
   "metadata": {},
   "source": [
    "On peut démontrer que la forme explicite d'un polynôme de Dickson est :\n",
    "\n",
    "$$\n",
    "D_{k,a}(X) = \\sum_{i=0}^{\\lceil k/2 \\rceil} \\frac{k}{k-i} \\binom{k-i}{i} (-a)^i X^{k-2i}\n",
    "$$\n",
    "\n",
    "**Question 14.** Écrire une fonction `dickson_bis(n, a)` qui, étant donné $a \\in \\mathbb{Z}/n\\mathbb{Z}$ et $k \\ge 0$,  calcule le polynôme de Dickson $D_k(X, a)$ suivant la formule explicite donnée plus haut. Vérifier également que $D_{2,a}(X) = X^2 -2a$ et $D_{5,a}(X) = X^5 - 5a X^3 + 5a^2 X$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e70944d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51dec9fc",
   "metadata": {},
   "source": [
    "**Question 15.** Pour $n=13$ et pour tout $a \\in \\mathbb{Z}/n\\mathbb{Z}$, vérifier que pour toutes les valeurs $k$ allant de $1$ à $100$, les polynômes de Dickson vérifient les propriétés suivantes :\n",
    "1. le degré de $D_{k,a}(X)$ est $k$\n",
    "2. $D_{k,a}(X)$ satisfait l'équation différentielle :\n",
    "\n",
    "$$\n",
    "    (X^2 - 4 a) D_{k,a}''(X) + X D_{k,a}'(X) - k^2 D_{k,a}(X) = 0 \n",
    "$$\n",
    "\n",
    "3. si $k = r s$ avec $r \\ge 1$ et $s \\ge 1$, alors\n",
    "\n",
    "$$\n",
    "    D_{rs,a}(X) = D_{r,a^s}(D_{s,a}(X)) \n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b5d4a92",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c68bd977",
   "metadata": {},
   "source": [
    "Pour $n$ un nombre premier, $a \\ne 0$ et $k \\ge 1$, on énonce la propriété suivante : \"le polynôme de Dickson $D_{k,a}(X)$ induit une permutation de $\\mathbb{Z}/n\\mathbb{Z}$ si et seulement si $k$ est premier avec $n^2-1$\".\n",
    "\n",
    "**Question 16.** Pour $n=13$ et par tests exhaustifs, vérifier que la propriété énoncée est vraie pour tous les entiers $1 \\le k \\le 12$ et tous les $a \\in \\mathbb{Z}/n\\mathbb{Z}$ non nuls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f739f1a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre réponse ici"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38a74ab5",
   "metadata": {},
   "source": [
    "<!-- ## Partie D : décomposition d'une permutation en cycles -->\n",
    "\n",
    "\n",
    "\n",
    "<!-- Soit $1 \\le k \\le n$. Un **$k$-cycle** est une permutation $\\sigma \\in S_n$, telle qu'il existe $B = \\{ b_1, \\dots, b_k \\} \\subseteq \\{0, \\dots, n-1\\}$ de cardinal $k$ vérifiant : -->\n",
    "\n",
    "<!-- $$ -->\n",
    "<!-- \\sigma(b_i) = b_{i+1}, \\; \\forall i \\in \\{1, \\dots, k-1\\}, \\quad\\quad  \\sigma(b_k) = b_1 -->\n",
    "<!-- $$ -->\n",
    "<!-- ainsi que $\\sigma(i) = i$ pour tout $i \\in \\{0, \\dots, n-1\\} \\setminus B$. -->\n",
    "\n",
    "\n",
    "<!-- Le **support** d'un $k$-cycle est l'ensemble $B = \\{b_1, \\dots, b_k\\}$. -->\n",
    "\n",
    "\n",
    "<!-- Dans ce devoir, pour différencier la représentation des permutations (sous forme de liste) de celle des cycles, on représentera les $k$-cycles par des $k$-uplets. Pour rappel, avec **python** ou **sagemath**, un $k$-uplet est décrit comme une succession d'éléments séparés par des parenthèses (au lieu des crochets pour les listes) et n'est pas \"mutable\". -->\n",
    "\n",
    "\n",
    "<!-- **Question 16.** Écrire une fonction `cycle(B, n)` qui prend en entrée un entier $n$ et un $k$-uplet d'éléments disjoints $B = ( b_1, \\dots, b_k )$ (avec les $b_i$ deux à deux disjoints et dans $\\{0, \\dots, n-1\\}$), et qui retourne la représentation sous forme de liste du $k$-cycle associé à $B$ dans $S_n$. -->\n",
    "\n",
    "<!-- <only student> -->\n",
    "<!-- ```{code-cell} -->\n",
    "<!-- # Votre réponse ici -->\n",
    "<!-- ``` -->\n",
    "<!-- <endonly> -->\n",
    "\n",
    "<!-- <only teacher> -->\n",
    "<!-- ```{code-cell} -->\n",
    "<!-- def cycle(B, n): -->\n",
    "<!--     sigma = permutation_identite(n) -->\n",
    "<!--     k = len(B) -->\n",
    "<!--     for i in range(k-1): -->\n",
    "<!--         sigma[B[i]] = B[i+1] -->\n",
    "<!--     sigma[B[k-1]] = B[0] -->\n",
    "<!--     return sigma -->\n",
    "    \n",
    "<!-- print(cycle((1,2,3), 6)) -->\n",
    "<!-- ``` -->\n",
    "<!-- <endonly> -->\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<!-- Tout $k$-cycle peut être décomposé en produit de $2$-cycles, de la manière suivante : -->\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<!-- **Question 17.** --\\-> décomposition $k$-cycle en $2$-cycles <--- -->\n",
    "\n",
    "<!-- <only student> -->\n",
    "<!-- ```{code-cell} -->\n",
    "<!-- # Votre réponse ici -->\n",
    "<!-- ``` -->\n",
    "<!-- <endonly> -->\n",
    "\n",
    "<!-- <only teacher> -->\n",
    "<!-- ```{code-cell} -->\n",
    "<!-- print(\"todo\") -->\n",
    "<!-- ``` -->\n",
    "<!-- <endonly> -->\n",
    "\n",
    "<!-- **Attention !** Cette partie est plus difficile. Notre objectif est maintenant d'implémenter un algorithme qui décompose une permutation, d'abord en cycles à support disjoints, puis en $2$-cycles. -->\n",
    "\n",
    "\n",
    "<!-- Pour la **décomposition en produit de cycles à supports disjoints**, on a l'algorithme suivant : -->\n",
    "\n",
    "\n",
    "<!-- 1. Chercher les images successives de $0$ par la permutation $\\sigma$, jusqu'à ce qu'on revienne à $0$. Former une première liste $C_0$ contenant ces images : c'est le cycle associé à $x_1 = 0$. -->\n",
    "<!-- 2. Chercher un élément de $\\{0, \\dots, n-1\\}$ qui ne soit pas dans $C_0$ (s'il existe). Appelons $x_2$ cet élément. Refaire l'étape $1$ en remplaçant $0$ par $x_2$. Former ainsi une seconde liste $C_{x_2}$. -->\n",
    "<!-- 3. Itérer le procédé jusqu'à avoir épuisé tous les éléments de $\\{0, \\dots, n-1\\}$. -->\n",
    "\n",
    "<!-- Les listes $C_{x_1}, \\dots, C_{x_r}$ représentent alors une décomposition de $\\sigma$ en cycles à supports disjoints.  -->\n",
    "\n",
    "<!-- --\\-> faire un exemple <--- -->\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<!-- **Question 18.** Écrire une fonction `decompose_disjoints(L)` qui .........  -->\n",
    "\n",
    "<!-- <only student> -->\n",
    "<!-- ```{code-cell} -->\n",
    "<!-- # Votre réponse ici -->\n",
    "<!-- ``` -->\n",
    "<!-- <endonly> -->\n",
    "\n",
    "<!-- <only teacher> -->\n",
    "<!-- ```{code-cell} -->\n",
    "<!-- def decompose_disjoints(L): -->\n",
    "<!--     n = len(L) -->\n",
    "<!--     C = [] -->\n",
    "<!--     S = [ i for i in range(n) ] -->\n",
    "<!--     while len(S) != 0: -->\n",
    "<!--         x = S.pop(0) -->\n",
    "<!--         B = [x] -->\n",
    "<!--         i = x -->\n",
    "<!--         while L[i] != x: -->\n",
    "<!--             i = L[i] -->\n",
    "<!--             B.append(i) -->\n",
    "<!--             S.remove(i) -->\n",
    "<!--         if len(B) != 1: -->\n",
    "<!--             C.append(cycle(B, n)) -->\n",
    "<!--     return C -->\n",
    "\n",
    "<!-- print(decompose_disjoints([0,1,2,3,4,5])) -->\n",
    "<!-- print(decompose_disjoints([1,2,3,4,5,0])) -->\n",
    "<!-- print(decompose_disjoints([1,2,0,4,3,5])) -->\n",
    "<!-- ``` -->\n",
    "<!-- <endonly> -->\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<!-- **Question 19.** Écrire une fonction `decompose_2cycles(L)` qui .........  -->\n",
    "\n",
    "<!-- <only student> -->\n",
    "<!-- ```{code-cell} -->\n",
    "<!-- # Votre réponse ici -->\n",
    "<!-- ``` -->\n",
    "<!-- <endonly> -->\n",
    "\n",
    "<!-- <only teacher> -->\n",
    "<!-- ```{code-cell} -->\n",
    "<!-- def decompose_2cycles(L): -->\n",
    "<!--     pass -->\n",
    "\n",
    "<!-- print(decompose_2cycles([0,1,2,3,4,5])) -->\n",
    "<!-- print(decompose_2cycles([1,2,3,4,5,0])) -->\n",
    "<!-- print(decompose_2cycles([1,2,0,4,3,5])) -->\n",
    "<!-- ``` -->\n",
    "<!-- <endonly> -->"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Sagemath",
   "language": "python",
   "name": "sagemath"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}