Complexité computationnelle dans un univers interactif

Complexité computationnelle
dans un univers interactif
Simone Martini
Dipartimento di Scienze dell’Informazione
Alma mater studiorum • Università di Bologna
and
EPI Focus • INRIA Sophia / Bologne
Rencontre LIGC, Paris
20 novembre 2010
1 / 45
Outline
1
In limine : informatique et langage
2
Complexité computationnelle implicite
3
Interaction et processus
4
Un exercice : processus soft
2 / 45
Informatique et langage
Avons nous une épistémologie de l’informatique ?
Je ne sais pas, comme un corpus bien defini et structuré
mais je sais que. . .
l’informatique joue toutes ses cartes
sur l’aspect linguistique des ses concepts.
3 / 45
Informatique et langage
Avons nous une épistémologie de l’informatique ?
Je ne sais pas, comme un corpus bien defini et structuré
mais je sais que. . .
l’informatique joue toutes ses cartes
sur l’aspect linguistique des ses concepts.
4 / 45
Quelques concepts
information
effectif (computation, procédure, processus, . . . )
feasible
hiérarchie d’abstraction
interaction
...
tous ils vont main dans la main avec la manière de leur
exprimer dans un language artificiel
5 / 45
Forme est substance
En informatique, la façon d’exprimer un concept
un algorithme, un protocol, une architecture logiciel, . . .
est co-essentiel au concept exprimé.
L’essence intrinsèque de la discipline reste dans l’immatériel
de l’expression linguistique du calcul et de l’interation.
Et, bien sur, il n’y pas des traductions (complètement ?)
fidèles entre une expression et l’autre. . .
[cfr. e.g. George Steiner, After Babel,19982 ]
6 / 45
Une histoire de success. . .
Les languages de programmation (sequentielle) modernes
Contribution significative au problem solving
Outils pour la division d’un problem en sous-problemes
Et pour mettre ensemble leur solutions
Abstraction mechanisms
7 / 45
Et une histoire de succès partial
Complexité algorithmique
8 / 45
Complexité Computationnelle Standard
On fixe un modèle de machine et un coût pour lui.
Pour un program P agissant sur les data dans D, la
complexité (time complexity) de P est une fonction
TP : N → N
pour chaque d ∈ D, le temps necéssaire pour calculer P(d)
est moins de TP (|d|).
Les modèles de machine raisonnables sont tous polytime
related entre leur.
9 / 45
La machine de Turing
A finite alphabet and a finite set of states
10 / 45
. . . et des classes de complexité
Ptime : pbs solvable in polynomial time
FPtime : functions computable in polynomial time
NPtime : pbs whose solution is checkable in polynomial time
Exptime : pbs solvable in exponential time
ElemTime : pbs solvable in Kalmar-elementary time
FElemTime : fncs computable in Kalmar-elementary time
LogSpace : pbs solvable in logaritmic (work) space
PSpace : pbs solvable in polynomial (work) space
11 / 45
Complexité Computationnelle Implicite
Une investigation de la notion de calcul feasible avec des
outils logiques et machine-free
La feasibility est étudiée avec des restrictions sur le langage,
pas avec des bornes externes
La structure logique est emportée dans le language
12 / 45
Duplication dans le λ-calcul
(λx.H[x])G → H[G ]
✬
✩
r
v = r
@
w
u
H
λ
G↓u
v
...
z1
zn
✫
v
z1
zn
{
ok
...
v
ok
→β
...
H
o1
...
o1
k times G↓v
x
Figure 2.3: The graphical β-rule
✪
Dans le langage du λ-calcul il n’y a pas la description de la
substitution
From an implementing point of view this obviously requires to reconstruct
thevive
needed
subtree
before a graphical β-contraction. But subtrees enjoy a local
Elle
dans
le metalangage
definition, i.e., such reconstruction does not require to explore the whole λ-tree
Mais
sansthe
langage,
il n’y a pas
la côntroler
! (with
but only
part to substitute,
and des
thus outils
can be pour
performed
in linear time
respect to its size).
13 / 45
Duplication dans le λ-calcul
(λx.H[x])G → H[G ]
✬
✩
r
v = r
@
w
u
H
λ
G↓u
v
...
z1
zn
✫
v
z1
zn
{
ok
...
v
ok
→β
...
H
o1
...
o1
k times G↓v
x
Figure 2.3: The graphical β-rule
✪
Dans le langage du λ-calcul il n’y a pas la description de la
substitution
From an implementing point of view this obviously requires to reconstruct
thevive
needed
subtree
before a graphical β-contraction. But subtrees enjoy a local
Elle
dans
le metalangage
definition, i.e., such reconstruction does not require to explore the whole λ-tree
Mais
sansthe
langage,
il n’y a pas
la côntroler
! (with
but only
part to substitute,
and des
thus outils
can be pour
performed
in linear time
respect to its size).
14 / 45
Raffiner pour limiter
C’est la grande leçon de :
la Logique Lineaire : Raffiner
La substitution est decomposée en duplication et propagation
le Logiques Legères (LLL, & Co.) : Limiter
On limite l’application de la duplication
Beaucoup des résultats dans le milieu sequentiel
15 / 45
De la logique au language
Si on est interessé au propriétés computationnelles
On n’a pas toujour besoin de rester dans la logique
On peut extraire les conditions combinatoires qui donnent les
bonnes proprietés algoritmiques
Et l’appliquer dans un langage non typé (i.e., sans logique)
16 / 45
Du λ-calcul au soft λ-calcul
Lambda calculus Λ :
M ::= x | λx.M | MM
Linear Lambda Calculus Λ!
M ::= x | λx.M | λ!x.M | MM | !M
where x appears linearly in the body of λx.M.
(λ!x.M)!N → M[N/x]
Soft Lambda Calculus ΛS
I
I
M ::= x | λx.M | λ!x.M | MM | !M
x appears once in M, inside a single occurrence of !...
... or x appears more than once in M, outside !.
17 / 45
Du λ-calcul au soft λ-calcul
Lambda calculus Λ :
M ::= x | λx.M | MM
Linear Lambda Calculus Λ!
M ::= x | λx.M | λ!x.M | MM | !M
where x appears linearly in the body of λx.M.
(λ!x.M)!N → M[N/x]
Soft Lambda Calculus ΛS
I
I
M ::= x | λx.M | λ!x.M | MM | !M
x appears once in M, inside a single occurrence of !...
... or x appears more than once in M, outside !.
18 / 45
Du λ-calcul au soft λ-calcul
Lambda calculus Λ :
M ::= x | λx.M | MM
Linear Lambda Calculus Λ!
M ::= x | λx.M | λ!x.M | MM | !M
where x appears linearly in the body of λx.M.
(λ!x.M)!N → M[N/x]
Soft Lambda Calculus ΛS
I
I
M ::= x | λx.M | λ!x.M | MM | !M
x appears once in M, inside a single occurrence of !...
... or x appears more than once in M, outside !.
19 / 45
Raffiner pour limiter
Λ =⇒ Λ! : c’est raffiner.
I
Λ est plongé dans Λ!
{x} = x
{λx.M} = λ!x.{M}
{MN} = {M}!{N}
Λ! =⇒ ΛS : c’est limiter.
I
Si on fait des copies d’un term, c’est l’unique fois qui l’on peut
faire.
I
λ!x.yxx
λ!x.y !x
λ!x.y (!x)x
I
F
F
X
X
Polytime soundness
Polytime completeness
20 / 45
Et dans un milieu interactif,
ou la computation est toujour infinie ?
21 / 45
La Machine de Turing persistante
Un model de computation interactive
Une Machine de Turing avec
un ruban d’input
un ruban d’output
un ruban de travaille persistant,
preservé entre deux computations
des autres rubans de travaille
A PTM M définit une fonction f : I × W → O × W
Le ruban de travaille permet un ensemble infini des états.
[D. Goldin, P. Wegner ; from 1999]
22 / 45
Computations des PTMs
Chaque “run” individuel est une computation d’une TM
conventionelle
Une computation d’une PTM sur l’input i0 i1 i2 · · · est une
serie (infinite) de runs individuels
fM : (i0 , ) → (o1 , w1 )
(i1 , w1 ) → (o2 , w2 )
(i2 , w2 ) → (o3 , w3 )
..
.
qui produit l’output o0 o1 o2 · · ·
Quelle notion de temp du calcul ?
23 / 45
Complexité pour les PTMs ?
Une computation est infinie par définition...
La taille de l’input est (le moin important) des ingredients
Taille du ruban de travaille,
qui depends de toute l’histoire d’interaction. . .
Je ne connais pas un traitement complèt (ou satisfaisant) de
la complexité des PTMs
24 / 45
Autres formalisations / inspirations. . .
Online algorithms.
Behavioral computation theory et Abstract State Machines
[Gurevich2005].
Timed process algebras.
Mais :
Ils sont tous aux niveaux en bas de la hiérarchie d’abstraction
Ou sont les langage des programmations ?
Peut-on faire de la complexité implicite ?
25 / 45
Un exercice
Complexité computationnelle implicite
pour un calcul des processus
[Avec Ugo Dal Lago and Davide Sangiorgi]
26 / 45
Calculs des processus
Le processus vide : 0, il est stoppé.
a
Actions élemèntaires : a.P → P
P fait l’action visible a et devient P
Parallel : P || Q
associative, commutative
les deux processus P et Q cohexistent et ils peuvent communiquer
Actions complémentaire : pour chaque action a on a aussi
l’action a
τ
Communication : a.P || a.Q → P || Q
a.P et a.Q se synchronisent ; l’action invisible τ
27 / 45
Complexité pour des processus ?
Entre deux actions visibles, on veut qu’il y a
un numéro fini d’action invisibles.
Il y a des systèmes des types pour ça
[Sangiorgi2006, DengSangiorgi2006]
.
Des bornes quantitatives sur ce numero d’actions internes ?
Bornés par quoi ?
I
I
Des bornes constants [Kobayashi2003].
Des bornes paramètriques, dans un contèxt
synchrone [AmadioDabrowski2007].
28 / 45
Higher order π-calculus
P ::= 0 | P || P | a(x).P | ahV i.P | (νa)P | {V }(V )
V ::= ? | x | λx.P
Semantique opérationelle
ahV i.P || a(x).Q →P P || Q[x/V ]
P →P Q
P || R →P Q || R
{(λx.P)}(V ) →P P[x/V ]
P →P Q
(νa)P →P (νa)Q
Et une congruence sur le processus, compatible avec la semantique.
29 / 45
La congruence
P ≡ Q if P and Q are α-equivalent;
P || (Q || R) ≡ (P || Q) || R;
P || Q ≡ Q || P;
(νa)((νb)P) ≡ (νb)((νa)P);
((νa)P || Q) ≡ ((νa)P) || Q if a is not free in Q;
P≡Q
Q →P R
P →P S
R≡S
30 / 45
Higher-Order π-Calculus
Non termination :
V = λy .a(x).({x}(?) || ahxi)
Q = {V }(?) || ahV i
On a :
Q → Q → ...
31 / 45
Un serveur
V = λz.a(x).(b(y ).chy i.{x}(?) || ahxi)
Q = {V }(?) || ahV i
P est un serveur qui accepts une demande y sur le canal b et
l’envoie sur c
Après, il peut accepter des autres demandes
32 / 45
Raffiner : LHOπ
Valeurs et Processus :
V ::= ? | x | λx.P | λ!x.P | !V
P ::= 0 | P || P | a(x).P | ah!xi.P | ahV i.P | (νa)P | {V }(V )
où
λx.P
a(x).P
x occurs once in P
at level 0
Examples :
a(x).{x}(?)
ah!xi.({x}(?) || {!x}(?))
ah!xi.ahxi.bhxi.0
ah!xi.(b(y ).chy i.{x}(?) || ah!xi.0)
a(x).{(!x)}(?)
X
X
X
X
33 / 45
Linear Higher-Order π-Calculus : LHOπ
Reduction :
ahV i.P || a(x).Q →L P || Q[x/V ]
ah!V i.P || ah!xi.Q →L P || Q[x/V ]
{(λx.P)}(V ) →L P[x/V ]
P →L Q
P || R →L Q || R
P≡Q
{(λ!x.P)}(!V ) →L P[x/V ]
P →L Q
(νa)P →L (νa)Q
Q →L R
P →L S
R≡S
34 / 45
LHOπ est plongé dans HOπ
[?]V = ?
[λx.P]V = λ!x.[P]P
[0]P = 0
[x]P = x
[P || Q]P = [P]P || [Q]P
[a(x).P]P = ah!xi.[P]P
[ahV i.P]P = ah![V ]V i.[P]P
[(νa)P]P = (νa)[P]P
[{V }(V )]P = {[V ]V }(![V ]V )
Theorem (Simulation)
If P →P Q, then [P]P →L [Q]P
35 / 45
Limiter : SHOπ
Processus lineares avec des autres limitations :
λx.P
a(x).P
λ!x.P
a(!x).P
x occurs once in P
at level 0
x occurs once in P
at level 1
x occurs in P
at level 0
36 / 45
Soft Processes : Examples
a(x).{x}(?)
X
ah!xi.({x}(?) || {(!x)}(?))
ah!xi.ahxi.bhxi.0
X
ah!xi.(b(y ).chy i.x || ah!xi)
37 / 45
Soft Processes : Examples
a(x).{x}(?)
X
ah!xi.({x}(?) || {(!x)}(?))
ah!xi.ahxi.bhxi.0
X
ah!xi.(b(y ).chy i.x || ah!xi)
38 / 45
Soft Processes : Examples
a(x).{x}(?)
X
ah!xi.({x}(?) || {(!x)}(?))
ah!xi.ahxi.bhxi.0
X
ah!xi.(b(y ).chy i.x || ah!xi)
39 / 45
Soft Processes : Examples
a(x).{x}(?)
X
ah!xi.({x}(?) || {(!x)}(?))
ah!xi.ahxi.bhxi.0
X
ah!xi.(b(y ).chy i.x || ah!xi)
40 / 45
Polytime Soundness
Theorem
There is a family of polynomials {pn }n such that for every process
P and for every m, if P →m
L Q, then m, |Q| ≤ pb(P) (|P|).
41 / 45
Completude ?
SHOπ est (tres) limité dans les actions visibles
On peut plonger ΛS dans SHOπ(via CPS translation).
On peut obténir des résultats de completude pour le fonctions
polynomiales
42 / 45
Des examples plus interessants : le serveur
V = λ!z.ah!xi.(b(y ).chy i.{x}(?) || ah!xi)
Q = {V }(?) || ahV i
n’est pas exprimible dans SHOπ.
On peut utilizer un autre operateur 2
λ!z.a(2x).(b(y ).chy i.{x}(?) || ah2xi)
x est deux fois dans P, aux niveaux 0 et 1.
Mais l’occurrence de x au niveau 0 est dans le “scope” d’un
input sur b, et il ne fait pas de output sur ce canal.
Le système reste correcte pour le temps polynomial.
43 / 45
Conclusions
Donner une notion de complexité pour les computations
interactives et/ou concurrentes est un problème ouvert
Utilizer des modèles de bas niveau peut être un mauvais choix
Une example de complexité implicite dans un cadre de
concurrence
Sans chercher une interprétation logique
44 / 45
Completude
We can capture all functions f : N → N as processes
(informally) behaving as :
a(x).bhf (x)i.0.
But we can get something more...
Let F be a class of functions on natural numbers. Then
L (F) is the class of LTSs defined (informally) as follows :
L ::= ahfxi.L | a(x).L | L || M
where f ∈ F and FC (L) ∩ FC (M) ∩ ∅ in L || M.
Example :
a(x).(bh{succ }(x)i || ah{square }(x)i.ah{fact }(x)i)
Indeed :
Theorem
SHOπ is sound and complete for L (FPT IME).
45 / 45