joshua/phd-thesis
Archived
1
Fork 0
Code Activity

Started with Learning Nom. Aut.. Adds biblio. Bit on algorithms typesetting.

Browse source
This commit is contained in:
Joshua Moerman 2018-08-02 17:54:28 +02:00
parent fefc170d4b
commit 56de3e67c4
10 changed files with 858 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

452
biblio.bib Normal file
View file

@ -0,0 +1,452 @@
@inproceedings{DBLP:conf/concur/AartsV10,
author = {Fides Aarts and
Frits W. Vaandrager},
title = {Learning {I/O} Automata},
booktitle = {{CONCUR} 2010 - Concurrency Theory, 21th International Conference,
{CONCUR} 2010, Paris, France, August 31-September 3, 2010. Proceedings},
pages = {71--85},
year = {2010},
crossref = {DBLP:conf/concur/2010},
url = {https://doi.org/10.1007/978-3-642-15375-4\_6},
doi = {10.1007/978-3-642-15375-4\_6},
timestamp = {Tue, 23 May 2017 01:11:19 +0200},
biburl = {https://dblp.org/rec/bib/conf/concur/AartsV10},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@proceedings{DBLP:conf/concur/2010,
editor = {Paul Gastin and
Fran{\c{c}}ois Laroussinie},
title = {{CONCUR} 2010 - Concurrency Theory, 21th International Conference,
{CONCUR} 2010, Paris, France, August 31-September 3, 2010. Proceedings},
series = {Lecture Notes in Computer Science},
volume = {6269},
publisher = {Springer},
year = {2010},
url = {https://doi.org/10.1007/978-3-642-15375-4},
doi = {10.1007/978-3-642-15375-4},
isbn = {978-3-642-15374-7},
timestamp = {Tue, 23 May 2017 01:11:19 +0200},
biburl = {https://dblp.org/rec/bib/conf/concur/2010},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@inproceedings{DBLP:conf/ictac/AartsFKV15,
author = {Fides Aarts and
Paul Fiterau{-}Brostean and
Harco Kuppens and
Frits W. Vaandrager},
title = {Learning Register Automata with Fresh Value Generation},
booktitle = {Theoretical Aspects of Computing - {ICTAC} 2015 - 12th International
Colloquium Cali, Colombia, October 29-31, 2015, Proceedings},
pages = {165--183},
year = {2015},
crossref = {DBLP:conf/ictac/2015},
url = {https://doi.org/10.1007/978-3-319-25150-9\_11},
doi = {10.1007/978-3-319-25150-9\_11},
timestamp = {Tue, 23 May 2017 01:11:58 +0200},
biburl = {https://dblp.org/rec/bib/conf/ictac/AartsFKV15},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@proceedings{DBLP:conf/ictac/2015,
editor = {Martin Leucker and
Camilo Rueda and
Frank D. Valencia},
title = {Theoretical Aspects of Computing - {ICTAC} 2015 - 12th International
Colloquium Cali, Colombia, October 29-31, 2015, Proceedings},
series = {Lecture Notes in Computer Science},
volume = {9399},
publisher = {Springer},
year = {2015},
url = {https://doi.org/10.1007/978-3-319-25150-9},
doi = {10.1007/978-3-319-25150-9},
isbn = {978-3-319-25149-3},
timestamp = {Tue, 23 May 2017 01:11:58 +0200},
biburl = {https://dblp.org/rec/bib/conf/ictac/2015},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@article{DBLP:journals/iandc/Angluin87,
author = {Dana Angluin},
title = {Learning Regular Sets from Queries and Counterexamples},
journal = {Inf. Comput.},
volume = {75},
number = {2},
pages = {87--106},
year = {1987},
url = {https://doi.org/10.1016/0890-5401(87)90052-6},
doi = {10.1016/0890-5401(87)90052-6},
timestamp = {Thu, 18 May 2017 09:54:17 +0200},
biburl = {https://dblp.org/rec/bib/journals/iandc/Angluin87},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@inproceedings{DBLP:conf/colt/AngluinC97,
author = {Dana Angluin and
Mikl{\'{o}}s Cs{\"{u}}r{\"{o}}s},
title = {Learning Markov Chains with Variable Memory Length from Noisy Output},
booktitle = {Proceedings of the Tenth Annual Conference on Computational Learning
Theory, {COLT} 1997, Nashville, Tennessee, USA, July 6-9, 1997.},
pages = {298--308},
year = {1997},
crossref = {DBLP:conf/colt/1997},
url = {http://doi.acm.org/10.1145/267460.267517},
doi = {10.1145/267460.267517},
timestamp = {Fri, 23 Dec 2011 14:54:21 +0100},
biburl = {https://dblp.org/rec/bib/conf/colt/AngluinC97},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@proceedings{DBLP:conf/colt/1997,
editor = {Yoav Freund and
Robert E. Schapire},
title = {Proceedings of the Tenth Annual Conference on Computational Learning
Theory, {COLT} 1997, Nashville, Tennessee, USA, July 6-9, 1997},
publisher = {{ACM}},
year = {1997},
url = {http://dl.acm.org/citation.cfm?id=267460},
isbn = {0-89791-891-6},
timestamp = {Mon, 12 Dec 2011 15:03:15 +0100},
biburl = {https://dblp.org/rec/bib/conf/colt/1997},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@inproceedings{DBLP:conf/popl/DAntoniV14,
author = {Loris D'Antoni and
Margus Veanes},
title = {Minimization of symbolic automata},
booktitle = {The 41st Annual {ACM} {SIGPLAN-SIGACT} Symposium on Principles of
Programming Languages, {POPL} '14, San Diego, CA, USA, January 20-21,
2014},
pages = {541--554},
year = {2014},
crossref = {DBLP:conf/popl/2014},
url = {http://doi.acm.org/10.1145/2535838.2535849},
doi = {10.1145/2535838.2535849},
timestamp = {Thu, 09 Jan 2014 08:32:32 +0100},
biburl = {https://dblp.org/rec/bib/conf/popl/DAntoniV14},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@proceedings{DBLP:conf/popl/2014,
editor = {Suresh Jagannathan and
Peter Sewell},
title = {The 41st Annual {ACM} {SIGPLAN-SIGACT} Symposium on Principles of
Programming Languages, {POPL} '14, San Diego, CA, USA, January 20-21,
2014},
publisher = {{ACM}},
year = {2014},
url = {http://dl.acm.org/citation.cfm?id=2535838},
isbn = {978-1-4503-2544-8},
timestamp = {Thu, 09 Jan 2014 08:21:22 +0100},
biburl = {https://dblp.org/rec/bib/conf/popl/2014},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@inproceedings{DBLP:conf/icalp/BojanczykL12,
author = {Miko{\l}aj Boja{\'{n}}czyk and
Slawomir Lasota},
title = {A Machine-Independent Characterization of Timed Languages},
booktitle = {Automata, Languages, and Programming - 39th International Colloquium,
{ICALP} 2012, Warwick, UK, July 9-13, 2012, Proceedings, Part {II}},
pages = {92--103},
year = {2012},
crossref = {DBLP:conf/icalp/2012-2},
url = {https://doi.org/10.1007/978-3-642-31585-5\_12},
doi = {10.1007/978-3-642-31585-5\_12},
timestamp = {Sun, 04 Jun 2017 10:07:30 +0200},
biburl = {https://dblp.org/rec/bib/conf/icalp/BojanczykL12},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@proceedings{DBLP:conf/icalp/2012-2,
editor = {Artur Czumaj and
Kurt Mehlhorn and
Andrew M. Pitts and
Roger Wattenhofer},
title = {Automata, Languages, and Programming - 39th International Colloquium,
{ICALP} 2012, Warwick, UK, July 9-13, 2012, Proceedings, Part {II}},
series = {Lecture Notes in Computer Science},
volume = {7392},
publisher = {Springer},
year = {2012},
url = {https://doi.org/10.1007/978-3-642-31585-5},
doi = {10.1007/978-3-642-31585-5},
isbn = {978-3-642-31584-8},
timestamp = {Sun, 04 Jun 2017 10:07:30 +0200},
biburl = {https://dblp.org/rec/bib/conf/icalp/2012-2},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@inproceedings{DBLP:conf/popl/BojanczykBKL12,
author = {Miko{\l}aj Boja{\'{n}}czyk and
Laurent Braud and
Bartek Klin and
Slawomir Lasota},
title = {Towards nominal computation},
booktitle = {Proceedings of the 39th {ACM} {SIGPLAN-SIGACT} Symposium on Principles
of Programming Languages, {POPL} 2012, Philadelphia, Pennsylvania,
USA, January 22-28, 2012},
pages = {401--412},
year = {2012},
crossref = {DBLP:conf/popl/2012},
url = {http://doi.acm.org/10.1145/2103656.2103704},
doi = {10.1145/2103656.2103704},
timestamp = {Sun, 03 Dec 2017 00:17:33 +0100},
biburl = {https://dblp.org/rec/bib/conf/popl/BojanczykBKL12},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@proceedings{DBLP:conf/popl/2012,
editor = {John Field and
Michael Hicks},
title = {Proceedings of the 39th {ACM} {SIGPLAN-SIGACT} Symposium on Principles
of Programming Languages, {POPL} 2012, Philadelphia, Pennsylvania,
USA, January 22-28, 2012},
publisher = {{ACM}},
year = {2012},
url = {http://dl.acm.org/citation.cfm?id=2103656},
isbn = {978-1-4503-1083-3},
timestamp = {Sun, 03 Dec 2017 00:17:33 +0100},
biburl = {https://dblp.org/rec/bib/conf/popl/2012},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@article{DBLP:journals/corr/BojanczykKL14,
author = {Miko{\l}aj Boja{\'{n}}czyk and
Bartek Klin and
Slawomir Lasota},
title = {Automata theory in nominal sets},
journal = {Logical Methods in Computer Science},
volume = {10},
number = {3},
year = {2014},
url = {https://doi.org/10.2168/LMCS-10(3:4)2014},
doi = {10.2168/LMCS-10(3:4)2014},
timestamp = {Wed, 03 May 2017 14:47:56 +0200},
biburl = {https://dblp.org/rec/bib/journals/corr/BojanczykKL14},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@inproceedings{DBLP:conf/ijcai/BolligHKL09,
author = {Benedikt Bollig and
Peter Habermehl and
Carsten Kern and
Martin Leucker},
title = {Angluin-Style Learning of {NFA}},
booktitle = {{IJCAI} 2009, Proceedings of the 21st International Joint Conference
on Artificial Intelligence, Pasadena, California, USA, July 11-17,
2009},
pages = {1004--1009},
year = {2009},
crossref = {DBLP:conf/ijcai/2009},
url = {http://ijcai.org/Proceedings/09/Papers/170.pdf},
timestamp = {Wed, 20 Jul 2016 14:20:40 +0200},
biburl = {https://dblp.org/rec/bib/conf/ijcai/BolligHKL09},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@proceedings{DBLP:conf/ijcai/2009,
editor = {Craig Boutilier},
title = {{IJCAI} 2009, Proceedings of the 21st International Joint Conference
on Artificial Intelligence, Pasadena, California, USA, July 11-17,
2009},
year = {2009},
url = {http://ijcai.org/proceedings/2009},
timestamp = {Wed, 20 Jul 2016 14:02:05 +0200},
biburl = {https://dblp.org/rec/bib/conf/ijcai/2009},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@inproceedings{DBLP:conf/dlt/BolligHLM13,
author = {Benedikt Bollig and
Peter Habermehl and
Martin Leucker and
Benjamin Monmege},
title = {A Fresh Approach to Learning Register Automata},
booktitle = {Developments in Language Theory - 17th International Conference, {DLT}
2013, Marne-la-Vall{\'{e}}e, France, June 18-21, 2013. Proceedings},
pages = {118--130},
year = {2013},
crossref = {DBLP:conf/dlt/2013},
url = {https://doi.org/10.1007/978-3-642-38771-5\_12},
doi = {10.1007/978-3-642-38771-5\_12},
timestamp = {Fri, 26 May 2017 00:50:55 +0200},
biburl = {https://dblp.org/rec/bib/conf/dlt/BolligHLM13},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@proceedings{DBLP:conf/dlt/2013,
editor = {Marie-Pierre B{\'{e}}al and
Olivier Carton},
title = {Developments in Language Theory - 17th International Conference, {DLT}
2013, Marne-la-Vall{\'{e}}e, France, June 18-21, 2013. Proceedings},
series = {Lecture Notes in Computer Science},
volume = {7907},
publisher = {Springer},
year = {2013},
url = {https://doi.org/10.1007/978-3-642-38771-5},
doi = {10.1007/978-3-642-38771-5},
isbn = {978-3-642-38770-8},
timestamp = {Fri, 26 May 2017 00:50:55 +0200},
biburl = {https://dblp.org/rec/bib/conf/dlt/2013},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@article{DBLP:journals/fac/CasselHJS16,
author = {Sofia Cassel and
Falk Howar and
Bengt Jonsson and
Bernhard Steffen},
title = {Active learning for extended finite state machines},
journal = {Formal Asp. Comput.},
volume = {28},
number = {2},
pages = {233--263},
year = {2016},
url = {https://doi.org/10.1007/s00165-016-0355-5},
doi = {10.1007/s00165-016-0355-5},
timestamp = {Wed, 17 May 2017 14:25:34 +0200},
biburl = {https://dblp.org/rec/bib/journals/fac/CasselHJS16},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@article{DBLP:journals/tocl/DemriL09,
author = {St{\'{e}}phane Demri and
Ranko Lazic},
title = {{LTL} with the freeze quantifier and register automata},
journal = {{ACM} Trans. Comput. Log.},
volume = {10},
number = {3},
pages = {16:1--16:30},
year = {2009},
url = {http://doi.acm.org/10.1145/1507244.1507246},
doi = {10.1145/1507244.1507246},
timestamp = {Mon, 09 Jan 2017 14:08:26 +0100},
biburl = {https://dblp.org/rec/bib/journals/tocl/DemriL09},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@inproceedings{DBLP:conf/vmcai/HowarSJC12,
author = {Falk Howar and
Bernhard Steffen and
Bengt Jonsson and
Sofia Cassel},
title = {Inferring Canonical Register Automata},
booktitle = {Verification, Model Checking, and Abstract Interpretation - 13th International
Conference, {VMCAI} 2012, Philadelphia, PA, USA, January 22-24, 2012.
Proceedings},
pages = {251--266},
year = {2012},
crossref = {DBLP:conf/vmcai/2012},
url = {https://doi.org/10.1007/978-3-642-27940-9\_17},
doi = {10.1007/978-3-642-27940-9\_17},
timestamp = {Wed, 24 May 2017 08:30:31 +0200},
biburl = {https://dblp.org/rec/bib/conf/vmcai/HowarSJC12},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@proceedings{DBLP:conf/vmcai/2012,
editor = {Viktor Kuncak and
Andrey Rybalchenko},
title = {Verification, Model Checking, and Abstract Interpretation - 13th International
Conference, {VMCAI} 2012, Philadelphia, PA, USA, January 22-24, 2012.
Proceedings},
series = {Lecture Notes in Computer Science},
volume = {7148},
publisher = {Springer},
year = {2012},
url = {https://doi.org/10.1007/978-3-642-27940-9},
doi = {10.1007/978-3-642-27940-9},
isbn = {978-3-642-27939-3},
timestamp = {Wed, 24 May 2017 08:30:31 +0200},
biburl = {https://dblp.org/rec/bib/conf/vmcai/2012},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@article{DBLP:journals/tcs/KaminskiF94,
author = {Michael Kaminski and
Nissim Francez},
title = {Finite-Memory Automata},
journal = {Theor. Comput. Sci.},
volume = {134},
number = {2},
pages = {329--363},
year = {1994},
url = {https://doi.org/10.1016/0304-3975(94)90242-9},
doi = {10.1016/0304-3975(94)90242-9},
timestamp = {Sun, 28 May 2017 13:20:09 +0200},
biburl = {https://dblp.org/rec/bib/journals/tcs/KaminskiF94},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@inproceedings{DBLP:journals/corr/KlinS16,
author = {Bartek Klin and
Michal Szynwelski},
title = {{SMT} Solving for Functional Programming over Infinite Structures},
booktitle = {Proceedings 6th Workshop on Mathematically Structured Functional Programming,
MSFP@ETAPS 2016, Eindhoven, Netherlands, 8th April 2016.},
pages = {57--75},
year = {2016},
crossref = {DBLP:journals/corr/AtkeyK16},
url = {https://doi.org/10.4204/EPTCS.207.3},
doi = {10.4204/EPTCS.207.3},
timestamp = {Wed, 03 May 2017 14:47:57 +0200},
biburl = {https://dblp.org/rec/bib/journals/corr/KlinS16},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@proceedings{DBLP:journals/corr/AtkeyK16,
editor = {Robert Atkey and
Neelakantan R. Krishnaswami},
title = {Proceedings 6th Workshop on Mathematically Structured Functional Programming,
MSFP@ETAPS 2016, Eindhoven, Netherlands, 8th April 2016},
series = {{EPTCS}},
volume = {207},
year = {2016},
url = {https://doi.org/10.4204/EPTCS.207},
doi = {10.4204/EPTCS.207},
timestamp = {Wed, 03 May 2017 14:47:56 +0200},
biburl = {https://dblp.org/rec/bib/journals/corr/AtkeyK16},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@article{DBLP:journals/tcs/MontanariS14,
author = {Ugo Montanari and
Matteo Sammartino},
title = {A network-conscious {\(\pi\)}-calculus and its coalgebraic semantics},
journal = {Theor. Comput. Sci.},
volume = {546},
pages = {188--224},
year = {2014},
url = {https://doi.org/10.1016/j.tcs.2014.03.009},
doi = {10.1016/j.tcs.2014.03.009},
timestamp = {Thu, 08 Jun 2017 09:02:39 +0200},
biburl = {https://dblp.org/rec/bib/journals/tcs/MontanariS14},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@phdthesis{DBLP:phd/de/Niese2003,
author = {Oliver Niese},
title = {An integrated approach to testing complex systems},
school = {Technical University of Dortmund, Germany},
year = {2003},
url = {http://eldorado.uni-dortmund.de:8080/0x81d98002\_0x0007b62b},
urn = {urn:nbn:de:101:1-201103292278},
timestamp = {Wed, 07 Dec 2016 14:16:48 +0100},
biburl = {https://dblp.org/rec/bib/phd/de/Niese2003},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
@book{Pitts13,
author={Andrew M. Pitts},
editor={Samson Abramsky and
Peter Aczel and
Yuri Gurevich and
John Tucker},
publisher={Cambridge University Press},
series={Cambridge Tracts in Theoretical Computer Science},
title={Nominal sets: Names and symmetry in computer science},
year={2013}
}

7
content.tex
View file

@ -1,5 +1,5 @@
\project thesis
\startproduct content
\project thesis
\starttext
@ -20,9 +20,12 @@
\component content/test-methods
\chapter{Learning Embedded Stuff}
\chapter{Separating Sequences}
\chapter{Learning Nominal Automata}
\component content/learning-nominal-automata
\chapter{Ordered Nominal Sets}
\chapter{Succinct Nominal Automata?}
\placelistofpublications
\stoptext
\stopproduct

335
content/learning-nominal-automata.tex Normal file
View file

@ -0,0 +1,335 @@
\project thesis
\startcomponent learning-nominal-automata
\startchapter
[title={Learning Nominal Automata},
reference=chap:learning-nominal-automata]
\todo{Auteurs en moet ik ook support noemen van de andere auteurs? Keywords?}
\startabstract
We present an Angluin-style algorithm to learn nominal automata, which are acceptors of languages over infinite (structured) alphabets.
The abstract approach we take allows us to seamlessly extend known variations of the algorithm to this new setting.
In particular we can learn a subclass of nominal non-deterministic automata.
An implementation using a recently developed Haskell library for nominal computation is provided for preliminary experiments.
\stopabstract
\startsection
[title={Introduction}]
Automata are a well established computational abstraction with a wide range of applications, including modelling and verification of (security) protocols, hardware, and software systems.
In an ideal world, a model would be available before a system or protocol is deployed in order to provide ample opportunity for checking important properties that must hold and only then the actual system would be synthesized from the verified model.
Unfortunately, this is not at all the reality:
Systems and protocols are developed and coded in short spans of time and if mistakes occur they are most likely found after deployment.
In this context, it has become popular to infer or learn a model from a given system just by observing its behaviour or response to certain queries.
The learned model can then be used to ensure the system is complying to desired properties or to detect bugs and design possible fixes.
Automata learning, or regular inference, is a widely used technique for creating an automaton model from observations.
The original algorithm by \cite[authoryears][DBLP:journals/iandc/Angluin87] works for deterministic finite automata, but since then has been extended to other types of automata, including Mealy machines and I/O automata (see \cite[left=,right=,righttext={\sectionmark 8.5}][DBLP:phd/de/Niese2003] and \cite[left=,right=][DBLP:conf/concur/AartsV10]), and even a special class of context-free grammars.
\todo{Deze nog citeren \cite[DBLP:conf/colt/AngluinC97]?}
Angluin's algorithm is sometimes referred to as {\em active learning}, because it is based on direct interaction of the learner with an oracle (\quotation{the Teacher}) that can answer different types of queries.
This is in contrast with \emph{passive} learning, where a fixed set of positive and negative examples is given and no interaction with the system is possible.
In this paper, staying in the realm of active learning, we will extend Angluin's algorithm to a richer class of automata.
We are motivated by situations in which a program model, besides control flow, needs to represent basic data flow, where data items are compared for equality (or for other theories such as total ordering).
In these situations, values for individual symbols are typically drawn from an infinite domain and automata over \emph{infinite alphabets} become natural models, as witnessed by a recent trend \cite[DBLP:conf/dlt/BolligHLM13, DBLP:conf/ictac/AartsFKV15,DBLP:conf/popl/DAntoniV14, DBLP:journals/corr/BojanczykKL14, DBLP:journals/fac/CasselHJS16].
One of the foundational approaches to formal language theory for infinite alphabets uses the notion of nominal sets \cite[DBLP:journals/corr/BojanczykKL14].
The theory of nominal sets originates from the work of Fraenkel in 1922, and they were originally used to prove the independence of the axiom of choice and other axioms.
They have been rediscovered in Computer Science by Gabbay and Pitts \cite[Pitts13], as an elegant formalism for modeling name binding, and since then they form the basis of many research projects in the semantics and concurrency community.
In a nutshell, nominal sets are infinite sets equipped with symmetries which make them finitely representable and tractable for algorithms.
We make crucial use of this feature in the development of a learning algorithm.
Our main contributions are the following.
\startitemize
\item A generalization of Angluin's original algorithm to nominal automata.
The generalization follows a generic pattern for transporting computation models from finite sets to nominal sets, which leads to simple correctness proofs and opens the door to further generalizations.
The use of nominal sets with different symmetries also creates potential for generalization, e.g., to languages with time features \cite[DBLP:conf/icalp/BojanczykL12] or data dependencies represented as graphs \cite[DBLP:journals/tcs/MontanariS14].
\item An extension of the algorithm to nominal non-deterministic automata (nominal NFAs).
To the best of our knowledge, this is the first learning algorithm for non-deterministic automata over infinite alphabets.
It is important to note that, in the nominal setting, NFAs are strictly more expressive than DFAs.
We learn a subclass of the languages accepted by nominal NFAs, which includes all the languages accepted by nominal DFAs.
The main advantage of learning NFAs directly is that they can provide exponentially smaller automata when compared to their deterministic counterpart.
This can be seen both as a generalization and as an optimization of the algorithm.
\item An implementation using our recently developed Haskell library tailored to nominal computation -- NLambda \cite[DBLP:journals/corr/KlinS16].
Our implementation is the first non-trivial application of a novel programming paradigm of functional programming over infinite structures, which allows the programmer to rely on convenient intuitions of searching through infinite sets in finite time.
\stopitemize
The paper is organized as follows.
In \in{Section}[sec:overview], we present an overview of our contributions (and the original algorithm) highlighting the challenges we faced in the various steps.
In \in{Section}[sec:prelim], we revise some basic concepts of nominal sets and automata.
\in{Section}[sec:nangluin] contains the core technical contributions of our paper: The new algorithm and proof of correctness.
In \in{Section}[sec:nondet], we describe an algorithm to learn nominal non-deterministic automata.
\in{Section}[sec:impl] contains a description of NLambda, details of the implementation, and results of preliminary experiments.
\in{Section}[sec:related] contains a discussion of related work. We conclude the paper with a discussion section where also future directions are presented.
\stopsection
\startsection
[title={Overview of the Approach},
reference=sec:overview]
In this section, we give an overview of the work developed in the paper through examples.
We will start by explaining the original algorithm for regular languages over finite alphabets, and then explain the challenges in extending it to nominal languages.
Angluin's algorithm \LStar{} provides a procedure to learn the minimal DFA accepting a certain (unknown) language $\lang$.
The algorithm has access to a \emph{teacher} which answers two types of queries:
\startitemize
\item \emph{membership queries}, consisting of a single word $w \in A^{\ast}$, to which the teacher will reply whether $w \in \lang$ or not;
\item \emph{equivalence queries}, consisting of a hypothesis DFA $H$, to which the teacher replies {\bf yes} if $\lang(H) = \lang$, and {\bf no} otherwise, providing a counterexample $w \in \lang(H) \triangle \lang$ ($\triangle$ denotes the symmetric difference of two languages).
\stopitemize
The learning algorithm works by incrementally building an {\em observation table}, which at each stage contains partial information about the language $\lang$.
The algorithm is able to fill the table with membership queries.
As an example, and to set notation, consider the following table (over $A=\{a, b\}$).
\starttikzpicture
\matrix[matrix of nodes](tab)
{
\phantom{$\epsilon$} & {$\epsilon$} & $a$ & $aa$ \\
$\epsilon$ & $0$ & $0$ & $1$ \\
$a$ & $0$ & $1$ & $0$ \\
$b$ & $0$ & $0$ & $0$ \\
};
\draw (tab-1-1.south west) -| (tab-1-4.south east);
\draw (tab-2-1.south west) -| (tab-2-4.south east);
\draw (tab-1-1.north east) -| (tab-4-1.south east);
\draw[decorate, decoration=brace] (tab-1-2.north) -- node[above]{$E$} (tab-1-4.north) ;
\draw[decorate, decoration=brace] (tab-4-1.west) -- node[left]{$S \cup S \Lext A$} (tab-2-1.west);
\node[fit=(tab-2-2)(tab-2-3)(tab-2-4), dotted, draw, inner sep=-2pt] (r1) {};
\node[fit=(tab-3-2)(tab-3-3)(tab-3-4), dotted, draw, inner sep=-2pt] (r2) {};
\node[fit=(tab-4-2)(tab-4-3)(tab-4-4), dotted, draw, inner sep=-2pt] (r3) {};
\node[right=1cm of tab](row){$row \colon S \cup S \Lext A \to 2^E$};
\node[below=0em of row](rowd){$row(u)(v) = 1 \iff uv \in \lang$};
\draw[->, shorten >=10pt, dotted] (r1.east) -- (row.west);
\draw[->, shorten >=10pt, dotted] (r2.east) -- (row.west);
\draw[->, shorten >=10pt, dotted] (r3.east) -- (row.west);
\stoptikzpicture
This table indicates that $\lang$ contains at least $aa$ and definitely does not contain the words $\epsilon, a, b, ba, baa, aaa$.
Since $row$ is fully determined by the language $\lang$, we will from now on refer to an observation table as a pair $(S,E)$, leaving the language $\lang$ implicit.
Given an observation table $(S,E)$ one can construct a deterministic automaton $M(S,E) = (Q,q_0,\delta,F)$ where
\startitemize
\item $Q = \{row(s)\mid s\in S\}$ is a finite set of states;
\item $F = \{ row (s) \mid s\in S, row(s)(\epsilon)=1\} \subseteq Q$ is the set of final states;
\item $q_0 = row(\epsilon)$ is the initial state;
\item $\delta\colon Q\times A \to Q$ is the transition function given by $\delta(row(s),a) = row(sa)$.
\stopitemize
For this to be well-defined, we need to have $\epsilon \in S$ (for the initial state) and $\epsilon \in E$ (for final states), and for the transition function there are two crucial properties of the table that need to hold:
Closedness and consistency.
An observation table $(S,E)$ is {\em closed} if for all $t\in S \Lext A$ there exists an $s \in S$ such that $row(t) = row(s)$.
An observation table $(S,E)$ is {\em consistent} if, whenever $s_1$ and $s_2$ are elements of $S$ such that $row(s_1) = row(s_2)$, for all $a \in A$, $row(s_1 a) = row(s_2 a)$.
Each time the algorithm constructs an automaton, it poses an equivalence query to the teacher.
It terminates when the answer is {\bf yes}, otherwise it extends the table with the counterexample provided.
\startplacealgorithm[title={The \LStar{} learning algorithm from \cite[authoryears][DBLP:journals/iandc/Angluin87].}, reference=alg:alg]
\startalgorithmic
\startlinenumbering
\STATE $S,E \gets \{\epsilon\}$
\REPEAT
\WHILE{$(S, E)$ is not closed or not consistent\someline[line:checks]}
\IF{$(S, E)$ is not closed\someline[line:begin-closed]}
\STATE find $s_1\in S$, $a \in A$ such that
\STATE \hfill $row(s_1a) \neq row(s)$ for all $s\in S$\someline[line:clos-witness]
\STATE $S\gets S\cup \{s_1a\}$ \someline[line:addrow-clos]
\ENDIF\someline[line:end-closed]
\IF{$(S, E)$ is not consistent\someline[line:begin-const]}
\STATE find $s_1, s_2 \in S$, $a \in A$, and $e\in E$ such that
\STATE \hfill $row(s_1) = row(s_2)$ and $\lang(s_1 a e) \neq \lang(s_2 a e)$\someline[line:cons-witness]
\STATE $E\gets E\cup \{ae\}$
\ENDIF
\ENDWHILE\someline[line:end-const]
\STATE Make the conjecture $M(S,E)$\someline[line:conj]
\IF{the Teacher replies {\bf no}, with a counter-example $t$\someline[line:counter-ex]}
\STATE $S\gets S\cup pref(t)$ \someline[line:addrow-ex]
\ENDIF
\UNTIL{the Teacher replies {\bf yes} to the conjecture $M(S,E)$}
\RETURN $M(S,E)$
\stoplinenumbering
\stopalgorithmic
\stopplacealgorithm
\startsubsection
[title={Simple Example of Execution},
reference=sec:execution_example_original]
Angluin's algorithm is displayed in \in{Algorithm}[alg:alg]. Throughout this section, we will consider the language(s)
\startformula
\lang_n = \left{ ww \mid w \in A^{\ast}, |w| = n \right}
\stopformula
If the alphabet $A$ is finite then $\lang_n$ is regular for any $n \in \N$, and there is a finite DFA accepting it.
The language $\lang_1 = \{ aa , bb \}$ looks trivial, but the minimal DFA recognizing it has as many as 5 states.
Angluin's algorithm will terminate in (at most) 5 steps.
We illustrate some relevant ones.
\startstep{1}
We start from $S, E = \{\epsilon\}$, and we fill the entries of the table below by asking membership queries for $\epsilon$, $a$ and $b$.
The table is closed and consistent, so we construct the hypothesis $\autom_1$.
\todo{tikz \tt 134-155}
The Teacher replies {\bf no} and gives the counterexample $aa$, which is in $\lang_1$ but it is not accepted by $\autom_1$.
Therefore, line 12 of the algorithm is triggered and we set $S \gets S \cup \{a, aa\}$.
\stopstep
\startstep{2}
The table becomes the one on the left below.
It is closed, but not consistent:
Rows $\epsilon$ and $a$ are identical, but appending $a$ leads to different rows, as depicted.
Therefore, line 9 is triggered and an extra column $a$, highlighted in red, is added.
The new table is closed and consistent and a new hypothesis $\autom_2$ is constructed.
\todo{tikz \tt 163-219}
The Teacher again replies {\bf no} and gives the counterexample $bb$, which should be accepted by $\autom_2$ but it is not. Therefore we put $S \gets S \cup \{b,bb\}$.
\stopstep
\startstep{3}
The new table is the one on the left.
It is closed, but $\epsilon$ and $b$ violate consistency, when $b$ is appended.
Therefore we add the column $b$ and we get the table on the right, which is closed and consistent.
The new hypothesis is $\autom_3$.
\todo{tikz \tt 228-296}
The Teacher replies {\bf no} and provides the counterexample $babb$, so $S \gets S \cup \{ba,bab\}$.
\stopstep
\startstep{4}
One more step brings us to the correct hypothesis $\autom_4$ (details are omitted).
\todo{tikz \tt 304-323}
\stopstep
\stopsubsection
\startsubsection
[title={Learning Nominal Languages},
reference=ssec:nom-learning]
Consider now an infinite alphabet $A = \{a,b,c,d,\dots\}$.
The language $\lang_1$ becomes $\{aa,bb,cc,dd,\dots\}$.
Classical theory of finite automata does not apply to this kind of languages, but one may draw an infinite deterministic automaton that recognizes $\lang_1$ in the standard sense:
\todo{tikz \tt 330-355}
where $\xrightarrow{A}$ and $\xrightarrow{\neq a}$ stand for the infinitely-many transitions labelled by elements of $A$ and $A \setminus \{a\}$, respectively.
This automaton is infinite, but it can be finitely presented in a variety of ways, for example:
\todo{tikz \tt 361-378}
One can formalize the quantifier notation above (or indeed the \quotation{dots} notation above that) in several ways.
A popular solution is to consider finite {\em register automata} \cite[DBLP:journals/tcs/KaminskiF94, DBLP:journals/tocl/DemriL09], i.e., finite automata equipped with a finite number of registers where alphabet letters can be stored and later compared for equality.
Our language $\lang_1$ is recognized by a simple automaton with four states and one register.
The problem of learning registered automata has been successfully attacked before
\cite[DBLP:conf/vmcai/HowarSJC12].
In this paper, however, we will consider nominal automata \cite[DBLP:journals/corr/BojanczykKL14] instead.
These automata ostensibly have infinitely many states, but the set of states can be finitely presented in a way open to effective manipulation.
More specifically, in a nominal automaton the set of states is subject to an action of permutations of a set $\EAlph$ of {\em atoms}, and it is finite up to that action.
For example, the set of states of $\autom_5$ is:
\startformula
\{q_0,q_3,q_4\} \cup \{q_a \mid a\in A\}
\stopformula
and it is equipped with a canonical action of permutations $\pi \colon \EAlph \to \EAlph$ that maps every $q_a$ to $q_{\pi(a)}$, and leaves $q_0$, $q_3$ and $q_4$ fixed.
Technically speaking, the set of states has four {\em orbits} (one infinite orbit and three fixed points) of the action of the group of permutations of $\EAlph$.
%
Moreover, it is required that in a nominal automaton the transition relation is {\em equivariant}, i.e., closed under the action of permutations.
The automaton $\autom_5$ has this property:
For example, it has a transition $q_a\stackrel{a}{\longrightarrow} q_3$, and for any $\pi \colon \EAlph \to \EAlph$ there is also a transition $\pi(q_a) = q_{\pi(a)}\stackrel{\pi(a)}{\longrightarrow} q_3 = \pi(q_3)$.
Nominal automata with finitely many orbits of states are equi-expressive with finite register automata \cite[DBLP:journals/corr/BojanczykKL14], but they have an important theoretical advantage:
They are a direct reformulation of the classical notion of finite automaton, where one replaces finite sets with orbit-finite sets and functions (or relations) with equivariant ones.
A research programme advocated in \cite[DBLP:journals/corr/BojanczykKL14, DBLP:conf/popl/BojanczykBKL12] is to transport various computation models, algorithms and theorems along this correspondence.
This can often be done with remarkable accuracy, and our paper is a witness to this.
Indeed, as we shall see, nominal automata can be learned with an algorithm that is almost a verbatim copy of the classical Angluin's one.
Indeed, consider applying Angluin's algorithm to our new language $\lang_1$.
The key idea is to change the basic data structure:
Our observation table $(S,E)$ will be such that \emph{$S$ and $E$ are equivariant subsets of $A^{\ast}$}, i.e., they are closed under the canonical action of atom permutations.
In general, such a table has {\em infinitely many rows and columns}, so the following aspects of \in{Algorithm}[alg:alg] seem problematic:
\description{\inline{line}[line:checks]} closedness and consistency tests range over infinite sets;
\description{\inline{line}[line:clos-witness] and \inline{line}[line:cons-witness]} finding witnesses for closedness or consistency violations potentially require checking all infinitely many rows;
\todo{Is hetzelfde als die hierboven. Doe maar line 4 en 9: oneindige checks. Extra clause over $S$ en $E$ oneindig?}
\description{\inline{line}[line:addrow-ex]} every counterexample $t$ has only infinitely many prefixes, so it is not clear how one would construct an infinite set $S$ in finite time.
However, an infinite $S$ is necessary for the algorithm to ever succeed, because no finite automaton recognizes $\lang_1$.
At this stage, we need to observe that due to equivariance of $S$, $E$ and $\lang_1$, the following crucial properties hold:
\description{(P1)} the sets $S$, $S \Lext A$ and $E$ admit a \emph{finite} representation up to permutations;
\description{(P2)} the function $row$ is such that $row(\pi(s))(\pi(e)) = row(s)(e)$, for all $s \in S$ and $e \in E$, so the observation table admits a finite symbolic representation.
Intuitively, checking closedness and consistency, and finding a witness for their violations, can be done effectively on the representations up to permutations {\bf (P1)}.
This is sound, as $row$ is invariant w.r.t. permutations {\bf (P2)}.
We now illustrate these points through a few steps of the algorithm for $\lang_1$.
\startstep{1'}
We start from $S, E = \{ \epsilon \}$.
We have $S \Lext A = A$, which is infinite but admits a finite representation.
In fact, for any $a \in A$, we have $A = \{ \pi(a) \mid \text{$\pi$ is a permutation}\}$.
Then, by {\bf (P2)}, $row(\pi(a))(\epsilon) = row(a)(\epsilon) = 0$, for all $\pi$, so the first table can be written as:
\todo{tikz \tt 411-434}
It is closed and consistent.
Our hypothesis is $\autom_1'$, where $\delta_{\autom_1'}(row(\epsilon),x) = row(x) = q_0$, for all $x \in A$.
As in {\bf Step 1}, the Teacher replies with the counterexample $aa$.
\stopstep
\startstep{2'}
By equivariance of $\lang_1$, the counterexample tells us that \emph{all} words of length 2 with two repeated letters are accepted.
Therefore we extend $S$ with the (infinite!) set of such words.
The new symbolic table is:
\todo{tikz \tt 440-452}
The lower part stands for elements of $S \Lext A$.
For instance, $ab$ stands for words obtained by appending a fresh letter to words of length 1 (row $a$).
It can be easily verified that all cases are covered. Notice that the table is different from that of {\bf Step 2}:
A single $b$ is not in the lower part, because it can be obtained from $a$ via a permutation. The table is closed.
Now, for consistency we need to check $row(\epsilon x) = row(ax)$, for all $a,x \in A$.
Again, by {\bf (P2)}, it is enough to consider rows of the table above.
Consistency is violated, because $row(a) \neq row(aa)$.
We found a \quotation{symbolic} witness $a$ for such violation.
In order to fix consistency, while keeping $E$ equivariant, we need to add columns for all $\pi(a)$.
The resulting table is
\todo{tikz \tt 457-470}
where non-specified entries are $0$.
Only finitely many entries of the table are relevant:
$row(s)$ is fully determined by its values on letters in $s$ and on just one letter not in $s$.
For instance, we have $row(a)(a) = 1$ and $row(a)(a') = 0$, for all $a' \in A \setminus \{ a \}$.
The table is trivially consistent.
Notice that this step encompasses both {\bf Step 2} and {\bf 3}, because the rows $b$ and $bb$ added by {\bf Step 2} are already represented by $a$ and $aa$.
The hypothesis automaton is
\todo{tikz \tt 475-488}
This is again incorrect, but one additional step will give the correct hypothesis automaton, shown earlier in \in{?}[eq:aut]).
\stopstep
\stopsubsection
\startsubsection
[title={Generalization to Non-Deterministic Automata}]
Since our extension of Angluin's \LStar{} algorithm stays close to her original development, exploring extensions of other variations of \LStar{} to the nominal setting can be done in a systematic way.
We will show how to extend the algorithm \NLStar{} for learning NFAs by \cite[authoryears][DBLP:conf/ijcai/BolligHKL09].
This has practical implications: It is well-known that NFAs are exponentially more succinct than DFAs.
This is true also in the nominal setting. However, there are challenges in the extension that require particular care.
\startitemize
\item Nominal NFAs are strictly more expressive than nominal DFAs.
We will show that the nominal version of \NLStar{} terminates for all nominal NFAs that have a corresponding nominal DFA and, more surprisingly, that it is capable of learning some languages that are not accepted by nominal DFAs.
\item Language equivalence of nominal NFAs is undecidable.
This does not affect the correctness proof, as it assumes a teacher which is able to answer equivalence queries accurately.
For our implementation, we will describe heuristics that produce correct results in many cases.
\stopitemize
For the learning algorithm the power of non-determinism means that we can make some shortcuts during learning:
If we want to make the table closed, we were previously required to find an equivalent row in the upper part; now we may find a sum of rows which, together, are equivalent to an existing row.
This means that in some cases fewer rows will be added for closedness.
\stopsubsection
\stopsection
\placelistofpublications
\stopcomponent

3
content/test-methods.tex
View file

@ -154,7 +154,6 @@ The issue of an unknown bound is addressed later in the paper.
\stopsubsection
\startsubsection[title={State identifiers, access sequences and sets of words}]
\define[1]\Fam{\mathcal{#1}}
In order to define a test suite modularly, we introduce notation for combining sets of words.
We require all sets to be \emph{prefix-closed}, this is very convenient in later proofs.
@ -308,6 +307,7 @@ For this reason we call the method a hybrid method.
\startalgorithmic
\REQUIRE{A Mealy machine $M$}
\ENSURE{A separating family $Z'$}
\startlinenumbering
\STATE{$T_1 \leftarrow$ splitting tree for Moore's minimization algorithm}
\STATE{$\Fam{H} \leftarrow$ separating family extracted from $T_1$}
\STATE{$T_2 \leftarrow$ splitting tree with valid splits (see \cite{LeeYannakakis})}
@ -318,6 +318,7 @@ For this reason we call the method a hybrid method.
}
\ENDFOR
\RETURN{$Z'$}
\stoplinenumbering
\stopalgorithmic
\stopplacealgorithm

22
environment.tex
View file

@ -3,13 +3,17 @@
% Bug in context? Zonder de ../ kunnen componenten de files niet vinden
\usepath[{environment,../environment}]
\environment bib
\environment font
\environment pdf
\environment notation
\environment paper
\environment pdf
\mainlanguage[en]
\setuppagenumbering[alternative=doublesided]
\setupindenting[yes, medium]
\setupwhitespace[medium]
\defineenumeration[definition][text=Definition]
\defineenumeration[example][text=Example]
@ -17,11 +21,19 @@
\defineenumeration[fact][text=Fact?] % niet nodig?
\setupenumeration[definition,example,lemma,fact][alternative=serried,width=fit,right=.]
\definefloat[algorithm][algorithms][figure]
\setuplabeltext[en][algorithm=Algorithm ]
\definefloat[algorithm][algorithms]
\setupcombinedlist[content][list={chapter,section}]
\definestartstop[abstract]
[before={\midaligned{\bf Abstract}\startnarrower[2*middle]},
after={\stopnarrower\blank[big]}]
\definedescription[description]
[headstyle=bold, alternative=serried, width=fit]
\definedescription[step]
[headstyle=bold, alternative=serried, width=fit, text={Step }]
% The black dot is missing from Euler?
\setupitemize[2,joinedup,nowhite,after]
@ -32,9 +44,11 @@
\define[1]\todo{\color[red]{\ss \bf #1}}
\usemodule[tikz]
\usetikzlibrary[automata, arrows, positioning]
\usetikzlibrary[automata, arrows, positioning, matrix, fit, decorations.pathreplacing]
\usemodule[algorithmic]
\setupalgorithmic[align=middle,numbercolor=darkgray] % center line numbers
\setupalgorithmic[before={\startframedtext[width=0.85\textwidth,offset=none,frame=off]},after={\stopframedtext}] % To enable linenumbers in a float
% Debugging
%\enabletrackers[references.references, visualizers.justification]

21
environment/bib.tex Normal file
View file

@ -0,0 +1,21 @@
\startenvironment bib
\usebtxdefinitions[apa]
\usebtxdataset[../biblio.bib]
\setupbtx[apa:cite][etallimit=2]
% The dblp database ignores Pauls nice a-breve and s-comma
\btxremapauthor [Paul Fiterau{-}Brostean] [Paul Fiterău-Broștean]
\btxremapauthor [Michal Szynwelski] [Micha\l{} Szynwelski]
\btxremapauthor [Slawomir Lasota] [S\l{}awomir Lasota]
%\define[1]\citenp{\cite[left=,right=][#1]} % Bla and Foo, 2015
%\define[1]\citet{\cite[authoryears][#1]} % Bla and Foo (2015)
%\define[1]\citep{\cite[authoryear][#1]} % (Bla and Foo, 2015)
%\cite[authoryear] -> (Bla, Foo & Baz, 2015)
%\cite[authoryears] -> Bla, Foo & Baz (2015)
%\cite[lefttext={See },righttext={ p.\nbsp yy}][book] -> (See Bla, Foo & Baz, 2015, p. yy)
\stopenvironment

3
environment/font.tex
View file

@ -16,7 +16,8 @@
% Eventueel kunnen we mathcal vervangen door een ander font
%\definefallbackfamily[myfamily] [mm] [TeX Gyre Pagella Math][range=uppercasescript,rscale=1.05]
% (Neo) Euler heeft niet alle symbolen, maar Pagella wel
\definefallbackfamily[mainfamily] [mm] [TeX Gyre Pagella Math][range=0x0266D-0x0266F,rscale=0.95] % sharp and flat
\definefallbackfamily[mainfamily] [mm] [TeX Gyre Pagella Math] [range=0x0266D-0x0266F,rscale=0.95] % sharp and flat
\definefallbackfamily[mainfamily] [mm] [TeX Gyre Pagella Math] [range=0x025B3] % triangle
% Neo Euler voor wiskunde. Merk op dat dit niet cursief is!
\definefontfamily[mainfamily] [mm] [Neo Euler]

19
environment/notation.tex Normal file
View file

@ -0,0 +1,19 @@
\startenvironment notation
\define[1]\Fam{\mathcal{#1}}
\define\lang{\mathcal{L}}
\define\autom{\mathcal{A}}
% L* algorithms
\define\LStar{{\tt L}$^{\ast}$}
\define\NLStar{{\tt NL}$^{\ast}$}
\define\nLStar{$\nu$\LStar}
\define\nNLStar{$\nu$\NLStar}
\define\N{\naturalnumbers}
\define\EAlph{\mathbb{A}}
% language extension
\define\Lext{{\cdot}}
\stopenvironment

3
stellingen.txt Normal file
View file

@ -0,0 +1,3 @@
Een FSM is een 5.65-tuple (gemiddelde over aantal referenties)
Adjunctions don't lift themselves

2
thesis.tex
View file

@ -1,4 +1,4 @@
\environment environment
\startproject thesis
\product main
\product content
\stopproject