---
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 >}}

## Circuits booléens

On veut simuler des formules booléennes (plus précisément des circuits) 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 >}}

5. En utilisant l'étoile `+share(X X X);`, définir le circuit booléen pour 
la formule du tiers exclu qui prend une unique entrée, la partage au travers de
deux sorties avec l'une qui passe par une porte NOT et pour rejoindre l'autre
sortie à travers une porte OR. Afficher la table de vérité correspondant à ce
circuit.

{{< 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);

+share(X X X);

'excluded middle
-share(X X1 X2) -not(X1 R1) -or(R1 X2 R2) +ex(R2);

@-ex(X) table_ex(X);
```
{{< /details >}}