Add introduction

content/docs/data-structures/exercises.md

@@ -5,9 +5,17 @@ weight: 50
 
 # Exercices 
 
-## Bases de connaissance et requêtes
+## Opérations sur listes
 
-## Relations
+1. Proposer une constellation répondant à l'étoile `@-last(l R);` pour une liste
+`l` telle que `R` contiendra le dernier élément de `l`.
+
+2. Proposer une constellation répondant à l'étoile `@-length(l R) R;` pour une
+liste `l` telle que `R` contiendra la taille de `l`.
+
+3. Proposer une constellation répondant à l'étoile `@-nth(i l R) R;`
+pour un entier `i` en unaire et une liste `l` telle que `R` contiendra le `i`ème
+élément de  `l`.
 
 ## Parcours de graphes
 
@@ -15,8 +23,6 @@ weight: 50
 
 ### Parcours performatif
 
-## Opérations sur listes
-
 ## Conversions d'entiers
 
 ### Décimal vers unaire

content/docs/data-structures/lists.md

@@ -39,10 +39,10 @@ On peut aussi opter pour une représentation avec polarités internes :
 ### Test liste vide
 
 ```
-+empty(e);
++empty?(e);
 
-@-empty(e) ok;
-@-empty(1:e) ok;
+@-empty?(e) ok;
+@-empty?(1:e) ok;
 ```
 
 ### Concaténation
@@ -57,9 +57,9 @@ On peut aussi opter pour une représentation avec polarités internes :
 ### 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-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;
 ```

content/docs/introduction/large-star-collider.md

@@ -3,4 +3,12 @@ title: "Large star collider"
 weight: 30
 ---
 
-(soon)
+# Large Star Collider
+
+Le Large Star Collider (LSC) est une réalisation informatique possible de la
+résolution stellaire qui fait des choix de conception pour s'adapter aux
+pratiques de programmation.
+
+Il s'agit uniquement d'un noyau minimal de fonctionnement qui permet de calculer
+d'après les principes de résolution stellaire. D'autres couches peuvent exister
+par dessus pour l'étendre (metalangages, langages de macros etc).

content/docs/introduction/stellar-resolution.md

@@ -3,4 +3,33 @@ title: "Résolution stellaire"
 weight: 20
 ---
 
-(soon)
+# Résolution stellaire
+
+La résolution stellaire est le langage utilisé dans la syntaxe transcendantale.
+Il s'agit d'un langage fonctionnant par interaction asynchrone d'agents
+indépendants. Cette interaction se base sur un algorithme d'unification servant
+de noyau minimal du calcul.
+
+Il représente le calcul par un réseau de contraintes syntaxiques qui doivent
+être résolues pour propager de l'information. Le résultat du calcul correspond
+aux informations laissées par les réseaux qui sont restés cohérents jusqu'au
+bout sand rencontrer de conflits. 
+
+Ce sont des idées qui existent déjà en programmation logique mais qui sont
+reformulées et utilisées différemment. En particulier, on attache aucun sens
+logique aux objets (même si on peut les voir comme tel, ils ne sont pas censés
+représenter pas des relations ou des objets de systèmes logiques). 
+
+Ce calcul peut être compris de plusieurs manières. C'est :
+- un calcul de processus
+- un langage de programmation par contrainte
+- une variante des clauses disjonctives avec règle de résolution de Robinson
+- une généralisation non planaire des tuiles de Wang ou des abstract tile
+  assembly models (aTAM)
+- une généralisation des tuiles flexibles de Jonoska utilisés en calcul ADN
+- une généralisation des briques LEGO
+- un langage de bas niveau exprimant le sens logique
+- une boîte à outils pour construire des types/formules
+- une généralisation des structures de preuves de Jean-Yves Girard
+- une forme de réseaux d'interaction de Lafont ne reposant sur aucune règle
+  autre que les principes d'unification de termes

content/docs/introduction/transcendental-syntax.md

@@ -3,4 +3,15 @@ title: "Syntaxe transcendantale"
 weight: 10
 ---
 
-(soon)
+# Syntaxe transcendantale
+
+La logique vit habituellement dans des *systèmes logiques* tous ou plus ou moins
+compatibles entre eux. On peut parler de pluralisme logique. 
+
+Les logiques fonctionnent habituellement avec une base calculatoire appelée
+*syntaxe* qui suit les règles dictées par une autre syntaxe de plus haut niveau
+qu'on appelle *sémantique*. En particulier, sont imposés : les objets
+utilisable, leur forme, leurs interactions possibles et les formules ou 
+spécifications que l'on peut exprimer.
+
+TODO

content/docs/playing/syntax.md

@@ -5,16 +5,16 @@ weight: 20
 
 # Rayons
 
-Soit une variable de la forme `[A-Z][A-Z 0-9]*` ou un symbole de fonction
-polarisé ou non par `+` ou `-` de la forme `(+|-)?[a-z 0-9 _]+` appliqué à une
+Soit une variable de la forme `[A-Z] [A-Z 0-9 _ -]* '*` ou un symbole de fonction
+polarisé ou non par `+` ou `-` de la forme `(+|-)?[a-z 0-9] [a-z A-Z 0-9 _ -]* '* '?'?` appliqué à une
 séquence ordonnée d'autres rayons en arguments (séquence possiblement vide dans
 le cas d'une constante) :
 
-`X`, `a`, `f(X)`, `+f(X)`, `-f(-h(a, Y1), X2)`, `+add_dec(0, 2, 2)`.
+`X`, `a`, `f(X)`, `+f(X)`, `-f(-h(a, Y1), X2)`, `+add-dec(0, 2, 2)`.
 
 Les virgules séparant les arguments peuvent être omises :
 
-`-f(-h(a Y1) X2)`, `+add_dec(0 2 2)`, `string(hello i am X)`.
+`-f(-h(a Y1) X2)`, `+add-dec(0 2 2)`, `string(hello i am X)`.
 
 # Concaténation
 
@@ -31,13 +31,15 @@ Une séquence non-ordonnée de rayons terminant par un point-virgule `;`:
 X a +f(X);
 ```
 
+L'étoile vide est `[]`.
+
 # Constellations
 
 Une séquence non-ordonnée d'étoiles :
 
 ```
 X a +f(X); -f(-h(a Y1) X2);
-+add_dec(0 2 2);
++add-dec(0 2 2);
 ```
 
 Toutes les variables sont locales à leur étoile. Donc, toutes les occurrences
@@ -48,6 +50,9 @@ ligne.
 Il n'y a pas de sensibilité à l'indentation ou aux sauts de ligne.
 {{< /hint >}}
 
+La constellation vide est `{}` (elle peut apparaître en résultat
+mais on ne peut pas l'écrire en tant qu'utilisateur).
+
 # Focus
 
 Pour choisir des points de départ du calcul, il est possible de préfixer
@@ -56,7 +61,7 @@ certaines étoiles (de notre choix) avec un symbole de *focus* `@`.
 ```
 @X a +f(X);
 @-f(-h(a Y1) X2);
-+add_dec(0 2 2);
++add-dec(0 2 2);
 ```
 
 # Commentaires 

content/docs/techniques/exercises.md

@@ -49,4 +49,69 @@ else
     no problem
 ```
 car cela requiert des mécanismes de liaisons séquentielles.
+{{< /hint >}}
+
+## Bases de connaissance et requêtes
+
+Prendre la base de connaissance suivante :
+
+```
++father(francisco paulo);
++father(joao paulo);
++father(ana francisco);
++mother(rita roberta);
++mother(joao roberta);
++mother(francisco roberta);
++mother(roberta maria);
+```
+
+1. Quelle étoile ajouter pour demander si le père d'ana est francisco de telle
+sorte à ce que l'exécution renvoie ok quand c'est bien le cas ?
+
+{{< hint info >}}
+@-father(ana francisco) ok;
+{{< /hint >}}
+
+2. Même exercice pour demander qui est la mère de joao de telle sorte à ce que
+l'exécution renvoie le nom de la mère de joao.
+
+{{< hint info >}}
+@-mother(joao X) X;
+{{< /hint >}}
+
+3. Même exercice pour demander qui sont les enfants de roberta et paulo.
+
+{{< hint info >}}
++children(X M F) -mother(X M) -father(X F);
+@-children(X roberta paulo) X;
+{{< /hint >}}
+
+4. Définir une constellation qui permet de donner le grand-père d'une personne.
+
+{{< hint info >}}
++grand-father(X GF) -father(X F) -father(F GF);
+{{< /hint >}}
+
+5. Définir une requête qui permet de lister toutes les relations de
+petit-fils/grand-père.
+
+{{< hint info >}}
++grand-father(X GF) -father(X F) -father(F GF);
+@-grand-father(X Y) grand-father(X Y);
+{{< /hint >}}
+
+6. Donner une nouvelle représentation de la base de connaissance qui permet de
+lister toutes les relations père et mère à l'aide d'une étoile
+`@-parent(R X Y) parent(R X Y)` où `R` correspond à la relation entre `X` et `Y`.
+
+{{< hint info >}}
+```
++parent(father francisco paulo);
++parent(father joao paulo);
++parent(father ana francisco);
++parent(mother rita roberta);
++parent(mother joao roberta);
++parent(mother francisco roberta);
++parent(mother roberta maria);
+```
 {{< /hint >}}