\project thesis
\startcomponent summary

\language[nl]
\startchapter
  [title={Samenvatting},
   reference=chap:summary-nl]

Het {\it leren van automaten} speelt een steeds grotere rol bij de verificatie van software.
Tijdens het leren, verkent een leeralgoritme het gedrag van software.
Dit gaat in principe volledig automatisch, en het algoritme pakt vanzelf interessante eigenschappen op van de software.
Het is hiermee mogelijk een redelijk precies model te maken van de werking van het stukje software dat we onder de loep nemen.
Fouten en onverwacht gedrag van software kunnen hiermee worden blootgelegd.

In dit proefschrift kijken we in eerste instantie naar technieken voor {\it testgeneratie}.
Deze zijn nodig om het leeralgoritme een handje te helpen.
Na het automatisch verkennen van gedrag, formuleert het leeralgoritme namelijk een hypothese die de software nog niet goed genoeg modelleert.
Om de hypothese te verfijnen en verder te leren, hebben we tests nodig.
{\it Effici\"entie} staat hierbij centraal: we willen zo min mogelijk testen, want dat kost tijd.
Aan de andere kant moeten we wel {\it volledig testen:}
als er een discrepantie is tussen het geleerde model en de software, dan willen we die met een test kunnen aanwijzen.

In de eerste paar hoofdstukken laten we zien hoe testen van automaten te werk gaat.
We geven een theoretisch kader om verschillende, bestaande {\it $n$-volledige testgeneratiemethodes} te vergelijken.
Op grond hiervan beschrijven we een nieuw, effici\"ent algoritme.
Dit nieuwe algoritme staat centraal bij een industri\"ele casus waarin we een model van complexe printer-software van Oc\'e leren.
We laten ook zien hoe een van de deelproblemen -- het {\it onderscheiden van toestanden} met zo kort mogelijke invoer -- effici\"ent kan worden opgelost.

Het tweede thema in dit proefschrift is de theorie van formele talen en automaten met {\it oneindige alfabetten}.
Ook dit is zinnig voor het leren van automaten.
Software, en in het bijzonder internet-communicatie-protocollen, maken namelijk vaak gebruik van \quotation{identifiers} om bijvoorbeeld verschillende gebruikers te onderscheiden.
Het liefst nemen we oneindig veel van zulke identifiers aan, aangezien we niet weten hoeveel er nodig zijn voor het leren van de automaat.

We laten zien hoe we de leeralgoritmes gemakkelijk kunnen veralgemeniseren naar oneindige alfabetten door gebruik te maken van {\it nominale verzamelingen}.
In het bijzonder kunnen we hiermee registerautomaten leren.
Vervolgens werken we de theorie van nominale automaten verder uit.
We laten zien hoe je deze structuren effici\"ent kan implementeren.
En we geven een speciale klasse van nominale automaten die een veel kleinere representatie hebben.
Dit zou gebruikt kunnen worden om zulke automaten sneller te leren.


\stopchapter
\language[en]
\startchapter
  [title={Summary},
   reference=chap:summary-en]

{\it Automata learning} plays a more and more prominent role in the field of software verification.
Learning algorithms are able to automatically explore the behaviour of software.
By revealing interesting properties of the software, these algorithms can create models the, otherwise unknown, software.
These learned models can, in turn, be inspected and analysed, which often leads to finding bugs and inconsistencies in the software.

An important tool which we need when learning software is {\it test generation.}
This is the topic of the first part of this thesis.
After the learning algorithm has learned a model and constructed a hypothesis, test generation methods are used to validate this hypothesis.
{\it Efficiency} is key: we want to test as little as possible, as testing may take valuable time.
However, our tests have to be {\it complete:} if the hypothesis fails to model the software well, we better have a test which shows this discrepancy.

The first few chapters explain black box testing of automata.
We present a theoretical framework in which we can compare existing {\it $n$-complete test generation methods.}
From this comparison, we are able to define a new, efficient algorithm.
In an industrial case study on embedded printer software, we show that this new algorithm works well for finding counterexamples in the hypothesis.
Besides the test generation, we show that one of the subproblems -- finding the shortest sequences to separate states -- can be solved very efficiently.

The second part of this thesis is on the theory of formal languages and automata with {\it infinite alphabets}.
This, too, is discussed in the context of automata learning.
Many pieces of software make use of identifiers or sequence numbers.
These are used, for example, in order to distinguish differen users or messages.
Ideally, we would like to model such systems with infinitely many identifiers, as we do not know beforehand how many of them will be used.

Using the theory of {\it nominal sets}, we show that learning algorithms can easily be generalised to automata with infinite alphabets.
In particular, this shows that we can learn register automata.
Furthermore, we deepen the theory of nominal sets.
First, we show that, in a special case, these sets can be implemented in an efficient way.
Second, we give a subclass of nominal automata which allow for a much smaller representation.
This could be useful for learning such automata more quickly.

\stopchapter


\stopcomponent