TD 12 – Circuits

Langages formels, calculabilité et complexité ENS Paris – A1S1 2019-2020

19 décembre 2019 NathanGrosshans

TD 12 – Circuits

1 Classe AC

Un circuit booléen avec n bits d’entrée est un graphe orienté acyclique (DAG) où les feuilles sont soit une des variables d’entrée x_i (i∈[[1, n]]) soit une constante >ou ⊥, la sortie est l’unique nœud dont le degré sortant est nul et chaque nœud est soit un nœud ∧ ou ∨ (qui peuvent être d’arité quelconque) soit un nœud ¬ (unaire). Étant donné un mot w ∈ {0,1}ⁿ avec n ∈ N et un circuit booléen dont la taille d’entrée est n, on peut évaluer le circuit sur w en remplaçant la i-ème feuille d’entrée par > quand wi = 1 et ⊥ quand wi = 0. Un tel circuit décide donc le langage des mots de {0,1}ⁿ sur lesquels il s’évalue à >.

On dit qu’une famille de circuits (C_n)n∈N décide un langage L ⊆ {0,1}^∗ lorsque pour chaque n∈N, le circuitCna nbits d’entrée et décide L∩ {0,1}ⁿ.

On définit la classe ACⁱ pouri∈Ncomme la classe des langages sur{0,1}décidés par une famille de circuits booléens (C_n)n∈N dont la taille est polynomiale et dont la profondeur est en O(log(n)ⁱ), c’est à dire qu’il existe un polynôme p et un entier k tels que pour tout n ∈ N, la taille de Cn est majorée parp(n) et la profondeur de C_n est majorée par k·log(n)ⁱ.

Exercice 1.Justifier que l’on ne s’intéresse qu’aux circuits de taille polynomiale (et non pas expo- nentielle ou illimitée).

Solution 1.Soit un langageL⊆ {0,1}ⁿ pour n∈N.

En posant ϕ_u(x₁, . . . , x_n) = V

i∈[[1,n]],ui=1x_i ∧V

i∈[[1,n]],ui=0¬x_i pour tout u ∈ {0,1}ⁿ, il suit que ϕu(x1, . . . , xn) s’évalue à>si et seulement si le mot en entrée est u, et donc on a que le circuit

_

u∈L

ϕu(x1, . . . , xn) décideL.

Il est ainsi possible de décider n’importe quel langage L ⊆ {0,1}ⁿ avec n ∈ N par un circuit de profondeur au plus 3.

Exercice 2.Montrer que le langage PARITY={w∈ {0,1}^∗| |w|₁= 1 mod2} est dans AC¹. Solution 2.On construit des circuits⊕(x₁, . . . , x_n)décidant PARITY∩ {0,1}ⁿ pour toutn∈Npar induction surn. On pose⊕(ε) =⊥,⊕(x₁) =x1 et pour tout n∈N, n≥2,

⊕(x₁, . . . , x_n) = ⊕(x₁, . . . , x_dn/2e)∧ ¬ ⊕(x_dn/2e+1, . . . , x_n)

∨

¬ ⊕(x₁, . . . , x_dn/2e)∧ ⊕(x_dn/2e+1, . . . , xn) .

Exercice 3.Montrer que le langage

ADD={abc∈ {0,1}^∗| |a|+ 1 =|b|+ 1 =|c|,a+b=c aveca, b, c en binaire petit-boutiste} est dans AC⁰.

Solution 3.Dans la suite, pour alléger la notation, pour deux cicuitsC etD, on écriraC⊕D pour (C∧ ¬D)∨(¬C∧D)etC⇔Dpour(C∧D)∨(¬C∧ ¬D). De même, lorsquen∈N>0suit clairement du contexte, nous écrironsx plutôt quex₁, . . . , x_n.

Étant donné , nous allons construire les circuits et pour tout

positioni dans la somme dex ety en binaire petit-boutiste. Pour touti∈[[1, n]], on pose

Ai(x, y) =

(Ri−1(x, y)⊕x_i⊕y_i si i≥2

x1⊕y1 sinon

et

Ri(x, y) = (Wi

j=1 x_j∧y_j∧Vi

k=j+1(x_k∨y_k) si i≥2 x1∧y1

. Pour décider ADD, on utilise ensuite le circuit

ADD(x, y, z) = ^ⁿ

i=1

A_i(x, y)⇔z_i

∧ R_n(x, y)⇔z_n+1

pour toutn∈N>0.

Exercice 4.Montrer que le langage

MULT={abc∈ {0,1}^∗ |2|a|= 2|b|=|c|,a·b=cavec a, b, c en binaire petit-boutiste} est dans AC¹.

Solution 4.Faire le produit de deux nombres de nbits revient à faire la somme dennombres de 2n bits, ce que nous allons faire ici.

Étant donné n ∈ N>0, pour faire la somme de n nombres de 2n bits donnés par les variables x⁽¹⁾, . . . , x⁽ⁿ⁾, nous allons réutiliser les circuits A_i(x, y)pour tout i∈[[1,2n]] de la solution à l’exercice précédent et construire par récurrence surn, pour touti∈[[1,2n]], le circuitCi(x⁽¹⁾, . . . , x⁽ⁿ⁾)donnant le bit en position i dans la somme de x⁽¹⁾, . . . , x⁽ⁿ⁾ en binaire petit-boutiste. Pour tous n ∈ N>0 et i∈[[1,2n]], on pose

C_i(x⁽¹⁾, . . . , x⁽ⁿ⁾) = (

Ai C(x⁽¹⁾, . . . , x^(dn/2e)), C(x^(dn/2e+1), . . . , x⁽ⁿ⁾)

si n≥2

x⁽¹⁾_i sinon .

Maintenant, étant donné n∈N>0, pour calculer le produit de deux nombres de nbits donnés par les variablesx, y, on effectue la somme desnnombres de2nbits donnés parB⁽¹⁾(x, y), . . . , B⁽ⁿ⁾(x, y), tels que

B_j⁽ⁱ⁾(x, y) =

(x_j∧y_i si i≤j ≤n+i−1

⊥ sinon

pour tousi∈[[1, n]]etj ∈[[1,2n]]. Pour décider MULT, on utilise ensuite le circuit MULT(x1, . . . , x_n, y₁, . . . , y_n, z₁, . . . , z_2n) =

2n

^

i=1

C_i B⁽¹⁾(x, y), . . . , B⁽ⁿ⁾(x, y)

⇔z_i

pour toutn∈N>0.

Exercice 5.Montrer que tout langage rationnel sur {0,1}est dans AC¹.

Solution 5.Soit A= (Q,{0,1}, δ, q₀, F) un AFD reconnaissant le langage considéré L⊆ {0,1}^∗. On construit des circuits Rq,p(x1, . . . , xn) pour tous n ∈ N et q, p ∈ N par récurrence sur n, indiquant si, oui ou non, on va de l’état q à l’état p dans A avec le mot correspondant à x₁, . . . , x_n. Pour tousq, p∈Q, on pose

ainsi que

Rq,p(x1) =















> si δ(q,0) =δ(q,1) =p

¬x₁ si δ(q,0) =pmais δ(q,1)6=p x1 si δ(q,1) =pmais δ(q,0)6=p

⊥ sinon

.

Ensuite, pour toutn∈N, n≥2et tous q, p∈Q, on pose Rq,p(x1, . . . , xn) = _

r∈Q

Rq,r(x1, . . . , xdn/2e)∧Rq,r(xdn/2e+1, . . . , xn) .

Pour décider L, on utilise ensuite le circuit L(x₁, . . . , x_n) = _

q∈F

R_q0,q(x₁, . . . , x_n)

pour toutn∈N.

2 Classe NC

On note NCⁱ la classe des langages sur{0,1} décidés par une famille de circuits booléens(C_n)n∈N

dont la taille est polynomiale et dont la profondeur est en O(log(n)ⁱ), mais où l’arité des portes∨et

∧est limitée à 2.

Exercice 6.Montrer que pour tout i∈N, on a l’inclusion NCⁱ⊆ACⁱ⊆NCⁱ⁺¹. Solution 6.Clairement, par définition, on a NCⁱ⊆ACⁱ pour touti∈N.

Maintenant, étant donné un circuit booléen correspondant à une famille pour ACⁱ avec i∈N, on remarque que chaque porte∧ou∨a une arité bornée par la taille du circuit qui est polynomiale en la taille d’entrée. En remplaçant chacune de ces portes par un arbre binaire équilibré des mêmes portes on obtient le résultat.

Exercice 7.Montrer que NC⁰6=AC⁰.

Solution 7.Un circuit booléen dont la profondeur estdmais où l’arité des portes∨ et∧est limitée à 2utilise au plus 2^d variables parmi toutes celles possibles.

Il s’ensuit que tout langage L de NC⁰ a la propriété qu’il existe c ∈ N vérifiant que pour tout n∈N, il existe au plusc positions de1 àn telles que l’appartenance d’un mot àL∩ {0,1}ⁿ dépende uniquement des bits à ces positions. Il vient donc en particulier que ADD∈/NC⁰.

3 Classe TC

La classe TC⁰ correspond à la classe des langages sur {0,1} décidés par une famille de circuits booléens dont la taille est polynomiale et dont la profondeur est en O(1), où les portes sont ¬ ainsi que des portes de seuil Tk d’arité non bornée pour k∈N quelconque, telles que pour toutn∈N, on ait que Tk(x₁, . . . , x_n) s’évalue à>quand kde ses entrées au moins s’évaluent à >.

Exercice 8.Montrer que tout circuit avec des portes ¬ ainsi que ∧, ∨ et MAJ d’arité non bornée, telles que pour toutn∈N, on ait que MAJ(x1, . . . , xn) s’évalue à>quand la moitié de ses entrées au moins (c’est-à-dire au moins dn/2e de celles-ci) s’évaluent à >, se réécrit comme un circuit de même taille et profondeur avec des portes¬ et T_k pour k∈Nquelconque décidant le même langage.

Solution 8.Pour toutn∈N, on a

∧(x₁, . . . , x_n)≡T_n(x₁, . . . , x_n)

∨(x₁, . . . , x_n)≡T1(x₁, . . . , x_n) MAJ(x1, . . . , xn)≡T_dn/2e(x1, . . . , xn) .

Exercice 9.Montrer qu’à l’inverse,TC⁰se définit aussi comme la classe des langages sur{0,1}décidés par une famille de circuits booléens dont la taille est polynomiale et dont la profondeur est en O(1), où les portes sont¬ ainsi que∧,∨ et MAJ d’arité non bornée.

Solution 9.Pour tousn, k∈N, on a

Tk(x1, . . . , xn)≡











MAJ(x1, . . . , xn,>, . . . ,>

| {z }

n−2k

) sik≤ ⁿ₂ MAJ(x1, . . . , xn,⊥, . . . ,⊥

| {z }

2k−n

) sinon . Notons que les portes ∨ et∧sont donc inutiles.

Exercice 10. Montrer queTC⁰⊆NC¹.

Solution 10. Pour tous n, i ∈ N>0, on construit des circuits B_i(x₁, . . . , x_n) et R_i(x₁, . . . , x_n) qui donnent, respectivement, le bit de poidsidans la représentation binaire du nombre de variables parmi x₁, . . . , x_n à >et l’éventuelle retenue obtenue suite à l’addition au poids idans la somme du nombre de variables parmi x₁, . . . , x_dn/2e à>et du nombre de variables parmi x_dn/2e+1, . . . , x_n à>. D’abord, pour touti∈N, on poseBi(ε) =Ri(ε) =⊥ainsi que

Bi(x1) =

(x₁ sii= 0

⊥ sinon etRi(x1) =⊥. Ensuite, pour tous i∈Net n∈N, n≥2, on pose

B_i(x₁, . . . , x_n) =

(Ri−1(x1, . . . , xn)⊕Bi(x1, . . . , xdn/2e)⊕Bi(xdn/2e+1, . . . , xn) sii≥1 B₀(x₁, . . . , x_dn/2e)⊕B₀(x_dn/2e+1, . . . , x_n) sinon et

Ri(x1, . . . , xn) =











Bi(x1, . . . , xdn/2e)∧Bi(xdn/2e+1, . . . , xn)

∨

Ri−1(x1, . . . , xn)∧ Bi(x1, . . . , x_dn/2e)∨Bi(x_dn/2e+1, . . . , xn) sii≥1 B0(x1, . . . , xdn/2e)∧B0(xdn/2e+1, . . . , xn) sinon

.

On peut montrer qu’il existe un entierα∈Ntel que pour tousn∈N>0 eti∈N, la profondeur de B_i(x₁, . . . , x_n)etR_i(x₁, . . . , x_n)soit majorée parα·(dlog₂(n)e+i). À noter que la même construction peut-être généralisée pour additionner m nombres de n bits avec des circuits de taille polynomiale, profondeur logarithmique et portes ∨ et∧ d’arité au plus 2(sachant qu’ici on additionne nnombres de 1bit).

Par conséquent, étant donné n, k∈N, on simule Tk(x1, . . . , xn) par> sik= 0, par⊥si k > net sinon, sibl−1· · ·b0 ∈ {0,1}^l avecl=dlog₂(n+ 1)eest la représentation binaire gros-boutiste dek, par

_

i∈[[0,l−1]],b_i=0

^

j∈[[i+1,l−1]],b_j=1

B_j(x₁, . . . , x_n)∧ ^

j∈[[i+1,l−1]],b_j=0

¬B_j(x₁, . . . , x_n)∧B_i(x₁, . . . , x_n)

∨

^

Bj(x1, . . . , xn)∧ ^

¬B_j(x1, . . . , xn) .

Exercice 11. Montrer que PARITY∈TC⁰.

Solution 11. On construit des circuits ⊕(x₁, . . . , xn) décidant PARITY∩ {0,1}ⁿ pour tout n ∈ N, tels que

⊕(x₁, . . . , xn) =

_n−1

2

_

i=0

T2i+1(x1, . . . , xn)∧ ¬T2i+2(x1, . . . , xn) .

Exercice 12. Montrer que MULT∈TC⁰.

Solution 12. Pour simplifier la présentation de cette solution, nous allons procéder de façon modu- laire.

Passage de la multiplication de deux nombres à l’addition de n nombres On ramène facilement le problème de la multiplication de deux nombres de taillen à l’addition dennombres de taille 2ncar (a×b) =P

1≤j≤n

P

1≤k≤n2^k+j(a_j ∧b_k).

Passage de l’addition demnombres de taillesnà l’addition en parrallèle deln(m)nombres de taille2ln(m). Notonsa¹, . . . , a^mles nombres à additionner etrⁱ=P

ja^j_i. Commerⁱest la somme de m nombres valant 0 ou 1, rⁱ ≤ m et donc rⁱ tient sur ln(m) bits. On veut calculer le bit r_jⁱ en profondeur constante. Notons pour celabit(k, j) qui vaut 1 si la représentation binaire de k contient un 1en j-ème position on a :

rⁱ_j = _

1≤k≤n bit(k,j)=1

Tk(a¹_i, . . . , a^m_i )

On a par ailleurs queP

ka^k=P

i2ⁱrⁱ avec :

a¹₁ · · · a¹_n

... ... ...

a^m₁ · · · a^m_n r1=P

ka^k₁ · · · rn=P

ka^k_n

Comme chacun des rⁱ tient sur ln(m)bits, on va regrouper les rⁱ en bloc de tailleB =ln(m)bits en calculant

v^` = X

1≤k≤ln(m)

2^kr^k+`

et donc on a toujours :

X

k

a^k =X

i

2ⁱrⁱ =X

`

v^{`</sup>2<sup>B`}

Nous allons montrer ensuite comment faire le calcul de v^{`</sup> en profondeur constante et taille poly- nomiale. Montrons d’abord comment s’en sortir si l’on sait calculer les v<sup>`}.

Une fois que les v^` sont calculés on calcule x = P

`2<sup>3B`</sup>v^3` et y = P

`2<sup>B(3`+1)</sup>v^3`+1 et z = P

`2<sup>B(3`+2)</sup>v^{2`+2</sup>. Chacun des v<sup>`} tient sur 2ln(m) bits on a que les sommes plus hauts peuvent être transformées en OU bit à bit car les représentations binaires de ces nombres sont disjointes (entre 2^{B`</sup>v<sup>`} et2^{B(`+3)</sup>v<sup>`+3} il n’y a pas de bits en commun car v^` ≤2^2B).

Enfin la dernière étape est de faire la somme x+y+z mais cela peut être fait en profondeur constante puisque la somme est dans AC⁰ ⊆TC⁰.

Calcul desv^{`</sup> en profondeur constante Ce que l’on a envie de faire pour calculerv<sup>`}c’est d’utiliser sa table de vérité. Le problème c’est que chaque bit dev^` dépend de ln(m)×ln(m) bits desrⁱ. Donc la table de vérité peut être exponentielle enln(m)×ln(m) ce qui est plus que polynomial en m.

Le calcul d’un v^{`</sup> correspond donc à faire la somme deln(m) nombres de taille2ln(m). En itérant une seule fois le processus qui nous a permis de passer d’une somme de a<sup>k</sup> à une somme de v<sup>`}, on se ramène à écrire v^` = P

2^B0jw^k. Où les w^k sont de taille logarithmique en la taille v^` et donc

|w^k| ≤2ln(ln(m)²)≤4ln(ln(m))

Maintenant les w^k sont de taille très petite par rapport à n et donc le calcul de chaque w^k peut se faire en profondeur constante en utilisant sa table de vérité (comme à la question 2). Passer par la table de vérité produit bien un circuit de profondeur constante mais de taille exponentielle. Cependant cette taille est exponentielle en le nombre de bits dont dépendw^k qui ici est 4ln(ln(m))×ln(ln(m)) et donc sub-linéaire en m. Notez qu’il y a un nombre polynomial de w^k car il y a ln(m)/ln(ln(m)) parv^{`</sup> et qu’il y a m/ln(m) v<sup>`} para^k.

Une fois que les w^k sont calculés on passe des w^k aux v^{`</sup> comme nous sommes passés des v<sup>`} aux a^k en en sommant un tous les trois, ce qui nous donne des nombres x⁰,y⁰ etz⁰ et l’on fait la somme x⁰+y⁰+z⁰.