diff --git a/content/docs/data-structures/_index.md b/content/docs/data-structures/_index.md
new file mode 100644
index 0000000..40433c8
--- /dev/null
+++ b/content/docs/data-structures/_index.md
@@ -0,0 +1,5 @@
+---
+title: "Structures de données" 
+bookFlatSection: true
+weight: 40
+---
diff --git a/content/docs/data-structures/encoding-techniques.md b/content/docs/data-structures/encoding-techniques.md
new file mode 100644
index 0000000..797f3b7
--- /dev/null
+++ b/content/docs/data-structures/encoding-techniques.md
@@ -0,0 +1,58 @@
+---
+title: "Techniques d'encodage"
+weight: 10
+---
+
+# Techniques d'encodage 
+
+Il existe deux manières d'encoder des structures de données.
+
+## Encodage algébrique
+
+On peut encoder des structures de données directement dans les rayons comme
+on le ferait en programmation fonctionnelle. 
+
+Dans ce cas-là, les structures de données sont vues comme des objets statiques
+qu'on évalue. Cela nous donne principalement des structures d'arbres et
+d'ensembles.
+
+Par exemple :
+
+```
+'unary integer
++nat(s(s(s(0))));
+
+'pair
++pair(a b);
+
+'list
++list(0 1 0);
++list(0:1:0:e);
++list(0(1(0(e))));
++cons(0, +cons(1, +cons(0, e)));
+
+'tree
+-and(-or(X Y) -not(Y));
+
+'set
++a +b +c +d +e; 'dependent
++a; +b; +c; +d; +e; 'independent
++list(0(1(e))) +nat(s(s(0))) +cons(0, +cons(1, e));
+
+'graph
++e(1 2); +e(2 3); +e(1 4);
+```
+
+## Encodage interactif 
+
+On peut aussi encoder une structure en jouant sur la compatibilité entre les
+rayons. Ainsi, la géométrie de la structure est reflétée par les dépendances
+entre les rayons.
+
+Une liste prendrait la forme d'étoiles qui peuvent s'enchaîner durant
+l'exécution. Un arbre serait un ensemble d'étoiles dont les dépendances forment
+une arborescence.
+
+Dans ce cas, on encode les structures de données par des sortes d'hypergraphes
+interactifs.
+
diff --git a/content/docs/data-structures/exercises.md b/content/docs/data-structures/exercises.md
new file mode 100644
index 0000000..d7d2d32
--- /dev/null
+++ b/content/docs/data-structures/exercises.md
@@ -0,0 +1,24 @@
+---
+title: "Exercices" 
+weight: 50
+---
+
+# Exercices 
+
+## Bases de connaissance et requêtes
+
+## Relations
+
+## Parcours de graphes
+
+### Parcours évaluatif
+
+### Parcours performatif
+
+## Opérations sur listes
+
+## Conversions d'entiers
+
+### Décimal vers unaire
+
+### Unaire vers décimal
diff --git a/content/docs/data-structures/hypergraphs.md b/content/docs/data-structures/hypergraphs.md
new file mode 100644
index 0000000..98c78f4
--- /dev/null
+++ b/content/docs/data-structures/hypergraphs.md
@@ -0,0 +1,6 @@
+---
+title: "Hypergraphes" 
+weight: 40
+---
+
+(Soon)
\ No newline at end of file
diff --git a/content/docs/data-structures/lists.md b/content/docs/data-structures/lists.md
new file mode 100644
index 0000000..f84e644
--- /dev/null
+++ b/content/docs/data-structures/lists.md
@@ -0,0 +1,108 @@
+---
+title: "Listes" 
+weight: 20
+---
+
+# Listes algébriques
+
+## Séquences fixes
+
+```
++list(a b c d);
+```
+
+## Pile de constantes
+
+```
++list(a(b(c(d(e)))));
+```
+
+## Listes générales
+
+Si on souhaite lister des rayons arbitraires alors on peut utiliser n'importe
+quel symbole de fonction binaire et notamment le symbole spécial `:` qui
+correspond à un symbole binaire `:(_, _)` en interne (associatif à droite) :
+
+```
++list(a:b:c:d:e);
++list(cons(a, cons(b, cons(c, cons(d, e)))));
+```
+
+On peut aussi opter pour une représentation avec polarités internes :
+
+```
++cons(a, +cons(b, +cons(c, +cons(d, e))));
+```
+
+## Quelques opérations sur les listes générales
+
+### Test liste vide
+
+```
++empty(e);
+
+@-empty(e) ok;
+@-empty(1:e) ok;
+```
+
+### Concaténation
+
+```
++append(e L L);
+-append(T L R) +append(H:T L H:R);
+
+@-append(a:b:e c:d:e R) R;
+```
+
+### Inverse d'une liste
+
+```
++rev_acc(e ACC ACC);
+-rev_acc(T H:ACC R) +rev_acc(H:T ACC R);
+-rev_acc(L e R) +rev(L R);
+
+@-rev(a:b:c:d:e R) R;
+```
+
+### Map
+
+```
++funcall(f X f(X));
+
++map(X e e);
+-funcall(F H FH) -map(F T R) +map(F H:T FH:R);
+
+@-map(f a:b:c:d:e R) R;
+```
+
+# Listes interactives
+
+Une liste interactive est définie par un enchaînement d'étoiles. On ne
+représente plus la liste mais le processus de création de liste :
+
+```
++l(0 a:X) -l(1 X);
++l(1 b:X) -l(2 X);
++l(2 c:X) -l(3 X);
++l(3 d:X) -l(4 X);
++l(4 e);
+
+@-l(0 X) X;
+```
+
+En remplaçant le `0` de `@-l(0 X) X`, cela nous permet de demander la liste à
+partir d'un certain indice :
+
+```
++l(0 a:X) -l(1 X);
++l(1 b:X) -l(2 X);
++l(2 c:X) -l(3 X);
++l(3 d:X) -l(4 X);
++l(4 e);
+
+@-l(2 X) X;
+```
+
+On peut aussi imaginer des variantes de représentations qui permettent d'agir
+sur les éléments de la liste. On peut aussi imaginer jouer avec des boucles
+pour former des listes circulaires ou alors générer une liste automatiquement. 
\ No newline at end of file
diff --git a/content/docs/data-structures/trees.md b/content/docs/data-structures/trees.md
new file mode 100644
index 0000000..961cc16
--- /dev/null
+++ b/content/docs/data-structures/trees.md
@@ -0,0 +1,6 @@
+---
+title: "Arbres" 
+weight: 30
+---
+
+(Soon)
\ No newline at end of file