94 research outputs found
Partitioning A Graph In Alliances And Its Application To Data Clustering
Any reasonably large group of individuals, families, states, and parties exhibits the phenomenon of subgroup formations within the group such that the members of each group have a strong connection or bonding between each other. The reasons of the formation of these subgroups that we call alliances differ in different situations, such as, kinship and friendship (in the case of individuals), common economic interests (for both individuals and states), common political interests, and geographical proximity. This structure of alliances is not only prevalent in social networks, but it is also an important characteristic of similarity networks of natural and unnatural objects. (A similarity network defines the links between two objects based on their similarities). Discovery of such structure in a data set is called clustering or unsupervised learning and the ability to do it automatically is desirable for many applications in the areas of pattern recognition, computer vision, artificial intelligence, behavioral and social sciences, life sciences, earth sciences, medicine, and information theory. In this dissertation, we study a graph theoretical model of alliances where an alliance of the vertices of a graph is a set of vertices in the graph, such that every vertex in the set is adjacent to equal or more vertices inside the set than the vertices outside it. We study the problem of partitioning a graph into alliances and identify classes of graphs that have such a partition. We present results on the relationship between the existence of such a partition and other well known graph parameters, such as connectivity, subgraph structure, and degrees of vertices. We also present results on the computational complexity of finding such a partition. An alliance cover set is a set of vertices in a graph that contains at least one vertex from every alliance of the graph. The complement of an alliance cover set is an alliance free set, that is, a set that does not contain any alliance as a subset. We study the properties of these sets and present tight bounds on their cardinalities. In addition, we also characterize the graphs that can be partitioned into alliance free and alliance cover sets. Finally, we present an approximate algorithm to discover alliances in a given graph. At each step, the algorithm finds a partition of the vertices into two alliances such that the alliances are strongest among all such partitions. The strength of an alliance is defined as a real number p, such that every vertex in the alliance has at least p times more neighbors in the set than its total number of neighbors in the graph). We evaluate the performance of the proposed algorithm on standard data sets
Hypergraph coloring complexes
AbstractThe aim of this paper is to generalize the notion of the coloring complex of a graph to hypergraphs. We present three different interpretations of those complexes–a purely combinatorial one and two geometric ones. It is shown, that most of the properties, which are known to be true for coloring complexes of graphs, break down in this more general setting, e.g., Cohen–Macaulayness and partitionability. Nevertheless, we are able to provide bounds for the f- and h-vectors of those complexes which yield new bounds on chromatic polynomials of hypergraphs. Moreover, though it is proven that the coloring complex of a hypergraph has a wedge decomposition, we provide an example showing that in general this decomposition is not homotopy equivalent to a wedge of spheres. In addition, we can completely characterize those hypergraphs whose coloring complex is connected
Simplicial and Cellular Trees
Much information about a graph can be obtained by studying its spanning
trees. On the other hand, a graph can be regarded as a 1-dimensional cell
complex, raising the question of developing a theory of trees in higher
dimension. As observed first by Bolker, Kalai and Adin, and more recently by
numerous authors, the fundamental topological properties of a tree --- namely
acyclicity and connectedness --- can be generalized to arbitrary dimension as
the vanishing of certain cellular homology groups. This point of view is
consistent with the matroid-theoretic approach to graphs, and yields
higher-dimensional analogues of classical enumerative results including
Cayley's formula and the matrix-tree theorem. A subtlety of the
higher-dimensional case is that enumeration must account for the possibility of
torsion homology in trees, which is always trivial for graphs. Cellular trees
are the starting point for further high-dimensional extensions of concepts from
algebraic graph theory including the critical group, cut and flow spaces, and
discrete dynamical systems such as the abelian sandpile model.Comment: 39 pages (including 5-page bibliography); 5 figures. Chapter for
forthcoming IMA volume "Recent Trends in Combinatorics
S-Store: Streaming Meets Transaction Processing
Stream processing addresses the needs of real-time applications. Transaction
processing addresses the coordination and safety of short atomic computations.
Heretofore, these two modes of operation existed in separate, stove-piped
systems. In this work, we attempt to fuse the two computational paradigms in a
single system called S-Store. In this way, S-Store can simultaneously
accommodate OLTP and streaming applications. We present a simple transaction
model for streams that integrates seamlessly with a traditional OLTP system. We
chose to build S-Store as an extension of H-Store, an open-source, in-memory,
distributed OLTP database system. By implementing S-Store in this way, we can
make use of the transaction processing facilities that H-Store already
supports, and we can concentrate on the additional implementation features that
are needed to support streaming. Similar implementations could be done using
other main-memory OLTP platforms. We show that we can actually achieve higher
throughput for streaming workloads in S-Store than an equivalent deployment in
H-Store alone. We also show how this can be achieved within H-Store with the
addition of a modest amount of new functionality. Furthermore, we compare
S-Store to two state-of-the-art streaming systems, Spark Streaming and Storm,
and show how S-Store matches and sometimes exceeds their performance while
providing stronger transactional guarantees
Incrementalizing Lattice-Based Program Analyses in Datalog
Program analyses detect errors in code, but when code changes frequently as in an IDE, repeated re-analysis from-scratch is unnecessary: It leads to poor performance unless we give up on precision and recall. Incremental program analysis promises to deliver fast feedback without giving up on precision or recall by deriving a new analysis result from the previous one. However, Datalog and other existing frameworks for incremental program analysis are limited in expressive power: They only support the powerset lattice as representation of analysis results, whereas many practically relevant analyses require custom lattices and aggregation over lattice values. To this end, we present a novel algorithm called DRedL that supports incremental maintenance of recursive lattice-value aggregation in Datalog. The key insight of DRedL is to dynamically recognize increasing replacements of old lattice values by new ones, which allows us to avoid the expensive deletion of the old value. We integrate DRedL into the analysis framework IncA and use IncA to realize incremental implementations of strong-update points-to analysis and string analysis for Java. As our performance evaluation demonstrates, both analyses react to code changes within milliseconds
An extensive English language bibliography on graph theory and its applications
Bibliography on graph theory and its application
OSS architecture for mixed-criticality systems – a dual view from a software and system engineering perspective
Computer-based automation in industrial appliances led to a growing number of
logically dependent, but physically separated embedded control units per
appliance. Many of those components are safety-critical systems, and require
adherence to safety standards, which is inconsonant with the relentless demand
for features in those appliances. Features lead to a growing amount of control
units per appliance, and to a increasing complexity of the overall software
stack, being unfavourable for safety certifications. Modern CPUs provide means
to revise traditional separation of concerns design primitives: the consolidation
of systems, which yields new engineering challenges that concern the entire
software and system stack.
Multi-core CPUs favour economic consolidation of formerly separated
systems with one efficient single hardware unit. Nonetheless, the system
architecture must provide means to guarantee the freedom from interference
between domains of different criticality. System consolidation demands for
architectural and engineering strategies to fulfil requirements (e.g., real-time
or certifiability criteria) in safety-critical environments.
In parallel, there is an ongoing trend to substitute ordinary proprietary base
platform software components by mature OSS variants for economic and
engineering reasons. There are fundamental differences of processual properties
in development processes of OSS and proprietary software. OSS in
safety-critical systems requires development process assessment techniques to
build an evidence-based fundament for certification efforts that is based upon
empirical software engineering methods.
In this thesis, I will approach from both sides: the software and system
engineering perspective. In the first part of this thesis, I focus on the
assessment of OSS components: I develop software engineering techniques
that allow to quantify characteristics of distributed OSS development
processes. I show that ex-post analyses of software development processes can
be used to serve as a foundation for certification efforts, as it is required
for safety-critical systems.
In the second part of this thesis, I present a system architecture based on
OSS components that allows for consolidation of mixed-criticality systems
on a single platform. Therefore, I exploit virtualisation extensions of modern
CPUs to strictly isolate domains of different criticality. The proposed
architecture shall eradicate any remaining hypervisor activity in order to
preserve real-time capabilities of the hardware by design, while
guaranteeing strict isolation across domains.ComputergestĂĽtzte Automatisierung industrieller Systeme fĂĽhrt zu einer
wachsenden Anzahl an logisch abhängigen, aber physisch voneinander getrennten
Steuergeräten pro System. Viele der Einzelgeräte sind sicherheitskritische
Systeme, welche die Einhaltung von Sicherheitsstandards erfordern, was durch
die unermüdliche Nachfrage an Funktionalitäten erschwert wird. Diese führt zu
einer wachsenden Gesamtzahl an Steuergeräten, einhergehend mit wachsender
Komplexität des gesamten Softwarekorpus, wodurch Zertifizierungsvorhaben
erschwert werden. Moderne Prozessoren stellen Mittel zur VerfĂĽgung, welche es
ermöglichen, das traditionelle >Trennung von Belangen< Designprinzip zu
erneuern: die Systemkonsolidierung. Sie stellt neue ingenieurstechnische
Herausforderungen, die den gesamten Software und Systemstapel betreffen.
Mehrkernprozessoren begünstigen die ökonomische und effiziente Konsolidierung
vormals getrennter Systemen zu einer effizienten Hardwareeinheit. Geeignete
Systemarchitekturen müssen jedoch die Rückwirkungsfreiheit zwischen Domänen
unterschiedlicher Kritikalität sicherstellen. Die Konsolidierung erfordert
architektonische, als auch ingenieurstechnische Strategien um die Anforderungen
(etwa Echtzeit- oder Zertifizierbarkeitskriterien) in sicherheitskritischen
Umgebungen erfüllen zu können.
Zunehmend werden herkömmliche proprietär entwickelte Basisplattformkomponenten
aus ökonomischen und technischen Gründen vermehrt durch ausgereifte OSS
Alternativen ersetzt. Jedoch hindern fundamentale Unterschiede bei prozessualen
Eigenschaften des Entwicklungsprozesses bei OSS den Einsatz in
sicherheitskritischen Systemen. Dieser erfordert Techniken, welche es erlauben
die Entwicklungsprozesse zu bewerten um ein evidenzbasiertes Fundament fĂĽr
Zertifizierungsvorhaben basierend auf empirischen Methoden des Software
Engineerings zur VerfĂĽgung zu stellen.
In dieser Arbeit nähere ich mich von beiden Seiten: der Softwaretechnik, und
der Systemarchitektur. Im ersten Teil befasse ich mich mit der Beurteilung von
OSS Komponenten: Ich entwickle Softwareanalysetechniken, welche es
ermöglichen, prozessuale Charakteristika von verteilten OSS
Entwicklungsvorhaben zu quantifizieren. Ich zeige, dass rĂĽckschauende Analysen
des Entwicklungsprozess als Grundlage fĂĽr Softwarezertifizierungsvorhaben
genutzt werden können.
Im zweiten Teil dieser Arbeit widme ich mich der Systemarchitektur. Ich stelle
eine OSS-basierte Systemarchitektur vor, welche die Konsolidierung von
Systemen gemischter Kritikalität auf einer alleinstehenden Plattform
ermöglicht. Dazu nutze ich Virtualisierungserweiterungen moderner Prozessoren
aus, um die Hardware in strikt voneinander isolierten Rechendomänen unterschiedlicher
Kritikalität unterteilen zu können. Die vorgeschlagene Architektur soll jegliche
Betriebsstörungen des Hypervisors beseitigen, um die Echtzeitfähigkeiten der
Hardware bauartbedingt aufrecht zu erhalten, während strikte Isolierung
zwischen Domänen stets sicher gestellt ist
Generating incremental attribute evaluators
In onze maatschappij wordt tegenwoordig veel met software, dat wil zeggen com-
puterprogramma's, gewerkt. Denk daarbij niet alleen aan tekstverwerkers, maar
ook aan software in geldautomaten, videorecorders en het administratiesysteem
van de scus.
Software moet geschreven worden. Programmeurs schrijven software in zoge-
heten hogere programmeertalen, waarvan Pascal, C, Basic, Cobol en Fortran de
bekenste zijn. Zulke programmeertalen nemen tijdrovende, saaie en administratieve
taken verbonden aan het programmeren, uit handen.
Echter, computers \begrijpen" hogere programmeertalen niet, zij moeten ge?n-
strueerd worden in een zogeheten machinetaal. Om een hogere programmeertaal
naar machinetaal te vertalen zijn er speciale computerprogramma's in omloop,
zogeheten compilers. Met andere woorden, compilers vormen een vitale schakel in
het productieproces van software.
Een compiler zet een zogeheten bronprogramma, geschreven in een specieke
hogere programmeertaal, om naar een zogeheten doel programma in een specieke
machinetaal. Men spreek dan bijvoorbeeld ook van een \Pascal compiler voor een
DOS computer". De kwaliteit van het doelprogramma is niet alleen afhankelijk van
de kwaliteit van het bronprogramma, maar ook van de kwaliteit van de gebruikte
compiler.
Compilers zijn grote, ingewikkelde programma's, die ook geschreven moeten
worden. Dit proces wordt ondersteund door compiler-generatoren. Tijdens mijn?192 Samenvatting
boter
melk 30
10 2,50
1,25
item aantal prijs a
b
c
d
1 23 4
b2 b3 x
c2 c3 x
b4+c4 b2+c2
boter
melk 30
10 2,50
1,25
25,00
52,50
item aantal prijs a
b
c
d
1 23 4
40 77,50
a. Invoer b. Uitvoer
Figuur 2. Een rekenblad voor de melkboer
vierjarig onderzoek heb ik een compiler-generator gemaakt. Een compiler-generator
is een computerprogramma dat, na invoer van een minutieuze beschrijving van
een hogere programmeertaal en de gewenste machinetaal, een compiler voor die
programmeertaal genereert.
De voordelen van een compiler-generator zijn legio. Elke verbetering aan de
generator heeft tot gevolg dat elke gegenereerde compiler verbetert. Bovendien
worden de produktiekosten en de produktietijd verbonden aan het maken van een
compiler, aanzienlijk verminderd. Immers, in plaats van een compiler voor een
hogere programmeertaal hoeft alleen nog maar een beschrijving van die hogere
programmeertaal geschreven te worden. Een student informatica kan in een paar
maanden tijd een compiler genereren, terwijl een groep beroeps programmeurs daar
eerder vele maanden tot jaren mee bezig is.
Incrementele berekeningen
De kracht van de compilers gegenereert door dedoor mij ontwikkelde generator is
voornamelijk gelegen in het feit dat ze incrementeel zijn. Dat betekent dat na een
kleine verandering in het bronprogramma, de compiler de corresponderende veran-
deringen in het doelprogramma aanbrengt|dit in tegenstelling tot het simpelweg
vertalen van het gehele (gewijzigde) bronprogramma. Dit laatste zou veel meer
tijd zou kosten.
Wat een incrementele berekening is wordt elegant ge?llustreerd aan de hand van
een compiler-verwante toepassing: een rekenblad of spreadsheet. Een rekenblad
bestaat uit cellen in een rechthoekig patroon, zie Figuur 2a. Elke cel wordt
aangeduid met een letter-cijfer combinatie. Zo wordt de cel links-boven aangeduid
met a1. Een cel kan tekst, getallen of formules bevatten: cel a1 bevat de tekst
`item', cel b2 bevat het getal 10 en cel b4 bevat de formule b2 b3.
Een rekenblad-evaluator berekent de waarde van de cellen waar formules in
staan. Dus, na invoer van het rekenblad in Figuur 2a wordt de uitvoer van Figuur 2b
geproduceerd.
Stel dat we een verandering aanbrengen in het rekenblad; we voeren een
zogeheten edit-operatie uit. We verlagen het getal in cel b2 van 10 naar 9, zie?Informele inleiding 193
boter
melk 30
2,50
1,25
item aantal prijs a
b
c
d
1 23 4
b2 b3 x
c2 c3 x
b4+c4 b2+c2
9 boter
melk 30
2,50
1,25 52,50
item aantal prijs a
b
c
d
1 23 4
9 22,50
75,00 39
a. Wijziging in de invoer b. Zuinige herberekening
Figuur 3. Wijziging aan een rekenblad
Figuur 3a. De rekenblad-evaluator zou alle cellen met formules opnieuw kunnen
uitrekenen. Een incrementele evaluator berekent alleen de grijze cellen in Figuur 3b.
In dit geval spaart dat de berekening van cel c4 uit.
Het is overigens niet eenvoudig om in te zien welke cellen herberekend moeten
worden. Om dat te bepalen stelt de rekenblad-evaluator een zogeheten graaf op
die de cel-afhankelijkheden weergeeft. Een knoop in de graaf representeert een cel.
Er loopt een pijl van knoop b2 naar knoopb4 omdat de formule van cel b4 refereert
aan cel b2. Zo'n pijl impliceert dat cel b4 na celb2 uitgerekend moet worden.
Bij een incrementele evaluatie moet elke cel wiens knoop in de graaf een
opvolger is van b2, herberekend worden, tenzij veranderingen eerder uitdoven.
Als voorbeeld van dat laatste, beschouwen we de volgende verandering: de prijs
van boter gaat naar 0,25 en de hoeveelheid boter naar 100. In dat geval blijft de
waarde van cel b4 25,00 zodat d4 niet herberekend hoeft te worden. Grafen spelen
b3
b2
c2
c3
c4
d2
b4
d4
bij incrementele berekeningen een belangrijke rol. Ze komen dan ook veelvuldig in
dit proefschrift voor.
Compilers worden ook vaak toegepast op slechts weinig veranderde invoer. Hoe
vaak wordt een computerprogramma niet gecompileerd om er vervolgens achter te
komen dat er een kleine fout in staat? Het is daarom jammer dat er nog zo weinig i:=1 had natuurlijk
i:=0 moeten zijn. incrementele compilers zijn.
Taal-specieke editors
Een editor is een computerprogramma waarmee gegevens in een computer in-
gevoerd kunnen worden. Bovendien kunnen met een editor bestaande gegevens
gewijzigd worden. Meestal verstaat men onder een editor een algemeen programma
waarmee gegevens voor uiteenlopende applicaties (toepassings programma's zoals
compilers, rekenbladen, tekstverwerkers) ingevoerd kunnen worden.
Een applicatie-specieke editor is een invoer-en-wijzig programma dat \kennis"
heeft van een applicatie. Alle huis-tuin-en-keuken applicaties zoals tekstverwerkers L a T E X is geen huis-tuin-
en-keuken applicatie. en rekenbladen zijn uitgerust met applicatie-specieke editors. Het grootste voor-
deel van zulke editors is dat ze de gebruiker kunnen sturen: er kan geen al te grote
onzin in worden gevoerd.?194 Samenvatting
Compilers zouden ook uitgerust kunnen worden met een brontaal-specieke
editor. Dat is met name interessant als er een incrementele compiler beschikbaar
is die tijdens het intypen van het bronprogramma voortdurend het bijbehorende
doelprogramma berekend. Zulke systemen zouden de arbeidsproduktiviteit van
programmeurs enorm verhogen. Immers, fouten in het bronprogramma worden
direct als zodanig herkend door het system, en meegedeeld aan de gebruiker. Het
grootste voordeel is echter dat de editor \ondervraagd" kan worden over bepaalde
kenmerken van het bronprogramma. Voor ingewijden: als de editor constateert dat
i:=1 incorrect is omdat i niet gedeclareerd is kan het een menu aanbieden met alle
integer variabelen in de huidige scoop en een optie om de declaratie i:integer
toe te voegen aan de declaraties.
Kort overzicht
Dit proefschrift beschrijft de generatie van incrementele compilers, met name als
onderdeel van een taal-specieke \language based" editor.
Omdat we uitgaan van een taal-specieke editor, kunnen we het ontleed-
traject (lexical scanning en parsing ) overslaan: de editor onderhoudt een boom-
representatie van het ingevoerde programma. Dat betekent dat compileren niets De titel: Generating
incremental attribute
evaluators.
anders is dan het attribueren van de boom; de compiler is een (incrementele)
attribute evaluator.
Het formalisme waarmee we bomen en attributen beschrijven is het attribuut
grammatica formalisme.
We geven twee methodes om incrementele attribuut evaluatoren te construeren.
De eerste methode is een bestaande: visit-sequences sturen boom decoratie. De
tweede methode is nieuw: visit-sequences worden afgebeeld op visit-functies die
gecached worden om incrementeel gedrag te verkrijgen. Een complicatie bij deze
aanpak vormen zogeheten intra-visit-dependencies. Om dat probleem op te lossen
worden bindingen ge?ntroduceerd.
Visit-functies zijn functies zonder zij-eecten. Dit opent de mogelijkheid tot
allerhanden optimalizaties. Aan de orde komen splitting, elimination, unication,
folding, normalization en untyping.
We bespreken hoe visit-sequences berekend worden aan de hand van een gram-
matica. We wijzigen Kastens' ordered scheduling op twee vlakken. Om te beginnen
voeren we dat grafen in (in stap 4) waardoor een grotere klasse van gramatica's
geaccepteerd wordt. Ten tweede voeren we een nieuw orderings algorithme in
(chained scheduling ) dat visit-sequences berekent die beter geschikt zijn voor
omzetting naar visit-functies.
Een groot deel van het onderzoek heeft zich toegespitst op de haalbaarheid van
een functionele aanpak: we hebben een generator geschreven. De gegenereerde
evaluatoren zijn eenvoudig, elegant en robuust. Bovenal zijn ze snel. De generator
is onder andere gebruikt om een deel van zichzelf te genereren
Proceedings of the 8th Cologne-Twente Workshop on Graphs and Combinatorial Optimization
International audienceThe Cologne-Twente Workshop (CTW) on Graphs and Combinatorial Optimization started off as a series of workshops organized bi-annually by either Köln University or Twente University. As its importance grew over time, it re-centered its geographical focus by including northern Italy (CTW04 in Menaggio, on the lake Como and CTW08 in Gargnano, on the Garda lake). This year, CTW (in its eighth edition) will be staged in France for the first time: more precisely in the heart of Paris, at the Conservatoire National d’Arts et Métiers (CNAM), between 2nd and 4th June 2009, by a mixed organizing committee with members from LIX, Ecole Polytechnique and CEDRIC, CNAM
- …