---
title: "Interactions élémentaires" 
weight: 4
---

# Interactions élémentaires

Ouvrez votre éditeur de code favori et pratiquons avec le LSC !

## Fusion

Une interaction simple entre deux étoiles avec transfert de la constante `a` :
```
+f(X) X; 's1
@-f(a);  's2
```

Les deux étoiles `s1` et `s2` se sont fusionnées en interagissant le long de
`+f(X)` et `-f(a)` (d'unificateur `{X:=a}`) laissant `X{X:=a} = a` en résultat. 

On peut étendre ce transfert en traversant plusieurs étoiles :

```
+f1(X1) X1;
-f1(X2) +f2(X2);
-f2(X3) +f3(X3);
@-f3(a);
```

## Effacement

Pour rappel, les étoiles qui contiennent des rayons polarisés sont effacés du
résultat de l'exécution. Cela permet donc de pouvoir gérer l'effacement ou la
conservation d'étoiles.

```
+f(X) +g(X);
@-f(a);
```

Ci-dessus, on a bien une interaction, mais le résultat est un rayon polarisé
qui attend d'être connecté. On obtient donc `{}` comme résultat.

On peut rajouter une étoile afin d'obtenir un résultat :

```
-g(X) X;
+f(X) +g(X);
@-f(a);
```

## Multi-focus

On peut utiliser plusieurs focus pour effectuer plusieurs calculs en parallèle :

```
+f(a);
+g(X) -g1(X);
+g1(X) -g2(X);
+g2(b);
+h(c);

@-f(X) X;
@-g(X) X;
@-h(X) X;
```

## Duplication

Il se peut qu'un même rayon de l'espace d'interaction soit compatible avec
deux rayons de deux étoiles différentes de la constellation de référence. Dans
ce cas, il y a une duplication :

```
-f(a);
-f(b);
@+f(X) X; 'étoile dupliquée
```

Une telle duplication est une "bifurcation" puisqu'elle génère deux étoiles
vues comme deux choix non-déterministes matérialisés dans deux branches
disjointes `a; b`.

Cependant, il est aussi possible d'avoir une duplication "déterministe" au sein
d'une même étoile : 

```
+f(a) +f(b); +g(a); @+g(b);
-f(X) -g(X) 0; 'étoile dupliquée
```

## Boucles

Il est possible de faire des boucles infinies :
```
-f(X) +f(X) 0;
@-f(X);
```

Mais aussi finies en faisant décroître un argument à chaque interaction et en
définissant une étoile en charge de l'arrêt de la boucle (comme en programmation
logique et fonctionnelle) :
```
+f(0);
-f(X) +f(g(X)) 0;
@-f(g(g(g(0))));
```