Exercices
Chemins
Donnez une valeur aux variables answer
de sorte à pouvoir exécuter
le code suivant sans erreur de typage.
L'idée est que ces constellations représentent des chemins à compléter de sorte
à obtenir seulement la constellation ok
en résultat.
checker = galaxy
interaction: #test #tested.
expect: { ok }.
end
empty = {}.
answer = #replace_me.
exercise1 :: empty [checker].
exercise1 = ((-1 ok) {1})[1=>answer].
answer = #replace_me.
exercise2 :: empty [checker].
exercise2 = ((-1; +2) {1})[1=>answer].
answer = #replace_me.
exercise3 :: empty [checker].
exercise3 = ((-1 ok; -2 +3) {1})[1=>answer].
answer = #replace_me.
exercise4 :: empty [checker].
exercise4 = ((-f(+g(X)) ok) {1})[1=>answer].
answer = #replace_me.
exercise5 :: empty [checker].
exercise5 = ((+f(a) +f(b); +g(a); @+g(b) ok) {1})[1=>answer].
Solutions
checker = galaxy
interaction: #test #tested.
expect: { ok }.
end
empty = {}.
answer = +1.
exercise1 :: empty [checker]
exercise1 = ((-1 ok) {1})[1=>answer].
answer = +1 -2 ok.
exercise2 :: empty [checker]
exercise2 = ((-1; +2) {1})[1=>answer].
answer = +1 +2; -3.
exercise3 :: empty [checker]
exercise3 = ((-1 ok; -2 +3) {1})[1=>answer].
answer = +f(-g(X)).
exercise4 :: empty [checker]
exercise4 = ((-f(+g(X)) ok) {1})[1=>answer].
answer = -f(a); -f(b) -g(a) -g(b).
exercise5 :: empty [checker]
exercise5 = ((+f(a) +f(b); +g(a); @+g(b) ok) {1})[1 => answer].
Registres dynamiques
Partons du programme suivant :
init = +r0(0).
print process
init.
{replace_me}.
end
représentant une mémoire avec un registre r0
.
Stellogen peut représenter la mémoire mais d'une façon particulière, en
détruisant pour construire ailleurs.
On ne peut pas se contenter de mettre à jour le registre avec une étoile
-r0(X) +r0(1)
car cette étoile a une dépendance circulaire qui lui
permettrait d'être réutilisée un nombre illimité de fois.
En fait, on ne peut que déplacer le registre pour le modifier, par exemple avec
une étoile -r0(0) +r1(1)
qui détruit le registre r0
et construit un
registre r1
contenant 1
.
Le but est de définir des constellations. Vous pouvez utiliser le code ci-dessus pour faire vos tests.
Exercice 1. Définir deux constellations permettant de mettre à jour le
registre r0
à 1
en utilisant une étoile intermédiaire pour sauvegarder la
valeur de r0
.
Solution
-r0(X) +tmp0(X).
-tmp0(X) +r0(1).
Exercice 2. Définir une constellation permettant de dupliquer et déplacer
le registre r0
dans deux registres r1
et r2
.
Solution
-r0(X) +r1(X);
-r0(X) +r2(X).
Exercice 3. Définir deux constellation permettant de mettre la valeur de
r1
à 0
puis définir deux constellations permettant d'échanger les valeurs
de r1
et r2
.
Solution
-r1(X) +tmp0(X).
-tmp0(X) +r1(0).
-r1(X) +s1(X); -r2(X) +s2(X).
-s1(X) +r2(X); -s2(X) +r1(X).
Exercice 4. Comment dupliquer r1
de sorte à pouvoir suivre ses copies et
mettre à jour en une fois (comme si on traitait un seul registre) toutes les
copies à la valeur 5
?
Solution
-r1(X) +r1(l X);
-r1(X) +r1(r X).
-r1(A X) +tmp0(A X).
-tmp0(A X) +r1(A 5).
Exercice 5. En suivant la méthode précédente, dupliquer chaque copie en une seule fois.
Solution
-r1(A X) +r1(l A X);
-r1(A X) +r1(r A X).
Logique booléenne
On veut simuler des formules booléennes par des constellations. Chaque question utilise le résultat de la question précédente.
Exercice 1. Définir une constellation calculant la négation de telle sorte
à ce qu'elle produise 1
en sortie lorsqu'elle est ajoutée à l'étoile
@-not(0 X) X
et 0
lorsqu'ajoutée à @-not(1 X) X
.
Solution
not = +not(0 1); +not(1 0).
Exercice 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).
?
Solution
print @-not(X Y) table_not(X Y).
Exercice 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.
Solution
and = +and(0 0 0); +and(0 1 0); +and(1 0 0); +and(1 1 1).
or = +or(0 0 0); +or(0 1 1); +or(1 0 1); +or(1 1 1).
and2 = +and2(0 X 0); +and2(1 X X).
or2 = +or2(0 X X); +or2(1 X 1).
print @-and(X Y R) table_and(X Y R).
print @-or(X Y R) table_or(X Y R).
print @-and2(X Y R) table_and2(X Y R).
print @-or2(X Y R) table_or2(X Y R).
Exercice 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
.
Solution
impl = -not(X Y) -or(Y Z R) +impl(X Z R).
impl2 = -not(X Y) -or2(Y Z R) +impl2(X Z R).
print @-impl(X Y R) table_impl(X Y R).
print @-impl2(X Y R) table_impl2(X Y R).
Exercice 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)
.
Solution
eqq = -impl(X Y R1) -impl(Y X R2) -and(R1 R2 R) +eqq(X Y R).
eqq2 = -impl2(X Y R1) -impl2(Y X R2) -and2(R1 R2 R) +eqq2(X Y R).
table_eqq = @-eqq(X Y R) table_eqq(X Y R).
table_eqq2 = @-eqq2(X Y R) table_eqq2(X Y R).
Exercice 6. Définir une constellation représentant la formule du tiers
X \/ ~X
. Afficher la table de vérité correspondant à cette formule.
Solution
ex = -not(X R1) -or(R1 X R2) +ex(X R2).
print -ex(X R) table_ex(X R).
Exercice 7. Déterminer pour quelles valeurs de X
, Y
et Z
la formule
X /\ ~(Y \/ Z)
est vraie.
Solution
print -or(Y Z R1) -not(R1 R2) -and(X R2 1) x(X) y(Y) z(Z).