14 research outputs found
A list of parameterized problems in bioinformatics
In this report we present a list of problems that originated in bionformatics. Our aim is to collect information on such problems that have been analyzed from the point of view of Parameterized Complexity. For every problem we give its definition and biological motivation together with known complexity results.Postprint (published version
Algorithms for graphs of small treewidth
Veel problemen uit de praktijk kunnen worden gemodelleerd als optimaliserings- of beslis-singsproblemen
op grafen. Denk bijvoorbeeld aan het probleem waarbij een koerier een
aantal pakketjes moet afleveren op verschillende adressen in het land. De manager van de
koerier wil dat hij een zo kort mogelijke route aflegt die begint en eindigt bij het koeriers-bedrijf,
en die alle adressen aandoet. Het probleem om zo n kortste route te vinden is het
zogenaamde handelsreizigersprobleem. De invoer kan worden gemodelleerd als een graaf,
waarbij elke knoop in de graaf een adres vertegenwoordigt en elke kant tussen twee knopen
de weg tussen de corresponderende adressen. Elke kant heeft een gewicht dat aangeeft hoe
lang de corresponderende weg is. Het probleem is dan om een cykel in de graaf te vinden die
alle knopen bevat en waarvoor de som van de gewichten van alle kanten in de cykel minimaal
is.
Helaas is het zo dat de meeste problemen op grafen die praktische problemen modelleren
lastig zijn in die zin, dat er waarschijnlijk geen effici¨ ente algoritmen zijn die deze problemen
oplossen. Formeel gezegd zijn deze problemen NP-lastig. Het handelsreizigersprobleem is
een voorbeeld hiervan. Een manier om hiermee om te gaan is om te kijken of er in het
probleem uit de praktijk een structuur zit die maakt dat het probleem effici¨ enter is op te
lossen. Het kan bijvoorbeeld zo zijn dat het gegeven probleem in het algemeen lastig is, maar
dat de grafen die in de praktijk voorkomen een dusdanige structuur hebben dat er wel een
effici¨ ent algoritme voor het probleem bestaat.
Een voorbeeld van een prettige graafstructuur is de boomstructuur: het blijkt dat veel
graafproblemen die in het algemeen lastig zijn, een effici¨ ent algoritme hebben wanneer de
graaf een boom is. Helaas is de boomstructuur erg beperkt: er zijn maar weinig praktische
problemen die kunnen worden gemodelleerd als problemen op bomen. In dit proefschrift kij-ken
we daarom naar een generalisatie van deze structuur, en dat is de boomachtige structuur:
we kijken naar grafen met boombreedte hooguit k of padbreedte hooguit k, waarbij k een
positief geheel getal is.
Intu¨itief gezien geeft de boombreedte van een graaf de mate aan waarin de graaf op een
boom lijkt: hoe groter de gelijkenis, hoe kleiner de boombreedte. Met een graaf van boom-breedte
k kan een boom worden geassocieerd waarbij elke knoop van de boom correspondeert
met een deelgraaf van de graaf op een zodanige manier dat
elke knoop en elke kant van de graaf in tenminste een knoop van de boom voorkomt, en
voor elke knoop v in de graaf geldt dat de knopen in de boom die v bevatten een verbonden
deelboom vormen.
Zo n boom bestaande uit deelgrafen wordt een boomdecompositie van de graaf genoemd.
De breedte van de boomdecompositie is het maximaal aantal knopen van de graaf dat in ´ e´ en
233?Samenvatting
knoop van de boomdecompositie voorkomt, min ´ e´ en. De boombreedte van een graaf is de
minimale breedte over alle boomdecomposities van de graaf (een boom heeft boombreedte
´ e´ en). Een paddecompositie van een graaf is een boomdecompositie die de vorm heeft van
een pad. De padbreedte van een graaf is de minimale breedte over alle paddecomposities van
de graaf. Dus de boombreedte van een graaf is altijd ten hoogste gelijk aan z n padbreedte.
Voor veel problemen zoals het handelsreizigersprobleem is er een effici¨ ent algoritme op
grafen met kleine boombreedte. Het blijkt dat er veel praktische graafproblemen zijn waar-voor
de invoergraaf een kleine boombreedte heeft. Bij al deze problemen helpt dit gegeven
bij het vinden van een effici¨ enter algoritme. Deze algoritmen maken meestal gebruik van
een boomdecompositie van de graaf met kleine breedte. Daarom is het nodig om eerst zo n
boomdecompositie van de graaf te vinden. Hiervoor zijn effici¨ ente algoritmen beschikbaar,
zowel sequentieel als parallel.
Helaas is het zo dat veel algoritmen op grafen met een kleine boombreedte alleen in
theorie efficient zijn: de looptijd van de algoritmen is vaak exponentieel in de boombreedte
van de graaf. Dit geldt bijvoorbeeld voor de algoritmen voor het vinden van een boom- of
paddecompositie van breedte hooguit k van een graaf, waarbij k constant is.
Het doel van dit proefschrift is om effici¨ ente sequenti¨ ele en parallelle algoritmen te ont-werpen
voor problemen op grafen met een kleine boom- of padbreedte. Het doel is om
algoritmen te ontwerpen die niet alleen theoretisch effici¨ ent zijn, maar die ook in praktische
toepassingen effici¨ ent kunnen zijn.
Het proefschrift is als volgt georganiseerd. Hoofdstuk 1 geeft een inleiding. In hoofd-stuk
2 worden formele definities van boom- en padbreedte gegeven, en wordt een aantal ei-genschappen
en bekende resultaten over grafen met een kleine boom- en padbreedte gegeven.
Verder worden definities gegeven die worden gebruikt in de rest van het proefschrift.
In hoofdstuk 3 geven we een volledige karakterisatie van grafen met padbreedte twee.
Deze karakterisatie wordt vervolgens gebruikt voor een effici¨ ent sequentieel algoritme dat
beslist of een graaf padbreedte ten hoogste twee heeft en, als dat zo is, een paddecompositie
van minimale breedte vindt. De karakterisatie wordt ook gebruikt in de algoritmen die zijn
beschreven in hoofdstuk 4.
Hoofdstuk 4 gaat over twee problemen welke hun oorsprong vinden in de moleculaire
biologie. In beide problemen bestaat de invoer uit een aantal copie¨ en van een DNA string
welke in fragmenten zijn opgedeeld. Voor elk paar van fragmenten is informatie beschikbaar
over de overlap tussen die twee fragmenten: ´ of we weten dat de fragmenten zeker overlappen,
´ of we weten dat ze zeker niet overlappen, ´ of we weten niets. Met behulp van deze informatie
moet de volledige overlap informatie tussen elk tweetal fragmenten worden berekend, dat wil
zeggen dat voor elk tweetal fragmenten moet worden berekend of ze wel of niet overlappen.
Dit probleem heet k-INTERVALIZING SANDWICH GRAPHS of k-ISG, waarbij k het aantal
copie¨ en is dat is gefragmenteerd. In de tweede variant is ook nog bekend dat alle fragmenten
gelijke lengte hebben. Deze variant heet k-UNIT-INTERVALIZING SANDWICH GRAPHS of k-UISG.
De invoer van beide problemen kan worden gemodelleerd als een graaf. Het blijkt dat
de volledige overlap informatie alleen kan worden berekend wanneer die graaf padbreedte
ten hoogste k heeft, waarbij k weer het aantal copie¨ en is. In Hoofdstuk 4 geven we een
234?Samenvatting
kwadratisch algoritme voor 3-ISG, en we bewijzen dat k-ISG NP-moeilijk is wanneer k 4.
Verder geven we een lineair algoritme voor 3-UISG.
Hoofstukken 5 9 gaan over een speciaal soort algoritmen, namelijk reductie algorit-men.
Een reductie algoritme is een algoritme waarin een reeks reducties wordt uitgevoerd op
de invoergraaf. Het gedrag van de reducties is beschreven in een verzameling van reductie
regels, welke afhangen van het probleem waarvoor het algoritme is. Wanneer de reductie re-gels
aan bepaalde voorwaarden voldoen kan het reductie algoritme lineaire tijd gebruiken (of
logaritmische tijd in het geval van een parallel reductie algoritme). De reductie algoritmen
zijn eenvoudig: de moeilijkheden van het probleem zitten verstopt in de verzameling reductie
regels, en niet in het algoritme.
Er zijn hele klassen van problemen op grafen met begrensde boombreedte waarvoor een
verzameling van reductie regels kan worden geconstrueerd. Het voordeel van reductie algo-ritmen
voor het oplossen van problemen op grafen met begrensde boombreedte is dat er geen
boomdecompositie van de graaf nodig is: de algoritmen werken direct op de graaf.
In hoofdstuk 5 geven we een overzicht van de bestaande theorie¨ en over reductie algorit-men.
We combineren verschillende bestaande idee¨ en en presenteren ze als een geheel. Dit
hoofdstuk is tevens een inleiding voor hoofdstukken 6 9.
Reductie algoritmen hebben als nadeel dat ze alleen optimaliserings- en beslissingspro-blemen
kunnen oplossen: bij een optimaliseringsprobleem wordt alleen de optimale waarde
teruggegeven, maar niet een oplossing waarvoor de waarde optimaal is. Bij beslissingspro-blemen
wordt alleen het antwoord ja of nee gegeven, maar als het antwoord ja is wordt
geen oplossing gegeven. In hoofdstuk 6 breiden we de theorie van reductie algoritmen uit
naar constructieve reductie algoritmen welke ook een (optimale) oplossing teruggeven, mits
er een is. We laten zien dat voor veel problemen op grafen met begrensde boombreedte waar-voor
reductie algoritmen kunnen worden toegepast, ook de constructieve reductie algoritmen
kunnen worden toegepast.
In hoofdstuk 7 passen we de theorie¨ en welke zijn gepresenteerd in hoofdstukken 5 en 6
toe op een aantal optimaliseringsproblemen.
In hoofdstukken 8 en 9 gebruiken we de theorie¨ en uit hoofdstuk 6, aangevuld met nieuwe
idee¨ en, om effici¨ ente, constructieve parallelle reductie algoritmen te verkrijgen voor de vol-gende
twee aanverwante problemen:
gegeven een graaf, bepaal of hij series-parallel is, en zo ja, vind dan een sp-boom van
de graaf,
gegeven een graaf, bepaal of hij boombreedte hooguit twee heeft, en zo ja, maak een
boomdecompositie van breedte twee van de graaf.
In hoofdstuk 10 vatten we de resultaten uit dit proefschrift nog eens samen, en geven we
wat richtingen aan voor verder onderzoek.
Appendix A bevat een opsomming van definities van alle graafproblemen welke worden
gebruikt in het proefschrift.
235?Samenvatting
23
Upper and lower bounds for finding connected motifs in vertex-colored graphs
International audienceWe study the problem of finding occurrences of motifs in vertex-colored graphs, where a motif is a multiset of colors, and an occurrence of a motif is a subset of connected vertices whose multiset of colors equals the motif. This problem is a natural graph-theoretic pattern matching variant where we are not interested in the actual structure of the occurrence of the pattern, we only require it to preserve the very basic topological requirement of connectedness. We give two positive results and three negative results that together give an extensive picture of tractable and intractable instances of the problem
Unit Interval Editing is Fixed-Parameter Tractable
Given a graph~ and integers , , and~, the unit interval
editing problem asks whether can be transformed into a unit interval graph
by at most vertex deletions, edge deletions, and edge
additions. We give an algorithm solving this problem in time , where , and denote respectively
the numbers of vertices and edges of . Therefore, it is fixed-parameter
tractable parameterized by the total number of allowed operations.
Our algorithm implies the fixed-parameter tractability of the unit interval
edge deletion problem, for which we also present a more efficient algorithm
running in time . Another result is an -time algorithm for the unit interval vertex deletion problem,
significantly improving the algorithm of van 't Hof and Villanger, which runs
in time .Comment: An extended abstract of this paper has appeared in the proceedings of
ICALP 2015. Update: The proof of Lemma 4.2 has been completely rewritten; an
appendix is provided for a brief overview of related graph classe
On the performance of edge coloring algorithms for cubic graphs
This thesis visits the forefront of algorithmic research on edge coloring of cubic graphs. We select a set of algorithms that are among the asymptotically fastest known today. Each algorithm has exponential time complexity, owing to the NP-completeness of edge coloring, but their space complexities differ greatly. They are implemented in a popular high-level programming language to compare their performance on a set of real instances. We also explore ways to parallelize each of the algorithms and discuss what benefits and detriments those implementations hold
Parameterized Lower Bound and Improved Kernel for Diamond-free Edge Deletion
A diamond is a graph obtained by removing an edge from a complete graph on four vertices. A graph is diamond-free if it does not contain an induced diamond. The Diamond-free Edge Deletion problem asks to find whether there exist at most k edges in the input graph whose deletion results in a diamond-free graph. The problem was proved to be NP-complete and a polynomial kernel of O(k^4) vertices was found by Fellows et. al. (Discrete Optimization, 2011). In this paper, we give an improved kernel of O(k^3) vertices for Diamond-free Edge Deletion. We give an alternative proof of the NP-completeness of the problem and observe that it cannot be solved in time 2^{o(k)} * n^{O(1)}, unless the Exponential Time Hypothesis fails
The Turing way to parameterized complexity
We propose a general proof technique based on the Turing machine halting problem that allows us to establish membership results for the classes W[1], W[2], and W[P]. Using this technique, we prove that Perfect Code belongs to W[1], Steiner Tree belongs to W[2], and α-Balanced Separator, Maximal Irredundant Set, and Bounded DFA Intersection belong to W[P]
Characterizing Hardness in Parameterized Complexity
Parameterized complexity theory relaxes the classical notion of tractability and
allows to solve some classically hard problems in a reasonably efficient way. However, many problems of interest remain intractable in the context of parameterized
complexity. A completeness theory to categorize such problems has been developed
based on problems on circuits and Model Checking problems. Although a basic
machine characterization was proposed, it was not explored any further.
We develop a computational view of parameterized complexity theory based on
resource-bounded programs that run on alternating random access machines. We
develop both natural and normalized machine characterizations for the W[t] and
L[t] classes. Based on the new characterizations, we derive the basic completeness results in parameterized complexity theory, from a computational perspective. Unlike the previous cases, our proofs follow the classical approach for showing basic NP-completeness results (Cook's Theorem, in particular). We give new proofs of the Normalization Theorem by showing that (i) the computation of a resource-bounded program on an alternating RAM can be represented by instances of corre-
sponding basic parametric problems, and (ii) the basic parametric problems can be
decided by programs respecting the corresponding resource bounds. Many of the
fundamental results follow as a consequence of our new proof of the Normalization
Theorem. Based on a natural characterization of the W[t] classes, we develop new
structural results establishing relationships among the classes in the W-hierarchy, and the W[t] and L[t] classes.
Nontrivial upper-bound beyond the second level of the W-hierarchy is quite
uncommon. We make use of the ability to implement natural algorithms to show
new upper bounds for several parametric problems. We show that Subset Sum,
Maximal Irredundant Set, and Reachability Distance in Vector Addition Systems (Petri Nets) are in W[3], W[4], and W[5], respectively. In some cases, the new bounds result in new completeness results. We derive new lower bounds based on the normalized programs for the W[t] and L[t] classes.
We show that Longest Common Subsequence, with parameter the number of strings, is hard for L[t], t >= 1, and for W[SAT]. We also show that Precedence Constrained Multiprocessor Scheduling, with parameter the number of processors, is hard for L[t], t >= 1