---
title: "Exercices" 
weight: 5
---

# Exercices 

## Chemins

Ajouter des étoiles aux constellations suivantes de sorte à obtenir `ok` après
exécution avec l'option `-allow-unfinished-computation`.

1. `-1 ok;`

2. `-1; +2;`

3. `-1 ok; -2 +3;`

4. `-f(+g(X)) ok;`

5. `+f(a) +f(b); +g(a); @+g(b) ok;`

{{< details title="Solution" open=false >}}
1. `-1 ok; +1;`

2. `-1; +2; +1 -2 ok;`

3. `-1 ok; -2 +3; +1 +2; -3;`

4. `-f(+g(X)) ok; +f(-g(a));`

5. `+f(a) +f(b); +g(a); @+g(b) ok; -f(X) -g(X);`
{{< /details >}}

## Altération de mémoire

Considérons la constellation suivante représentant des registres dans lesquels
on peut stocker des données (ils sont tous initialisés à `0`) :
```
' initialisation
+ia(0); +ib(0);

@-ra(X) +a(X); ' registre a
@-rb(X) +b(X); ' registre b
```

Pour chaque question, vous pouvez soit ajouter des étoiles à la constellation
de départ ou modifier celles que vous avez ajoutées.

1. Comment relier les étoiles d'initialisation de sorte à initialiser le
registre `a` à `0` ?

{{< details title="Solution" open=false >}}
En ajoutant l'étoile `-ia(X) +ra(X);` servant de pont entre le rayon `+ia(0)`
et le rayon `-ra(X)`. On peut vérifier que l'on a bien un transfert de la
constante `0` vers `+a(X)` avec l'option `-allow-unfinished-computation` et
qu'on obtient ainsi `+a(0)` dans la sortie.
{{< /details >}}

2. Comment afficher la valeur de `a` et ainsi obtenir `a(0)` en sortie ? 

{{< details title="Solution" open=false >}}
Il faut ajouter l'étoile `-a(X) a(X);` pour éviter l'effacement de l'étoile
correspondant au registre `a`.
{{< /details >}}

3. Comment mettre à jour `a` à la valeur `1` ?

{{< details title="Solution" open=false >}}
Il y a plusieurs manières de le faire en remplaçant l'étoile `-ia(X) +ra(X)`
introduite précédemment :
- court-circuiter avec `+ra(1)`;
- faire une succession de mise à jour avec l'étoile `-ia(X) +ia1(1); -ia1(X) +ra(X);`.
{{< /details >}}

4. Comment copier la valeur de `a` dans `b` et afficher `b` ?

{{< details title="Solution" open=false >}}
On utilise la constellation `-a(X) +rb(X); -b(X) b(X);` permettant de rediriger
la sortie `+a(X)` vers `b` (en plus de l'affichage de `a`). Et on ajoute une
étoile d'affichage comme pour `a`.
{{< /details >}}

5. En utilisant une seule étoile, comment afficher `mem(a(va) b(vb))` tel que
`va` est la valeur de `a` et `vb` celle de `b` ? 

{{< details title="Solution" open=false >}}
On utilise l'étoile `-a(X) -b(Y) c(va(X) vb(Y));`.
{{< /details >}}

## Portes logiques

On veut simuler des formules booléennes par des constellations. Chaque question
utilise le résultat de la question précédente.

1. Ecrire une constellation calculant la négation de telle sorte à ce qu'elle
produise `1` en sortie lorsqu'ajoutée à l'étoile `@-not(0 X) X;` et `0`
lorsqu'ajoutée à `@-not(1 X) X`.

{{< details title="Solution" open=false >}}
```
+not(0 1); +not(1 0);
```
{{< /details >}}

2. Comment afficher la table de vérité de la négation avec une seule étoile,
de sorte à ce qu'on obtienne en sortie `table_not(0 1); table_not(1 0);` ?

{{< details title="Solution" open=false >}}
```
@-not(X Y) table_not(X Y);
```
{{< /details >}}

3. Ecrire de deux manières différentes des constellations calculant la
conjonction et la disjonction et afficher leur table de vérité de la même façon
que pour la question précédente.

{{< details title="Solution" open=false >}}
```
+and(0 0 0); +and(0 1 0); +and(1 0 0); +and(1 1 1);
+or(0 0 0); +or(0 1 1); +or(1 0 1); +or(1 1 1);

+and2(0 X 0); +and2(1 X X);
+or2(0 X X); +or2(1 X 1);

@-and(X Y R) table_and(X Y R);
@-or(X Y R) table_or(X Y R);
@-and2(X Y R) table_and2(X Y R);
@-or2(X Y R) table_or2(X Y R);
```
{{< /details >}}

4. Utiliser la disjonction et la négation pour afficher la table de vérité
de l'implication sachant que `X => Y = not(X) \/ Y`.

{{< details title="Solution" open=false >}}
```
+not(0 1); +not(1 0);
+and(0 0 0); +and(0 1 0); +and(1 0 0); +and(1 1 1);
+or(0 0 0); +or(0 1 1); +or(1 0 1); +or(1 1 1);

+and2(0 X 0); +and2(1 X X);
+or2(0 X X); +or2(1 X 1);

-not(X Y) -or(Y Z R) +impl(X Z R);
-not(X Y) -or2(Y Z R) +impl2(X Z R);

@-impl(X Y R) table_impl(X Y R);
@-impl2(X Y R) table_impl2(X Y R);
```
{{< /details >}}

5. Utiliser l'implication et la conjonction pour afficher la table de vérité
de l'équivalence logique sachant que `X <=> Y = (X => Y) /\ (X => Y)`.

{{< details title="Solution" open=false >}}
```
+not(0 1); +not(1 0);
+and(0 0 0); +and(0 1 0); +and(1 0 0); +and(1 1 1);
+or(0 0 0); +or(0 1 1); +or(1 0 1); +or(1 1 1);

+and2(0 X 0); +and2(1 X X);
+or2(0 X X); +or2(1 X 1);

-not(X Y) -or(Y Z R) +impl(X Z R);
-not(X Y) -or2(Y Z R) +impl2(X Z R);

-impl(X Y R1) -impl(Y X R2) -and(R1 R2 R) +eqq(X Y R);
-impl2(X Y R1) -impl2(Y X R2) -and2(R1 R2 R) +eqq2(X Y R);

@-eqq(X Y R) table_eqq(X Y R);
@-eqq2(X Y R) table_eqq2(X Y R);
```
{{< /details >}}