205 lines
5.7 KiB
Markdown
205 lines
5.7 KiB
Markdown
---
|
|
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 >}} |