Polynomial-Time
Under-Approximation
Of Winning Regions
In Parity Games
Adam Antonik
Nathaniel Charlton
Michael Huth
imperial.ac.uk/quads
Page 1
© Imperial College London
Motivation
• Program analysis: all interesting problems
undecidable
• Program analyses abstract to gain decidability or
even scalability
• Parity game: decision problem of who wins a
node (player 0 or player 1) is in UP  coUP
• Proposal: use abstract analyses to gain
polynomial-time decisions of who wins nodes
• Tradeoff: not all nodes’ winning status may be
decided
Page 2
© Imperial College London
Parity game:
[Kuesters 2002]
• player who owns node may move forward along one edge
e.g. player 1 may move from v3 to v0
• play = sequence of such moves, beginning at any node
• finite play = reaches deadend, lost by player who owns deadend
• infinite plays: player 0 wins iff maximum of
label numbers (inside nodes) that occur in play infinitely often is even
• example: v7v0v7v0… won by player 1 as only 0 and 1 occur infinitely often
Page 3
© Imperial College London
Parity games are determined
[Emerson & Jutla 1991]
• Memoryless strategy for player 0: choice of at
most one outgoing edge for each node player 0
owns
(similar definition for player 1)
• Player 0 wins node v iff player 0 has memoryless
strategy for which he wins all plays beginning at
node v
(similar definition for player 1)
• Determinacy holds: every node v in a parity
game is won by exactly one player,
player 0 or player 1
Page 4
© Imperial College London
Example of determinacy [Kuesters 2002]
Win(G,0) = {v4,v5,v6}
Win(G,1) = {v0,v1,v2,v3,v7}
Player 0’s winning memoryless strategy:
at v4 go to v5, at v6 go to v5
Page 5
© Imperial College London
Computational complexity
and our approach
• Decision problem “v in Win(G,0)?” in UP  coUP
(unambiguous non-deterministic polynomial-time
Turing machines)
• Algorithms that compute Win(G,0) either have
exponential worst-case input G, or their precise
complexity is unknown
• Our approach: propose design pattern for
PTIME algorithms that under-approximate
Win(G,0) and Win(G,1) through static analyses
Page 6
© Imperial College London
Wlog: Elimination of deadends and selfloops
G below turns into
G’ on right; winning regions
preserved; Wlog: no deadends,
no selfloops
Page 7
© Imperial College London
Wlog: Lax parity games
•
•
•
•
new label X = “doesn’t matter”
turn G above into G’ or G’’ below
no change of winning regions
no cycles with X labels only
Page 8
© Imperial College London
Attractors
// Wlog: no deadends
• Attractors: Attr0(G,Z) = set of nodes for which
player 0 has winning strategy to reach set Z
(Attr1(G,Z) similarly defined for player 1)
• Z  Attr0(G,Z)  Attr1(G,Z)
• Attr0(G,Z) = least set Y that contains Z and:
- node v owned by 0 is in Y if there is an edge
from v to some w in Y
- node w owned by 1 is in Y if all edges from w
lead to nodes in Y
• Y is 0-attractor iff for some Z, Y = Attr0(G,Z)
Page 9
© Imperial College London
Example attractors
• Attr1(G,{})
= {} since there are no
deadends in G
• Attr0(G,{v4,v5}) = {v4,v5,v6}
- e.g. v6 in Attr0(G,{v4,v5})
since player 0 can move from
v6 to v5
- e.g. v7 not in Attr0(G,{v4,v5})
since player 1 can move from
v7 to v0
• Attr0(G,{v4,v5,v6}) = {v4,v5,v6}
is 0-attractor
Page 10
© Imperial College London
Traps and paradises
• W is 0-trap iff player 1 has memoryless
strategy with which he can secure that all
plays beginning in W stay in W
• W is 1-paradise iff W is a 0-trap & player 1
has memoryless strategy with which he
wins all plays beginning in W
• Fact: 0-paradises are closed under unions
and 0-attractors
• Fact: 0-attractor is 1-trap
Page 11
© Imperial College London
Example traps
and paradises
• {v4,v5,v6} is 1-trap in G
• {v4,v5,v6,v7} is not 1-trap in G:
player 1 can move from v7 to v0
• {}, {v5,v6}, and {v4,v5,v6}
are 0-paradises in G
Page 12
© Imperial College London
Sub-games
• Let parity game G have game graph (V,E)
• For U  V let G[U] be game with game
graph (V  U, E  UU) and labels as in V
• G[U] is sub-game of G iff all deadends in
G[U] are deadends in G already
• Fact: If U is 0-trap or 1-trap of G, then G[U]
is sub-game of G: traps induce sub-games
Page 13
© Imperial College London
(Non-)Example
of sub-games
• G[{v4,v5,v6}] sub-game of G: no deadends
• G[{v0,v1}] not sub-game of G:
v1 deadend in G[{v0,v1}] but not in G
Page 14
© Imperial College London
Design pattern for PTIME underapproximation of winning regions
% PRE: G lax with no deadends or selfloops,
rank(G) value of some rank function,
each A#i an “aspect” // some examples later
% POST: W0  Win(G,0), W1  Win(G,1)
W0 = {}; W1 = {};
cache = 0;
while (rank(G) != cache) {
cache = rank(G);
for (i = 1; i = i + 1; i <= k) { A#i; }
}
return (W0,W1);
Page 15
© Imperial College London
Dynamic snapshot of computational state
U
Page 16
© Imperial College London
Rank function sufficient for this talk
• rank(G) = size of U +
sum of all labels in U
(any X interpreted as 0)
• for the game on
the left with U = V:
rank(G) = 8 + 8 = 16
Rank function and aspects are parameters for our design pattern.
Page 17
© Imperial College London
Invariants for design pattern and aspects
(P)
(A)
(L)
(F)
W0 is 0-paradise, W1 is 1-paradise in G
W0 is 0-attractor, W1 is 1-attractor in G
G[U] lax with no selfloops or deadends
Win(G,0) and Win(G,1) won’t change if
G changes state to some G’
“Palf: a young, angry member of the legal
profession; confident of his ability in every field”
Source: urban DICTIONARY
Page 18
© Imperial College London
Important consequence of invariants
From our invariants (PALF) we get:
1. G[U] is sub-game of G
2. Win(G,0)  U = Win(G[U],0)
3. For all Z in U:
Attr0(G, W0  Z) = W0  Attr0(G[U],Z)
1.-3. guarantee aspects can operate on residual
game G[U] only and ignore W0 and W1:
incremental computation possible
Page 19
© Imperial College London
Requirements for aspects A#i
• Should run in polynomial time
• May abstract away the role of players (i.e.
alternation) to change/simplify labels
• May abstract, soundly for wins of one
player, sets of label values into a single
label value
• May be deterministic or contain nondeterministic choices (resolved in
implementations)
Page 20
© Imperial College London
Aspect A1
For each node v in U with label l not in
{0,1,X}:
if there is no cycle in G[U] through v
containing some w with label l - 1
then re-set label l at node v to l - 2
Ignores alternation but exploits
redundancies, namely local or global
“gaps”, in label structure.
Page 21
© Imperial College London
Example for
Aspect A1
• v1 only node with
label (3) larger than 1
• no label 2 in graph (a global “gap”) so
reset label 3 to 1, reduces index (i.e.
maximal label value - 1) of the game
Page 22
© Imperial College London
Non-example for
Aspect 1
• v5 and v4 only candidates for Aspect 1
• v5v6v5… cycle through v5 with label 1 on it
• v4v3v4… cycle through v4 with label 1 on it
• so Aspect 1 has no effect on this state of G
Page 23
© Imperial College London
Aspect 2
For each v in U with label l != X:
if all cycles C through v in G[U] have
some node w with label n such that
l <= n != X
then reset label at v from l to X
Ignores alternation but exploits nondeterministic redundancies, namely local
“dominance”, in label structure
Page 24
© Imperial College London
Example for
Aspect 2
• All cycles through v3 have
some nodes whose label
dominates that of v3, which is 0
• So we can reset that label to X:
Page 25
© Imperial College London
Example for
Aspect 2 cont’d
• v0’s label can’t change as it
dominates all others
• Both v1 and v2 satisfy criterion of
Aspect 2
• But we can only reset one of their labels
since otherwise there are cycles with only X labels:
XOR
Page 26
© Imperial College London
Aspect 3
• Aspects 1 and 2 don’t increase W0 or W1, that’s
the job of Aspect 3 and similar aspects
• Aspect 3 abstracts game G[U] into
2 * n/2 parity games checkInfFin(I,F,s) of
index 3, where player s has winning condition
(Street acceptance condition with one pair only)
“meet set I infinitely often and F only finitely often”
• Only one winning region of each of these games
is paradise for G[U]: under-approximation at work
• Choice of index 3 is arbitrary (more on this later)
Page 27
© Imperial College London
Aspect 3
pseudo-code
n := max { label(v) | v in U };
s := n mod 2;
for (k = 0; k = k + 1; 2*k <= n) {
Zs = checkInfFin({n,n-2,...,n-2*k},
{n-1,n-3,...,n-2*k+1}, s);
Ws := Ws  Attrs(G[U], Zs );
Z1-s = checkInfFin({n-1,n-3,...,n-2*k-1},
{n,n-2,...,n-2*k}, 1-s);
W1-s := W1-s  Attr1-s(G[U], Z1-s );
}
Page 28
© Imperial College London
Example
for Aspect 3
• n = 2, s = 0, U = V
• checkInfFin({2}, {}, 0):
decides v4,v5,v6 in
Win(G[U], 0)
• checkInfFin({1}, {2}, 1)
decides v0,v1,v2,v3,v7
in Win(G[U], 1)
• Game solved
Page 29
© Imperial College London
Non-example
for Aspect 3
• Aspect 3 won’t decide
any nodes here
• Aspect 2 ; Aspect 3
solves the game:
- Aspect 2 re-sets label
at v2 to X
- Then checkInfFin({3,1}, {2}, 1)
decides player 1 wins all nodes
Aspects interact
Page 30
© Imperial College London
Worst-case input for existing algorithm
• Worst-case input game for small-progress measure
algorithm of [Jurdzinski 2000], input given in loc. cit.
• Aspect 3 solves this game completely
Page 31
© Imperial College London
Higher-order transformation
A  probe(A)
• Let A be any instantiation of our design
pattern with k > 1 aspects and suitable
rank function.
• probe(A) yields new PTIME underapproximation that uses A as underapproximating oracle
• probe(A) may use oracle A in various ways
• probe may be applied to A repeatedly
Page 32
© Imperial College London
probe(A):
Its “Proof by contradiction” component
• Let node v in U be owned by player 0.
• Assume that player 1 wins node v.
• Let G[U,w] be G[U] except that (v,w) is only edge
out of v (where (v,w) was edge in G already)
• By assumption: G[U,w] and G[U,w’] have same
winning regions for all such w != w’
• Use under-approximating oracle A to detect
differences in such winning regions for either
player
• If difference detected: player 0 wins v
• If nothing detected: nothing inferred
Page 33
© Imperial College London
probe(A):
Its “Proof by invariance” component
• Let v be any node in U.
• For each edge (v,w):
compute under-approximation of
Win(G[U,w],0) with oracle A
• If any node z is in this underapproximation
for all edges (v,w) in G
then z in Win(G[U],0)
(Ditto for player 1.)
Page 34
© Imperial College London
Higher-order transformation
using call-by-need
n = 0;
while (rank(G) != 0) {
cache = rank(G);
probe(A,n);
if (cache != rank(G)) { n = 0; } else { n = n + 1; }
}
where probe(A, 0) = A,
probe(A, n + 1) = probe(probe(A,n)), and
A any instantiation of our design pattern
for k > 1 aspects and suitable rank function
Page 35
© Imperial College London
Related work
[M. Lange 2005] Solving Parity Games by a
Reduction to SAT. In Proc. Of Workshop
on Games in Design and Verification,
GDV’05, Edinburgh, Scotland, UK, 2005.
[M. Jurdzinski 1998] Deciding the winner in
parity games is in UP  coUP. Information
Processing Letters 68(3):119-124.
[M. Jurdzinski 2000] Small progress
measures for solving parity games. In
Proc. of 17th STACS, LNCS 1770, pp.290301, Springer 2000.
Page 36
© Imperial College London
Conclusions
• Proposed design pattern for algorithms
that under-approximate winning regions of
parity games in PTIME
• Pattern instantiated with rank function and
k > 1 aspects
• Aspects interact to improve precision onthe-fly
• Invariants of design pattern allow for
incremental computation on residual parity
game
Page 37
© Imperial College London
Future work
• Connections to descriptive complexity
measures, e.g. DAG-width [Berwanger,
Dawar, Hunter, and Kreutzer 2006] and
Entanglement [Berwanger and Graedel
2005]
• Abstractions of existing exponential-time
algorithms: can they satisfy our invariants?
• Implementation (nearly completed) and
validation of our approach
Page 38
© Imperial College London
Page 39
© Imperial College London