Domain > zetzsche.xyz

More information on this domain is in AlienVault OTX

DNS Resolutions

Date	IP Address
2025-09-20	3.5.139.75 (ClassC)
2025-11-01	52.219.47.204 (ClassC)

HTTP/1.1 200 OKx-amz-id-2: D4zmjO9Q7kFG86nbkwv4C/Nkjdn2hxJesdn7UnWPDP+Cy721XTLBhfBScD8iZriroGQA1It+bHYx-amz-request-id: B260VQTNM8T8GCNXDate: Sat, 01 Nov 2025 18:08:11 GMTLast-Modified: Fri, 04 Apr 2025 15:33:01 GMTETag: a2c99adff019577116af626c9630b95cContent-Type: text/htmlContent-Length: 405950Server: AmazonS3

!DOCTYPE html>html>head>meta charsetUTF-8>meta http-equivCache-Control contentno-cache, no-store, must-revalidate />meta http-equivPragma contentno-cache />meta http-equivExpires content0 />style typetext/css>	* { font-family:sans-serif; }	a {                color: blue;                text-decoration: none;        }	span.title { font-weight: bold;	}	div.heading1 {		font-size: 150%;		font-weight: bold;		margin-top: 0.3em;		margin-bottom: 0.3em;	}	div.heading2 {		font-size: 120%;		font-weight: bold;		margin-top: 0.3em;		margin-bottom: 0.3em;		margin-left: 2em;	}	div.heading3 {		font-size: 110%;		font-weight: bold;		margin-top: 0.1em;		margin-bottom: 0.1em;		margin-left: 2em;	}	span.abstractheading {		font-weight: bold;		font-size: 80%;	}		span.award {		font-weight: bold;		font-size: 80%;		color: green;	}	span.linklist {		font-size: 80%;	}	span.coursetitle {		font-style: italic;	}	p {		max-width: 40em;	}	div {		max-width: 40em;	}	ul {	max-width: 40em;	}	div.abstract {		font-size: 80%;	}	div.entry {		margin-left: 4em;	}	div#navigation {		position:fixed;		left: 10px;		top: 100px;	}	body {		margin-left: 10em;	}	pre { font-family: monospace; }	span.backtotop {		display:none;		font-size: 60%;		font-weight: normal;	}		@media handheld, screen and (max-width: 700px) {		div#navigation {			position:static !important;			left: 0 !important;			top: 0 !important;		}                span.backtotop {                        display:inline;                }		body {			margin-left: 0 !important;		}	}/style>!--	div#publications {	}	div#talks{	} -->!--script typetext/javascript   srchttp://cdn.mathjax.org/mathjax/latest/MathJax.js?configTeX-AMS-MML_HTMLorMML>/script>script typetext/x-mathjax-config>MathJax.Hub.Config({  tex2jax: {    inlineMath: $,$, \$,\$,    processEscapes: true  }});/script>-->title>Georg Zetzsche/title>/head>body idtop>div idnavigation>	a href#top>Home/a>br/>	a href#publications>Publications/a>br/>	a href#reviews>Service/a>br/> 	a href#teaching>Teaching/a>br/>	a href#talks>Talks/a>br/>	br/>/div>div classheading1>Georg Zetzsche/div>table>tr>td stylevalign:top;>  b>Mailing address/b>br/>   Georg Zetzschebr/>   Max Planck Institute for Software Systemsbr/>   Paul-Ehrlich Strasse G 26br/>   67663 Kaiserslautern br/>  Germanybr/>b>Email/b>br/>g e o r g (at) m p i - s w s . o r gbr/>b>Mastodon/b>br/>a hrefhttps://chaos.social/@gz relme>@gz@chaos.social/a>br/>/td>td stylewidth:100px;>/td>td stylevertical-align:top;>  b>Physical address/b>br/>  MPI-SWSbr/>  Room 406br/>  Paul-Ehrlich-Str. 26br/>  D-67663 Kaiserslauternbr/>  Germanybr/>/td>/tr>/table>p>Since November 2018, I am a tenure-track faculty member at  the a hrefhttps://www.mpi-sws.org/>Max Planck Institute for  Software Systems (MPI-SWS)/a> in Kaiserslautern, where I head the  Models of Computation group.p>From November 2017 until October 2018, I was a postdocat a hrefhttp://www.irif.fr/>IRIF, UniversitéParis-Diderot/a>, funded by a fellowship ofthe a hrefhttps://www.sciencesmaths-paris.fr/en/>Fondation SciencesMathématiques de Paris/a> and hostedby a hrefhttps://www.irif.fr/~serre/>Olivier Serre/a>.p> From November 2015 until October 2017, I was a postdoc at the ahrefhttp://www.lsv.ens-cachan.fr/>LSV Cachan/a>, funded by a fellowship ofthe a hrefhttps://www.daad.de/>DAAD/a> (German Academic Exchange Service),hosted by a hrefhttp://www.lsv.fr/~phs/>Philippe Schnoebelen/a>, and theproject a hrefhttp://labex-digicosme.fr/Emergence+VERICONISS>VERICONISS/a>by a hrefhttp://www.lsv.fr/~goeller/>Stefan Göller/a>. p>Beforethat, I obtained a PhD with ahrefhttp://www.tcs.cs.tu-bs.de/group/meyer/home.html>Prof. Dr. RolandMeyer/a> in the a hrefhttp://concurrency.cs.uni-kl.de/>Concurrency TheoryGroup/a> in Kaiserslautern.  I defended a href#theses>b>mydissertation/b>/a> on June 19th, 2015. Until December 2010, I studiedComputer Science (with a minor in Mathematics) at Universität Hamburg. p>My research is concerned with b>theoretical foundations of verificationand synthesis/b> of software systems. More specifically, I am interestedin b>decidability and complexity issues of infinite-state systems/b>. Onecurrent focus is synthesis of b>finite-state abstractions ofinfinite-state systems/b> (separability problems, downward closures,Parikh images), which can be used as correctness certificates or asbuilding blocks for decision procedures.p>In addition, I am working on decision problems for b>infinite groups/b>,where I seek to apply methods from verification and gain insights onhow to devise infinite-state models with pleasant analysis properties.p>b>Recent invited talks/b>ul>	li>Invited speaker at a hrefhttps://highlights-conference.org/2024/jewels>Jewels of Automata Theory 2024/a>li>Invited speaker at a hrefhttps://sites.google.com/view/infinite-automata/program>Infinite Automata 2024/a>!--  li>Invited speaker at a hrefhttps://automatha.uni-leipzig.de/2020/>AutoMathA 2020/a>/li> -->  li>Invited speaker at a hrefhttp://rp2021.csc.liv.ac.uk/>RP 2021/a>./ul>p>b>News/b>ul>  li>I feel extremely honored to receive the 2025 a hrefhttps://math.utu.fi/salomaaprize/>Salomaa Prize/a>!  li>I am on the PC of LICS 2026./li>  li>I am on the PC of MFCS 2025./li>  li>I am on the PC of a hrefhttps://events.gwdg.de/event/576/>DLT 2024/a>.  li>I am on the PC of a hrefhttps://compose.ioc.ee/icalp2024/#icalp>ICALP 2024/a>.  li>I am on the PC of a hrefhttps://popl24.sigplan.org/>POPL 2024/a>.  li>My project FINABIS, Finite-state abstractions of infinite-state systems, will be funded by an ERC Starting Grant. Thanks a lot to everyone who gave me advice on the application!   li>I am on the PC of a hrefhttps://lics.siglog.org/lics23/>LICS 2023/a>.  li>Together with Anthony W. Lin, Im organizing the a hrefhttps://theorietag2023.mpi-sws.org>Theorietag 2023/a> on automata and formal languages./li>  li>a hrefhttp://rp2022.mpi-sws.org/>RP 2022/a> will be in Kaiserslautern, please submit!  li>I am on the PC of a hrefhttps://gandalf2022.software.imdea.org/>GandALF 2022/a>.  li>I am on the PC of a hrefhttp://delta.cs.cinvestav.mx/~francisco/Latin22/>LATIN 2022/a>.  li>I am on the PC of a hrefhttps://www.fsttcs.org.in/2021/>FSTTCS 2021/a>.  li>I am on the PC of a hrefhttps://highlights-conference.org/>Highlights 2021/a>.  li>I am on the PC of a hrefhttps://lics.siglog.org/>LICS 2021/a>.  li>I am on the PC of a hrefhttps://www.irif.fr/~rp2020/>RP 2020/a>.  li>I am on the PC of a hrefhttp://mfcs.mff.cuni.cz/2020/>MFCS 2020/a>.  li>I am on the PC of a hrefhttps://stacs2020.sciencesconf.org/>STACS 2020/a>.  li>I am on the PC of a hrefhttp://math.utu.fi/dlt/>DLT 2019/a>.li>I am on the PC of a hrefhttps://community.dur.ac.uk/cie.2019/>CiE 2019/a>./ul>Awards and Grants:ul>li>2025 a hrefhttps://math.utu.fi/salomaaprize/>Salomaa Prize/a>/li>li>EATCS Best Paper Award at a hrefhttps://etaps.org/2023/>ETAPS 2023/a>/li>li>a hrefhttps://doi.org/10.3030/101077902>ERC Starting Grant 2022/a>/li>li>EAPLS Best Paper Award at a hrefhttps://etaps.org/2021/>ETAPS 2021/a>.li>Distinguished Paper Award at a hrefhttps://popl21.sigplan.org/>POPL 2021/a>.li>a hrefhttp://eatcs.org/index.php/dissertation-award>EATCS Distinguished Dissertation Award/a> (see a href#theses>my thesis/a>).li>a hrefhttp://eatcs.org/index.php/best-student-icalp-paper>Best Student Paper Award at ICALP 2015 (Track B)/a>. /ul>Group Members:ul>  li>a hrefhttps://people.mpi-sws.org/~pbaumann>Pascal Baumann/a> (PhD student, October 2019–)/li>  li>a hrefhttp://arg.informatik.uni-kl.de/gruppe/bergstraesser/>Pascal Bergsträßer/a> (PhD student at TU Kaiserslautern, December 2020–), co-advised with a hrefhttps://anthonywlin.github.io/>Anthony W. Lin/a>/li>  li>a hrefhttps://people.mpi-sws.org/~mganardi>Moses Ganardi/a> (PostDoc, May 2020–)/li>	li>a hrefhttps://people.mpi-sws.org/~ckoecher/>Chris Köcher/a> (PostDoc, January 2023–)/li>	li>a hrefhttps://www.mpi-sws.org/people/isaglam/>Irmak Sağlam/a> (PhD student, October 2020–), co-advised with a hrefhttps://wp.mpi-sws.org/akschmuck/>Anne-Kathrin Schmuck/a>/li>    li>a hrefhttps://people.mpi-sws.org/~lschuetze>Lia Schütze/a> (PhD student, December 2020–)/li>   li>Yousef Shakiba (PhD student, August 2022–)/li>/ul>Former Members:ul>  li>a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S Thinniyam/a> (PostDoc, May 2019–April 2020)/li>  !--  li>Yousef Shakiba (Intern, Sharif University, July–September 2019)/li> -->  li>Aneesh Shetty (Intern, IIT Bombay, June–July 2019)/li>  li>Ashwani Anand (Intern, Chennai Mathematical Institute, July 2020–June 2021)/li>  li>Thibault Hilaire (Intern, ENS Paris-Saclay, October 2020–July 2021)/li>/ul>!--Events I attended/will attend:ul>  li>Dagstuhl Seminar on a hrefhttps://www.dagstuhl.de/19131>Algorithmic Problems in Group Theory/a>/li>  li>a hrefhttps://www.cmi.ac.in/~sri/CAALM2019/index.html>CAALM 2019/a>, Chennai/li>li>a hrefhttp://highlights-conference.org/>Highlights 2018/a>, Berlin/li>  li>a hrefhttps://lics.siglog.org/lics18/>LICS 2018/a>, Oxford/li>  li>a hrefhttps://www.mimuw.edu.pl/%7Ewczerwin/SP/>Separability Problems/a> (ICALP 2017 workshop), Warsawli>a hrefhttp://homepages.inf.ed.ac.uk/ptotzke/gregynog/>Gregynog 71717/a>/li>/ul>-->div idpublications>div classheading1>Publicationsspan classbacktotop>  a href#top>back to top/a> /span>/div>		script typetext/javascript>		!--			function toggle(element) {				elementShow  element + -show;				elementHide  element + -hide;				if(document.getElementById(element).style.display  none)					document.getElementById(element).style.display  block;				else					document.getElementById(element).style.display  none;				if(document.getElementById(elementShow).style.display  none)					document.getElementById(elementShow).style.display  inline;				else					document.getElementById(elementShow).style.display  none;				if(document.getElementById(elementHide).style.display  none)					document.getElementById(elementHide).style.display  inline;				else					document.getElementById(elementHide).style.display  none;			}			function toggle1(element) {				if(document.getElementById(element).style.display  none)					document.getElementById(element).style.display  block;				else					document.getElementById(element).style.display  none;			}		//-->		/script>						div classheading2>Accepted/div>br/>div classentry>span classtitle>The Power of Hard Attention Transformers on Data Sequences:		A Formal Language Theoretic Perspective/span>br/>with a hrefhttps://arg.cs.uni-kl.de/gruppe/bergstraesser/>Pascal Bergsträßer/a>, a hrefhttps://people.mpi-sws.org/~ckoecher/>Chris Köcher/a>, and a hrefhttps://anthonywlin.github.io/>Anthony W. Lin/a>br/>Accepted for a hrefhttps://neurips.cc/Conferences/2024 titleThirty-Eighth Annual Conference on Neural Information Processing Systems>NeurIPS 2024/a>br/>span classlinklist idBergstraesserKoecherLinZetzsche2024a-linklist styledisplay:none;>[ span classjsbutton>a idBergstraesserKoecherLinZetzsche2024a-bibtex-show  hrefjavascript:toggle(BergstraesserKoecherLinZetzsche2024a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBergstraesserKoecherLinZetzsche2024a-bibtex-hide hrefjavascript:toggle(BergstraesserKoecherLinZetzsche2024a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | a hrefhttp://arxiv.org/abs/2405.16166 title2405.16166>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(BergstraesserKoecherLinZetzsche2024a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BergstraesserKoecherLinZetzsche2024a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2405.16166 title2405.16166>arXiv/a> ]br/>/span>/noscript>div idBergstraesserKoecherLinZetzsche2024a-bibtex classbibtex styledisplay:none;>pre>@MISC{BergstraesserKoecherLinZetzsche2024a,	AUTHOR		 {Bergstr{\a}{\ss}er, Pascal and K{\o}cher, Chris and Lin, Anthony W. and Zetzsche, Georg},	TITLE		 {The Power of Hard Attention Transformers on Data Sequences:		A Formal Language Theoretic Perspective},	NOTE		 {To appear in Proc. of the Thirty-Eighth Annual Conference on Neural Information Processing Systems (NeurIPS 2024)}}/pre>/div>/div>br/>div classentry>span classtitle>Separability in Büchi VASS and Singly Non-Linear Systems of Inequalities/span>br/>with Pascal Baumann, Eren Keskin, and a hrefhttp://www.tcs.cs.tu-bs.de/group/meyer/home.html>Roland Meyer/a>br/>Accepted for a hrefhttps://compose.ioc.ee/icalp2024/ title51st EATCS International Colloquium on Automata, Languages, and Programming>ICALP 2024/a>br/>span classlinklist idBaumannKeskinMeyerZetzsche2024a-linklist styledisplay:none;>[ span classjsbutton>a idBaumannKeskinMeyerZetzsche2024a-bibtex-show  hrefjavascript:toggle(BaumannKeskinMeyerZetzsche2024a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannKeskinMeyerZetzsche2024a-bibtex-hide hrefjavascript:toggle(BaumannKeskinMeyerZetzsche2024a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(BaumannKeskinMeyerZetzsche2024a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannKeskinMeyerZetzsche2024a.bib>BibTeX/a> ]br/>/span>/noscript>div idBaumannKeskinMeyerZetzsche2024a-bibtex classbibtex styledisplay:none;>pre>@MISC{BaumannKeskinMeyerZetzsche2024a,	AUTHOR		 {Baumann, Pascal and Keskin, Eren and Meyer, Roland and Zetzsche, Georg},	TITLE		 {Separability in B{\u}chi VASS and Singly Non-Linear Systems of Inequalities},	NOTE		 {To appear in Proc. of the 51st EATCS International Colloquium on Automata, Languages, and Programming (ICALP 2024)}}/pre>/div>/div>br/>div classentry>span classtitle>An efficient quantifier elimination procedure for Presburger arithmetic/span>br/>with a hrefhttps://www.cs.ox.ac.uk/people/christoph.haase/>Christoph Haase/a>, a hrefhttps://www.cse.iitb.ac.in/~krishnas/>Krishna S./a>, a hrefhttps://people.mpi-sws.org/~kmadnani/>Khushraj Madnani/a>, and Om Swostik Mishrabr/>Accepted for a hrefhttps://compose.ioc.ee/icalp2024/ title51st EATCS International Colloquium on Automata, Languages, and Programming>ICALP 2024/a>br/>span classlinklist idHaaseMadnaniKrishnaMishraZetzsche2024a-linklist styledisplay:none;>[ span classjsbutton>a idHaaseMadnaniKrishnaMishraZetzsche2024a-bibtex-show  hrefjavascript:toggle(HaaseMadnaniKrishnaMishraZetzsche2024a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idHaaseMadnaniKrishnaMishraZetzsche2024a-bibtex-hide hrefjavascript:toggle(HaaseMadnaniKrishnaMishraZetzsche2024a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(HaaseMadnaniKrishnaMishraZetzsche2024a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/HaaseMadnaniKrishnaMishraZetzsche2024a.bib>BibTeX/a> ]br/>/span>/noscript>div idHaaseMadnaniKrishnaMishraZetzsche2024a-bibtex classbibtex styledisplay:none;>pre>@MISC{HaaseMadnaniKrishnaMishraZetzsche2024a,	AUTHOR		 {Haase, Christoph and S., Krishna and Madnani, Khushraj and Mishra, Om Swostik and Zetzsche, Georg},	TITLE		 {An efficient quantifier elimination procedure for Presburger arithmetic},	NOTE		 {To appear in Proc. of the 51st EATCS International Colloquium on Automata, Languages, and Programming (ICALP 2024)}}/pre>/div>/div>br/>div classentry>span classtitle>Slice closures of indexed languages and word equations with counting constraints/span>br/>with a hrefhttp://www.macs.hw.ac.uk/~lc45/>Laura Ciobanu/a>br/>Accepted for a hrefhttps://lics.siglog.org/lics24/ titleThirty-Ninth Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2024/a>br/>span classlinklist idCiobanuZetzsche2024a-linklist styledisplay:none;>[ span classjsbutton>a idCiobanuZetzsche2024a-bibtex-show  hrefjavascript:toggle(CiobanuZetzsche2024a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idCiobanuZetzsche2024a-bibtex-hide hrefjavascript:toggle(CiobanuZetzsche2024a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(CiobanuZetzsche2024a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/CiobanuZetzsche2024a.bib>BibTeX/a> ]br/>/span>/noscript>div idCiobanuZetzsche2024a-bibtex classbibtex styledisplay:none;>pre>@MISC{CiobanuZetzsche2024a,	AUTHOR		 {Ciobanu, Laura and Zetzsche, Georg},	TITLE		 {Slice closures of indexed languages and word equations with counting constraints},	NOTE		 {To appear in Proc. of the Thirty-Ninth Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2024)}}/pre>/div>/div>br/>div classentry>span classtitle>Verifying unboundedness via amalgamation/span>br/>with a hrefhttps://people.mpi-sws.org/~ashwani/>Ashwani Anand/a>, a hrefhttps://www.irif.fr/en/users/schmitz/index/>Sylvain Schmitz/a>, and a hrefhttps://people.mpi-sws.org/~lschuetze/>Lia Schütze/a>br/>Accepted for a hrefhttps://lics.siglog.org/lics24/ titleThirty-Ninth Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2024/a>br/>span classlinklist idAnandSchmitzSchuetzeZetzsche2024a-linklist styledisplay:none;>[ span classjsbutton>a idAnandSchmitzSchuetzeZetzsche2024a-bibtex-show  hrefjavascript:toggle(AnandSchmitzSchuetzeZetzsche2024a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idAnandSchmitzSchuetzeZetzsche2024a-bibtex-hide hrefjavascript:toggle(AnandSchmitzSchuetzeZetzsche2024a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(AnandSchmitzSchuetzeZetzsche2024a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/AnandSchmitzSchuetzeZetzsche2024a.bib>BibTeX/a> ]br/>/span>/noscript>div idAnandSchmitzSchuetzeZetzsche2024a-bibtex classbibtex styledisplay:none;>pre>@MISC{AnandSchmitzSchuetzeZetzsche2024a,	AUTHOR		 {Anand, Ashwani and Schmitz, Sylvain and Sch{\u}tze, Lia and Zetzsche, Georg},	TITLE		 {Verifying unboundedness via amalgamation},	NOTE		 {To appear in Proc. of the Thirty-Ninth Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2024)}}/pre>/div>/div>br/>div classheading2>Conference contributions/div>br/>div classentry>span classtitle>Directed Regular and Context-Free Languages/span>br/>with a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a> and a hrefhttps://isaglam.github.io/>Irmak Sağlam/a>br/>Proceedings of a hrefhttps://stacs2024.limos.fr/ title41st International Symposium on Theoretical Aspects of Computer Science>STACS 2024/a>br/>span classlinklist idGanardiSaglamZetzsche2024a-linklist styledisplay:none;>[ span classjsbutton>a idGanardiSaglamZetzsche2024a-bibtex-show  hrefjavascript:toggle(GanardiSaglamZetzsche2024a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idGanardiSaglamZetzsche2024a-bibtex-hide hrefjavascript:toggle(GanardiSaglamZetzsche2024a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idGanardiSaglamZetzsche2024a-abstract-show  hrefjavascript:toggle(GanardiSaglamZetzsche2024a-abstract)>Show abstract/a>/span>span classjsbutton>a idGanardiSaglamZetzsche2024a-abstract-hide hrefjavascript:toggle(GanardiSaglamZetzsche2024a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPICS.STACS.2024.36 title10.4230/LIPICS.STACS.2024.36>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(GanardiSaglamZetzsche2024a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/GanardiSaglamZetzsche2024a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPICS.STACS.2024.36 title10.4230/LIPICS.STACS.2024.36>DOI/a> ]br/>/span>/noscript>div classabstract idGanardiSaglamZetzsche2024a-abstract>span classabstractheading>Abstract/span>br/>		We study the problem of deciding whether a given language is directed.  Alanguage $L$ is \emph{directed} if every pair of words in $L$ have a common (scattered)superword in $L$.  Deciding directedness is a fundamental problem in connectionwith ideal decompositions of downward closed sets.% A language $L$ is directed if and only if the ideal%decomposition of $L$s downward closure consists of exactly one ideal.Another motivation is that deciding whether two \emph{directed} context-freelanguages have the same downward closures can be decided in polynomial time,whereas for general context-free languages, this problem is known to be $\coNEXP$-complete.We show that the directedness problem for regular languages, given as NFAs, belongs to$\AC^1$, and thus polynomial time.  Moreover, it is $\NL$-complete for fixedalphabet sizes. Furthermore, we show that for context-free languages,the directedness problem is $\PSPACE$-complete.	/div>script typetext/javascript>document.getElementById(GanardiSaglamZetzsche2024a-abstract).style.displaynone;/script>div idGanardiSaglamZetzsche2024a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{GanardiSaglamZetzsche2024a,	AUTHOR		 {Ganardi, Moses and Salam, Irmak and Zetzsche, Georg},	TITLE		 {Directed Regular and Context-Free Languages},	BOOKTITLE	 {Proc. of the 41st International Symposium on Theoretical Aspects of Computer Science (STACS 2024)},	YEAR		 {2024},	SERIES		 {LIPIcs},	VOLUME		 {289},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	ADDRESS	 {Dagstuhl, Germany},	PAGES		 {36:1--36:20},	DOI		 {10.4230/LIPICS.STACS.2024.36}}/pre>/div>/div>br/>div classentry>span classtitle>Reachability in Continuous Pushdown VASS/span>br/>with a hrefhttps://arbalan96.github.io/>A. R. Balasubramanian/a>, a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a>, and a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Proceedings of a hrefhttps://popl24.sigplan.org/ title51st ACM SIGPLAN Symposium on Principles of Programming Languages>POPL 2024/a>br/>span classlinklist idBalasubramanianMajumdarThinniyamZetzsche2024a-linklist styledisplay:none;>[ span classjsbutton>a idBalasubramanianMajumdarThinniyamZetzsche2024a-bibtex-show  hrefjavascript:toggle(BalasubramanianMajumdarThinniyamZetzsche2024a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBalasubramanianMajumdarThinniyamZetzsche2024a-bibtex-hide hrefjavascript:toggle(BalasubramanianMajumdarThinniyamZetzsche2024a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBalasubramanianMajumdarThinniyamZetzsche2024a-abstract-show  hrefjavascript:toggle(BalasubramanianMajumdarThinniyamZetzsche2024a-abstract)>Show abstract/a>/span>span classjsbutton>a idBalasubramanianMajumdarThinniyamZetzsche2024a-abstract-hide hrefjavascript:toggle(BalasubramanianMajumdarThinniyamZetzsche2024a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2310.16798 title2310.16798>arXiv/a> | a hrefhttp://dx.doi.org/10.1145/3633279 title10.1145/3633279>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BalasubramanianMajumdarThinniyamZetzsche2024a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BalasubramanianMajumdarThinniyamZetzsche2024a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2310.16798 title2310.16798>arXiv/a> | a hrefhttp://dx.doi.org/10.1145/3633279 title10.1145/3633279>DOI/a> ]br/>/span>/noscript>div classabstract idBalasubramanianMajumdarThinniyamZetzsche2024a-abstract>span classabstractheading>Abstract/span>br/>		Pushdown Vector Addition Systems with States (PVASS) consist of finitely many control states, a pushdown stack, and a set of counters that can be incremented and decremented, but not tested for zero.                Whether the reachability problem is decidable for PVASS is a long-standing open problem.                We consider continuous PVASS, which are PVASS with a continuous semantics.                This means, the counter values are rational numbers and whenever a vector is added to the current counter values, this vector is first scaled with an arbitrarily chosen rational factor between zero and one.                We show that reachability in continuous PVASS is NEXPTIME-complete.                Our result is unusually robust: Reachability can be decided in NEXPTIME even if all numbers are specified in binary.                On the other hand, NEXPTIME-hardness already holds for coverability, in fixed dimension, for bounded stack, and even if all numbers are specified in unary.	/div>script typetext/javascript>document.getElementById(BalasubramanianMajumdarThinniyamZetzsche2024a-abstract).style.displaynone;/script>div idBalasubramanianMajumdarThinniyamZetzsche2024a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BalasubramanianMajumdarThinniyamZetzsche2024a,	AUTHOR		 {Balasubramanian, A. R. and Majumdar, Rupak and Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {Reachability in Continuous Pushdown VASS},	BOOKTITLE	 {Proc. of the 51st ACM SIGPLAN Symposium on Principles of Programming Languages (POPL 2024)},	YEAR		 {2024},	PUBLISHER	 {ACM},	ADDRESS	 {USA},	SERIES		 {Proceedings of the ACM on Programming Languages},	DOI		 {10.1145/3633279}}/pre>/div>/div>br/>div classentry>span classtitle>Ramsey Quantifiers in Linear Arithmetics/span>br/>with a hrefhttps://arg.cs.uni-kl.de/gruppe/bergstraesser/>Pascal Bergsträßer/a>, a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>, and a hrefhttps://anthonywlin.github.io/>Anthony W. Lin/a>br/>Proceedings of a hrefhttps://popl24.sigplan.org/ title51st ACM SIGPLAN Symposium on Principles of Programming Languages>POPL 2024/a>br/>span classlinklist idBergstraesserGanardiLinZetzsche2024a-linklist styledisplay:none;>[ span classjsbutton>a idBergstraesserGanardiLinZetzsche2024a-bibtex-show  hrefjavascript:toggle(BergstraesserGanardiLinZetzsche2024a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBergstraesserGanardiLinZetzsche2024a-bibtex-hide hrefjavascript:toggle(BergstraesserGanardiLinZetzsche2024a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBergstraesserGanardiLinZetzsche2024a-abstract-show  hrefjavascript:toggle(BergstraesserGanardiLinZetzsche2024a-abstract)>Show abstract/a>/span>span classjsbutton>a idBergstraesserGanardiLinZetzsche2024a-abstract-hide hrefjavascript:toggle(BergstraesserGanardiLinZetzsche2024a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2311.04031 title2311.04031>arXiv/a> | a hrefhttp://dx.doi.org/10.1145/3632843 title10.1145/3632843>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BergstraesserGanardiLinZetzsche2024a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BergstraesserGanardiLinZetzsche2024a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2311.04031 title2311.04031>arXiv/a> | a hrefhttp://dx.doi.org/10.1145/3632843 title10.1145/3632843>DOI/a> ]br/>/span>/noscript>div classabstract idBergstraesserGanardiLinZetzsche2024a-abstract>span classabstractheading>Abstract/span>br/>	    We study Satisfiability Modulo Theories (SMT) enriched with the so-called    Ramsey quantifiers, which assert the existence of cliques (complete graphs)    in the graph induced by some formulas. The extended framework is known to    have    applications in    proving program termination (in particular, whether a transitive binary    predicate is well-founded), and monadic decomposability of SMT formulas.    Our main result is a new algorithm for eliminating Ramseyquantifiers from three common SMT theories: Linear Integer Arithmetic (LIA),Linear Real Arithmetic (LRA), and Linear Integer Real Arithmetic (LIRA).In particular, if we work only with existentially quantified formulas, then ouralgorithm runs in polynomial time and produces a formula of linear size. Oneimmediate consequence isthat checking well-foundedness of a given formula in the aforementioned theorydefining a transitive predicatecan be straightforwardly handled by highly optimized SMT-solvers. We show also    how this provides a    uniform semi-algorithm for verifying termination and liveness with    completeness guarantee    (in fact, with an optimal computational complexity) for several well-known    classes of    infinite-state systems, which include succinct timed systems, one-counter    systems, and monotonic counter systems.    Another immediate consequence is a solution to an open problem on checking    monadic decomposability of a given relation in quantifier-free fragments of    LRA and LIRA, which is an    important problem in automated reasoning and constraint databases. Our    result immediately implies decidability of this problem with an optimal    complexity (coNP-complete) and enables exploitation of SMT-solvers. It also    provides a termination guarantee for the generic monadic decomposition    algorithm of Veanes et al. for LIA, LRA, and LIRA. We report encouraging    experimental results on a prototype implementation of our algorithms on    micro-benchmarks.	/div>script typetext/javascript>document.getElementById(BergstraesserGanardiLinZetzsche2024a-abstract).style.displaynone;/script>div idBergstraesserGanardiLinZetzsche2024a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BergstraesserGanardiLinZetzsche2024a,	AUTHOR		 {Bergstr{\a}{\ss}er, Pascal and Ganardi, Moses and Lin, Anthony W. and Zetzsche, Georg},	TITLE		 {Ramsey Quantifiers in Linear Arithmetics},	BOOKTITLE	 {Proc. of the 51st ACM SIGPLAN Symposium on Principles of Programming Languages (POPL 2024)},	YEAR		 {2024},	PUBLISHER	 {ACM},	ADDRESS	 {USA},	SERIES		 {Proceedings of the ACM on Programming Languages},	DOI		 {10.1145/3632843}}/pre>/div>/div>br/>div classentry>span classtitle>Regular Separators for VASS Coverability Languages/span>br/>with a hrefhttps://people.mpi-sws.org/~ckoecher/>Chris Köcher/a>br/>Proceedings of a hrefhttp://www.fsttcs.org.in/2023/ title43rd Annual Conference on Foundations of Software Technology and Theoretical Computer Science>FSTTCS 2023/a>br/>span classlinklist idKoecherZetzsche2023a-linklist styledisplay:none;>[ span classjsbutton>a idKoecherZetzsche2023a-bibtex-show  hrefjavascript:toggle(KoecherZetzsche2023a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idKoecherZetzsche2023a-bibtex-hide hrefjavascript:toggle(KoecherZetzsche2023a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idKoecherZetzsche2023a-abstract-show  hrefjavascript:toggle(KoecherZetzsche2023a-abstract)>Show abstract/a>/span>span classjsbutton>a idKoecherZetzsche2023a-abstract-hide hrefjavascript:toggle(KoecherZetzsche2023a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.FSTTCS.2023.15 title10.4230/LIPIcs.FSTTCS.2023.15>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(KoecherZetzsche2023a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/KoecherZetzsche2023a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.FSTTCS.2023.15 title10.4230/LIPIcs.FSTTCS.2023.15>DOI/a> ]br/>/span>/noscript>div classabstract idKoecherZetzsche2023a-abstract>span classabstractheading>Abstract/span>br/>	        We study regular separators of vector addition systems (VASS, for        short) with coverability semantics. A regular language $R$ is a        \emph{regular separator} of languages $K$ and $L$ if $K\subseteq R$ and        $L\cap R\emptyset$. It was shown by Czerwi\{n}ski, Lasota, Meyer,        Muskalla, Kumar, and Saivasan~(CONCUR 2018) that it is decidable        whether, for two given VASS, there exists a regular separator. In fact,        they show that a regular separator exists if and only if the two VASS        languages are disjoint. However, they provide a triply exponential        upper bound and a doubly exponential lower bound for the size of such        separators and leave open which bound is tight.        We show that if two VASS have disjoint languages, then there exists a        regular separator with at most doubly exponential size.  Moreover, we        provide tight size bounds for separators in the case of fixed        dimensions and unary/binary encodings of updates and NFA/DFA        separators. In particular, we settle the aforementioned question.        The key ingredient in the upper bound is a structural analysis of        separating automata based on the concept of \emph{basic separators}, which was        recently introduced by Czerwi\{n}ski and the second author.  This allows us to        determinize (and thus complement) without the powerset construction and avoid one exponential        blowup.	/div>script typetext/javascript>document.getElementById(KoecherZetzsche2023a-abstract).style.displaynone;/script>div idKoecherZetzsche2023a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{KoecherZetzsche2023a,	AUTHOR		 {K{\o}cher, Chris and Zetzsche, Georg},	TITLE		 {Regular Separators for VASS Coverability Languages},	BOOKTITLE	 {Proc. of the 43rd Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS 2023)},	YEAR		 {2023},	SERIES		 {LIPIcs},	VOLUME		 {284},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	ADDRESS	 {Dagstuhl, Germany},	PAGES		 {15:1--15:19},	DOI		 {10.4230/LIPIcs.FSTTCS.2023.15}}/pre>/div>/div>br/>div classentry>span classtitle>Counter Machines With Infrequent Reversals/span>br/>with a hrefhttp://www.lsv.fr/~finkel/>Alain Finkel/a>, a hrefhttps://www.cse.iitb.ac.in/~krishnas/>Krishna S./a>, a hrefhttps://people.mpi-sws.org/~kmadnani/>Khushraj Madnani/a>, and a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a>br/>Proceedings of a hrefhttp://www.fsttcs.org.in/2023/ title43rd Annual Conference on Foundations of Software Technology and Theoretical Computer Science>FSTTCS 2023/a>br/>span classlinklist idFinkelKrishnaMadnaniMajumdarZetzsche2023a-linklist styledisplay:none;>[ span classjsbutton>a idFinkelKrishnaMadnaniMajumdarZetzsche2023a-bibtex-show  hrefjavascript:toggle(FinkelKrishnaMadnaniMajumdarZetzsche2023a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idFinkelKrishnaMadnaniMajumdarZetzsche2023a-bibtex-hide hrefjavascript:toggle(FinkelKrishnaMadnaniMajumdarZetzsche2023a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idFinkelKrishnaMadnaniMajumdarZetzsche2023a-abstract-show  hrefjavascript:toggle(FinkelKrishnaMadnaniMajumdarZetzsche2023a-abstract)>Show abstract/a>/span>span classjsbutton>a idFinkelKrishnaMadnaniMajumdarZetzsche2023a-abstract-hide hrefjavascript:toggle(FinkelKrishnaMadnaniMajumdarZetzsche2023a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.FSTTCS.2023.42 title10.4230/LIPIcs.FSTTCS.2023.42>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(FinkelKrishnaMadnaniMajumdarZetzsche2023a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/FinkelKrishnaMadnaniMajumdarZetzsche2023a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.FSTTCS.2023.42 title10.4230/LIPIcs.FSTTCS.2023.42>DOI/a> ]br/>/span>/noscript>div classabstract idFinkelKrishnaMadnaniMajumdarZetzsche2023a-abstract>span classabstractheading>Abstract/span>br/>		Bounding the number of reversals in a counter machine is one of the most                prominent restrictions to achieve decidability of the reachability problem.                Given this success, we explore whether this notion can be relaxed while                retaining decidability.                To this end, we introduce the notion of an                $f$-reversal-bounded counter machine for a monotone function $f\colon \N\to                \N$. In such a machine, every run of length $n$ makes at most $f(n)$ reversals. Our first main result is a dichotomy theorem:  We show that for every                monotone function $f$, one of the following holds: Either (i)~$f$ grows so                slowly that every $f$-reversal bounded counter machine is already $k$-reversal                bounded for some constant $k$ or (ii)~$f$ belongs to $\Omega(\log(n))$ and                reachability in $f$-reversal bounded counter machines is undecidable. This                shows that classical reversal bounding already captures the decidable cases of                $f$-reversal bounding for any monotone function $f$.  The key technical                ingredient is an analysis of the growth of small solutions of iterated                compositions of Presburger-definable constraints. In our second contribution, we investigate whether imposing $f$-reversal                boundedness improves the complexity of the reachability problem in vector                addition systems with states (VASS).  Here, we obtain an analogous dichotomy:                We show that either (i)~$f$ grows so slowly that every $f$-reversal-bounded VASS is already $k$-reversal-bounded for some constant $k$ or (ii)~$f$ belongs to $\Omega(n)$ and the reachability problem for $f$-reversal-bounded VASS remains Ackermann-complete. This result is proven using run amalgamation in VASS.                Overall, our results imply that classical restriction of reversal boundedness is a robust one.	/div>script typetext/javascript>document.getElementById(FinkelKrishnaMadnaniMajumdarZetzsche2023a-abstract).style.displaynone;/script>div idFinkelKrishnaMadnaniMajumdarZetzsche2023a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{FinkelKrishnaMadnaniMajumdarZetzsche2023a,	AUTHOR		 {Finkel, Alain and S., Krishna and Madnani, Khushraj and Majumdar, Rupak and Zetzsche, Georg},	TITLE		 {Counter Machines With Infrequent Reversals},	BOOKTITLE	 {Proc. of the 43rd Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS 2023)},	YEAR		 {2023},	SERIES		 {LIPIcs},	VOLUME		 {284},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	ADDRESS	 {Dagstuhl, Germany},	PAGES		 {38:1--38:17},	DOI		 {10.4230/LIPIcs.FSTTCS.2023.42}}/pre>/div>/div>br/>div classentry>span classtitle>Priority Downward Closures/span>br/>with a hrefhttps://people.mpi-sws.org/~ashwani/>Ashwani Anand/a>br/>Proceedings of a hrefhttps://www.uantwerpen.be/en/conferences/confest-2023/concur/ title34th International Conference on Concurrency Theory>CONCUR 2023/a>br/>span classlinklist idAnandZetzsche2023a-linklist styledisplay:none;>[ span classjsbutton>a idAnandZetzsche2023a-bibtex-show  hrefjavascript:toggle(AnandZetzsche2023a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idAnandZetzsche2023a-bibtex-hide hrefjavascript:toggle(AnandZetzsche2023a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idAnandZetzsche2023a-abstract-show  hrefjavascript:toggle(AnandZetzsche2023a-abstract)>Show abstract/a>/span>span classjsbutton>a idAnandZetzsche2023a-abstract-hide hrefjavascript:toggle(AnandZetzsche2023a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2307.07460 title2307.07460>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.CONCUR.2023.39 title10.4230/LIPIcs.CONCUR.2023.39>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(AnandZetzsche2023a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/AnandZetzsche2023a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2307.07460 title2307.07460>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.CONCUR.2023.39 title10.4230/LIPIcs.CONCUR.2023.39>DOI/a> ]br/>/span>/noscript>div classabstract idAnandZetzsche2023a-abstract>span classabstractheading>Abstract/span>br/>		When a system sends messages through a lossy channel, then the language encoding all sequences of messages can be abstracted by its downward closure, i.e. the set of all (not necessarily contiguous) subwords. This is useful because even if the system has infinitely many states, its downward closure is a regular language. However, if the channel has congestion control based on priorities assigned to the messages, then we need a finer abstraction: The downward closure with respect to the priority embedding. As for subword-based downward closures, one can also show that these priority downward closures are always regular.While computing finite automata for the subword-based downward closure is well understood, nothing is known in the case of priorities. We initiate the study of this problem and provide algorithms to compute priority downward closures for regular languages, one-counter languages, and context-free languages.	/div>script typetext/javascript>document.getElementById(AnandZetzsche2023a-abstract).style.displaynone;/script>div idAnandZetzsche2023a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{AnandZetzsche2023a,	AUTHOR		 {Anand, Ashwani and Zetzsche, Georg},	TITLE		 {Priority Downward Closures},	BOOKTITLE	 {Proc. of the 34th International Conference on Concurrency Theory (CONCUR 2023)},	YEAR		 {2023},	SERIES		 {LIPIcs},	VOLUME		 {279},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	ADDRESS	 {Dagstuhl, Germany},	PAGES		 {39:1--39:18},	DOI		 {10.4230/LIPIcs.CONCUR.2023.39}}/pre>/div>/div>br/>div classentry>span classtitle>Monus Semantics in Vector Addition Systems with States/span>br/>with Pascal Baumann, a hrefhttps://people.mpi-sws.org/~kmadnani/>Khushraj Madnani/a>, and a hrefhttps://fmazowiecki.github.io/>Filip Mazowiecki/a>br/>Proceedings of a hrefhttps://www.uantwerpen.be/en/conferences/confest-2023/concur/ title34th International Conference on Concurrency Theory>CONCUR 2023/a>br/>span classlinklist idBaumannMadnaniMazowieckiZetzsche2023a-linklist styledisplay:none;>[ span classjsbutton>a idBaumannMadnaniMazowieckiZetzsche2023a-bibtex-show  hrefjavascript:toggle(BaumannMadnaniMazowieckiZetzsche2023a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannMadnaniMazowieckiZetzsche2023a-bibtex-hide hrefjavascript:toggle(BaumannMadnaniMazowieckiZetzsche2023a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBaumannMadnaniMazowieckiZetzsche2023a-abstract-show  hrefjavascript:toggle(BaumannMadnaniMazowieckiZetzsche2023a-abstract)>Show abstract/a>/span>span classjsbutton>a idBaumannMadnaniMazowieckiZetzsche2023a-abstract-hide hrefjavascript:toggle(BaumannMadnaniMazowieckiZetzsche2023a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2308.14926 title2308.14926>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.CONCUR.2023.10 title10.4230/LIPIcs.CONCUR.2023.10>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BaumannMadnaniMazowieckiZetzsche2023a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannMadnaniMazowieckiZetzsche2023a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2308.14926 title2308.14926>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.CONCUR.2023.10 title10.4230/LIPIcs.CONCUR.2023.10>DOI/a> ]br/>/span>/noscript>div classabstract idBaumannMadnaniMazowieckiZetzsche2023a-abstract>span classabstractheading>Abstract/span>br/>		Vector addition systems with states (VASS) are a popular model for concurrent systems. However, many decision problems have prohibitively high complexity. Therefore, it is sometimes useful to consider overapproximating semantics in which these problems can be decided more efficiently.We study an overapproximation, called monus semantics, that slightly relaxes the semantics of decrements: A key property of a vector addition systems is that in order to decrement a counter, this counter must have a positive value. In contrast, our semantics allows decrements of zero-valued counters: If such a transition is executed, the counter just remains zero.It turns out that if only a subset of transitions is used with monus semantics (and the others with classical semantics), then reachability is undecidable. However, we show that if monus semantics is used throughout, reachability remains decidable. In particular, we show that reachability for VASS with monus semantics is as hard as that of classical VASS (i.e. Ackermann-hard), while the zero-reachability and coverability are easier (i.e. EXPSPACE-complete and NP-complete, respectively). We provide a comprehensive account of the complexity of the general reachability problem, reachability of zero configurations, and coverability under monus semantics. We study these problems in general VASS, two-dimensional VASS, and one-dimensional VASS, with unary and binary counter updates.	/div>script typetext/javascript>document.getElementById(BaumannMadnaniMazowieckiZetzsche2023a-abstract).style.displaynone;/script>div idBaumannMadnaniMazowieckiZetzsche2023a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BaumannMadnaniMazowieckiZetzsche2023a,	AUTHOR		 {Baumann, Pascal and Madnani, Khushraj and Mazowiecki, Filip and Zetzsche, Georg},	TITLE		 {Monus Semantics in Vector Addition Systems with States},	BOOKTITLE	 {Proc. of the 34th International Conference on Concurrency Theory (CONCUR 2023)},	YEAR		 {2023},	SERIES		 {LIPIcs},	VOLUME		 {279},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	ADDRESS	 {Dagstuhl, Germany},	PAGES		 {10:1--10:18},	DOI		 {10.4230/LIPIcs.CONCUR.2023.10}}/pre>/div>/div>br/>div classentry>span classtitle>Context-Bounded Analysis of Concurrent Programs (Invited Talk)/span>br/>with Pascal Baumann, a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>, a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a>, and a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Proceedings of a hrefhttps://icalp2023.cs.upb.de/ title50th EATCS International Colloquium on Automata, Languages, and Programming>ICALP 2023/a>br/>span classlinklist idBaumannGanardiMajumdarThinniyamZetzsche2023c-linklist styledisplay:none;>[ span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023c-bibtex-show  hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023c-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023c-bibtex-hide hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023c-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023c-abstract-show  hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023c-abstract)>Show abstract/a>/span>span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023c-abstract-hide hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023c-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2023.3 title10.4230/LIPIcs.ICALP.2023.3>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BaumannGanardiMajumdarThinniyamZetzsche2023c-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannGanardiMajumdarThinniyamZetzsche2023c.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2023.3 title10.4230/LIPIcs.ICALP.2023.3>DOI/a> ]br/>/span>/noscript>div classabstract idBaumannGanardiMajumdarThinniyamZetzsche2023c-abstract>span classabstractheading>Abstract/span>br/>		Context-bounded analysis of concurrent programs is a technique to compute a sequence of under-approximations of all behaviors of the program. For a fixed bound k, a context bounded analysis considers only those runs in which a single process is interrupted at most k times. As k grows, we capture more and more behaviors of the program. Practically, context-bounding has been very effective as a bug-finding tool: many bugs can be found even with small bounds. Theoretically, context-bounded analysis is decidable for a large number of programming models for which verification problems are undecidable. In this paper, we survey some recent work in context-bounded analysis of multithreaded programs.In particular, we show a general decidability result. We study context-bounded reachability in a language-theoretic setup. We fix a class of languages (satisfying some mild conditions) from which each thread is chosen. We show context-bounded safety and termination verification problems are decidable iff emptiness is decidable for the underlying class of languages and context-bounded boundedness is decidable iff finiteness is decidable for the underlying class.	/div>script typetext/javascript>document.getElementById(BaumannGanardiMajumdarThinniyamZetzsche2023c-abstract).style.displaynone;/script>div idBaumannGanardiMajumdarThinniyamZetzsche2023c-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BaumannGanardiMajumdarThinniyamZetzsche2023c,	AUTHOR		 {Baumann, Pascal and Ganardi, Moses and Majumdar, Rupak and Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {Context-Bounded Analysis of Concurrent Programs (Invited Talk)},	BOOKTITLE	 {Proc. of the 50th EATCS International Colloquium on Automata, Languages, and Programming (ICALP 2023)},	YEAR		 {2023},	SERIES		 {LIPIcs},	VOLUME		 {261},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	ADDRESS	 {Dagstuhl, Germany},	PAGES		 {3:1--3:16},	DOI		 {10.4230/LIPIcs.ICALP.2023.3}}/pre>/div>/div>br/>div classentry>span classtitle>Checking Refinement of Asynchronous Programs against Context-Free Specifications/span>br/>with Pascal Baumann, a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>, a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a>, and a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Proceedings of a hrefhttps://icalp2023.cs.upb.de/ title50th EATCS International Colloquium on Automata, Languages, and Programming>ICALP 2023/a>br/>span classlinklist idBaumannGanardiMajumdarThinniyamZetzsche2023b-linklist styledisplay:none;>[ span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023b-bibtex-show  hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023b-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023b-bibtex-hide hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023b-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023b-abstract-show  hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023b-abstract)>Show abstract/a>/span>span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023b-abstract-hide hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023b-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2306.13058 title2306.13058>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2023.110 title10.4230/LIPIcs.ICALP.2023.110>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BaumannGanardiMajumdarThinniyamZetzsche2023b-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannGanardiMajumdarThinniyamZetzsche2023b.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2306.13058 title2306.13058>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2023.110 title10.4230/LIPIcs.ICALP.2023.110>DOI/a> ]br/>/span>/noscript>div classabstract idBaumannGanardiMajumdarThinniyamZetzsche2023b-abstract>span classabstractheading>Abstract/span>br/>		In the language-theoretic approach to refinement verification, we check that thelanguage of traces of an implementation all belong to the language of a specification.We consider the refinement verification problem for asynchronous programs against specifications given by a Dycklanguage.We show that this problem is EXPSPACE-complete---the same complexity as that of language emptiness and forrefinement verification against a regular specification.Our algorithm uses several technical ingredients.First, we show that checking if the coverability language of a succinctly describedvector addition system with states (VASS) is contained in a Dyck languageis EXPSPACE-complete.Second, in the more technical part of the proof, we define an ordering on words and show a downward closure construction thatallows replacing the (context-free) language of each task in an asynchronous program by a regular language.Unlike downward closure operations usually considered in infinite-state verification, our ordering is not a well-quasi-ordering, and we haveto construct the regular language ab initio.Once the tasks can be replaced, we show a reduction to an appropriate VASS and use our first ingredient.In addition to the inherent theoretical interest, refinement verification with Dyck specifications captures commonpractical resource usage patterns based on reference counting, for which few algorithmic techniques were known.	/div>script typetext/javascript>document.getElementById(BaumannGanardiMajumdarThinniyamZetzsche2023b-abstract).style.displaynone;/script>div idBaumannGanardiMajumdarThinniyamZetzsche2023b-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BaumannGanardiMajumdarThinniyamZetzsche2023b,	AUTHOR		 {Baumann, Pascal and Ganardi, Moses and Majumdar, Rupak and Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {Checking Refinement of Asynchronous Programs against Context-Free Specifications},	BOOKTITLE	 {Proc. of the 50th EATCS International Colloquium on Automata, Languages, and Programming (ICALP 2023)},	YEAR		 {2023},	SERIES		 {LIPIcs},	VOLUME		 {261},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	ADDRESS	 {Dagstuhl, Germany},	PAGES		 {110:1--110:20},	DOI		 {10.4230/LIPIcs.ICALP.2023.110}}/pre>/div>/div>br/>div classentry>span classtitle>Unboundedness problems for machines with reversal-bounded counters/span>br/>with Pascal Baumann, a hrefhttps://www1.mat.uniroma1.it/people/dalessandro/index.html>Flavio DAlessandro/a>, a hrefhttps://sites.cs.ucsb.edu/~ibarra/>Oscar Ibarra/a>, a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>, a hrefhttps://www.cs.usask.ca/faculty/mcquillan/>Ian McQuillan/a>, and a hrefhttps://people.mpi-sws.org/~lschuetze/>Lia Schütze/a>br/>Proceedings of a hrefhttps://etaps.org/2023/ title26th International Conference on Foundations of Software Science and Computation Structures>FoSSaCS 2023/a>br/>span classaward>EATCS Best Paper Award at ETAPS 2023/span>br/>span classlinklist idBaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-linklist styledisplay:none;>[ span classjsbutton>a idBaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-bibtex-show  hrefjavascript:toggle(BaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-bibtex-hide hrefjavascript:toggle(BaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-abstract-show  hrefjavascript:toggle(BaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-abstract)>Show abstract/a>/span>span classjsbutton>a idBaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-abstract-hide hrefjavascript:toggle(BaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2301.10198 title2301.10198>arXiv/a> | a hrefhttp://dx.doi.org/10.1007/978-3-031-30829-1\_12 title10.1007/978-3-031-30829-1\_12>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2301.10198 title2301.10198>arXiv/a> | a hrefhttp://dx.doi.org/10.1007/978-3-031-30829-1\_12 title10.1007/978-3-031-30829-1\_12>DOI/a> ]br/>/span>/noscript>div classabstract idBaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-abstract>span classabstractheading>Abstract/span>br/>		 We consider a general class of decision problems concerning formal languages, called ``(one-dimensional) unboundedness predicates, for automata that feature reversal-bounded counters (RBCA). We show that each problem in this class reduces -- non-deterministically in polynomial time -- to the same problem for just finite automata. We also show an analogous reduction for automata that have access to both a pushdown stack and reversal-bounded counters (PRBCA).This allows us to answer several open questions: For example, we show that it is coNP-complete to decide whether a given (P)RBCA language L is bounded, meaning whether there exist words $w_1,\ldots,w_n$ with $L\subseteq w_1^*w_2^*\cdots w_n^*$. For PRBCA, even decidability was open. Our methods also show that there is no language of a (P)RBCA of intermediate growth. This means, the number of words of each length grows either polynomially or exponentially. Part of our proof is likely of independent interest: We show that one can translate an RBCA into a machine with Z-counters in logarithmic space, while preserving the accepted language.	/div>script typetext/javascript>document.getElementById(BaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-abstract).style.displaynone;/script>div idBaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BaumannDAlessandroGanardiIbarraMcQuillenSchuetzeZetzsche2023a,	AUTHOR		 {Baumann, Pascal and DAlessandro, Flavio and Ibarra, Oscar and Ganardi, Moses and McQuillan, Ian and Sch{\u}tze, Lia and Zetzsche, Georg},	TITLE		 {Unboundedness problems for machines with reversal-bounded counters},	BOOKTITLE	 {Proc. of the 26th International Conference on Foundations of Software Science and Computation Structures (FoSSaCS 2023)},	YEAR		 {2023},	SERIES		 {Lecture Notes in Computer Science},	PUBLISHER	 {Springer},	VOLUME		 {13992},	PAGES		 {240--264},	DOI		 {10.1007/978-3-031-30829-1\_12}}/pre>/div>/div>br/>div classentry>span classtitle>Regular Separability in Büchi VASS/span>br/>with Pascal Baumann and a hrefhttp://www.tcs.cs.tu-bs.de/group/meyer/home.html>Roland Meyer/a>br/>Proceedings of a hrefhttps://www.conferences.uni-hamburg.de/event/272/page/153-home title40th International Symposium on Theoretical Aspects of Computer Science>STACS 2023/a>br/>span classlinklist idBaumannMeyerZetzsche2023a-linklist styledisplay:none;>[ span classjsbutton>a idBaumannMeyerZetzsche2023a-bibtex-show  hrefjavascript:toggle(BaumannMeyerZetzsche2023a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannMeyerZetzsche2023a-bibtex-hide hrefjavascript:toggle(BaumannMeyerZetzsche2023a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBaumannMeyerZetzsche2023a-abstract-show  hrefjavascript:toggle(BaumannMeyerZetzsche2023a-abstract)>Show abstract/a>/span>span classjsbutton>a idBaumannMeyerZetzsche2023a-abstract-hide hrefjavascript:toggle(BaumannMeyerZetzsche2023a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2301.11242 title2301.11242>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2023.9 title10.4230/LIPIcs.STACS.2023.9>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BaumannMeyerZetzsche2023a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannMeyerZetzsche2023a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2301.11242 title2301.11242>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2023.9 title10.4230/LIPIcs.STACS.2023.9>DOI/a> ]br/>/span>/noscript>div classabstract idBaumannMeyerZetzsche2023a-abstract>span classabstractheading>Abstract/span>br/>		We study the regular separability problem for Büchi VASS languages: Given two Büchi VASS with languages $L_1$ and $L_2$, check whether there is a regular language that fully contains $L_1$ while remaining disjoint from $L_2$.We show that the problem is decidable in general and PSPACE-complete in the 1-dimensional case, assuming succinct counter updates.The results rely on several arguments.We characterize the set of all regular languages disjoint from $L_2$.Based on this, we derive a (sound and complete) notion of inseparability witnesses, non-regular subsets of $L_1$.Finally, we show how to symbolically represent inseparability witnesses and how to check their existence.	/div>script typetext/javascript>document.getElementById(BaumannMeyerZetzsche2023a-abstract).style.displaynone;/script>div idBaumannMeyerZetzsche2023a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BaumannMeyerZetzsche2023a,	AUTHOR		 {Baumann, Pascal and Meyer, Roland and Zetzsche, Georg},	TITLE		 {Regular Separability in B{\u}chi VASS},	BOOKTITLE	 {Proc. of the 40th International Symposium on Theoretical Aspects of Computer Science (STACS 2023)},	YEAR		 {2023},	SERIES		 {LIPIcs},	VOLUME		 {254},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	ADDRESS	 {Dagstuhl, Germany},	PAGES		 {9:1--9:19},	DOI		 {10.4230/LIPIcs.STACS.2023.9}}/pre>/div>/div>br/>div classentry>span classtitle>Context-Bounded Verification of Context-Free Specifications/span>br/>with Pascal Baumann, a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>, a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a>, and a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Proceedings of a hrefhttps://popl23.sigplan.org/ title50th ACM SIGPLAN Symposium on Principles of Programming Languages>POPL 2023/a>br/>span classlinklist idBaumannGanardiMajumdarThinniyamZetzsche2023a-linklist styledisplay:none;>[ span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023a-bibtex-show  hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023a-bibtex-hide hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023a-abstract-show  hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023a-abstract)>Show abstract/a>/span>span classjsbutton>a idBaumannGanardiMajumdarThinniyamZetzsche2023a-abstract-hide hrefjavascript:toggle(BaumannGanardiMajumdarThinniyamZetzsche2023a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1145/3571266 title10.1145/3571266>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BaumannGanardiMajumdarThinniyamZetzsche2023a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannGanardiMajumdarThinniyamZetzsche2023a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1145/3571266 title10.1145/3571266>DOI/a> ]br/>/span>/noscript>div classabstract idBaumannGanardiMajumdarThinniyamZetzsche2023a-abstract>span classabstractheading>Abstract/span>br/>		A fundamental problem in refinement verification is to check that the language of behaviors of an implementation		is included in the language of the specification.		We consider the refinement verification problem where the implementation is a multithreaded shared memory system		modeled as a multistack pushdown automaton and the specification is an input-deterministic multistack pushdown language.		Our main result shows that the context-bounded refinement problem, where we ask that all behaviors		generated in runs of bounded number of context switches belong to a specification given by a Dyck language,		is decidable and coNP-complete.		The more general case of input-deterministic languages follows, with the same complexity.		Context-bounding is essential since emptiness for multipushdown automata is already undecidable, and so is the refinement verification problem for the subclass		of regular specifications.		Input-deterministic languages capture many non-regular specifications of practical interest and our result opens the way for algorithmic analysis of these properties.		The context-bounded refinement problem is coNP-hard already with deterministic regular specifications;		our result demonstrates that the problem is not harder despite the stronger class of specifications.		Our proof introduces several general techniques for formal languages and counter programs and shows that the search for counterexamples		can be reduced in non-deterministic polynomial time to the satisfiability problem for existential Presburger arithmetic.		These techniques are essential to ensure the coNP upper bound: existing techniques for regular specifications are not powerful enough		for decidability, while simple reductions lead to problems that are either undecidable or have high complexities.		As a special case, our decidability result gives an algorithmic verification technique to reason about		reference counting and re-entrant locking in multithreaded programs.	/div>script typetext/javascript>document.getElementById(BaumannGanardiMajumdarThinniyamZetzsche2023a-abstract).style.displaynone;/script>div idBaumannGanardiMajumdarThinniyamZetzsche2023a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BaumannGanardiMajumdarThinniyamZetzsche2023a,	AUTHOR		 {Baumann, Pascal and Ganardi, Moses and Majumdar, Rupak and Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {Context-Bounded Verification of Context-Free Specifications},	BOOKTITLE	 {Proc. of the 50th ACM SIGPLAN Symposium on Principles of Programming Languages (POPL 2023)},	YEAR		 {2023},	PUBLISHER	 {ACM},	ADDRESS	 {USA},	SERIES		 {Proceedings of the ACM on Programming Languages},	DOI		 {10.1145/3571266}}/pre>/div>/div>br/>div classentry>span classtitle>Membership problems in finite groups/span>br/>with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a> and a hrefhttps://www.eti.uni-siegen.de/ti/mitarbeiter/rosowski/index.html?langdeDaniel>Andreas Rosowski/a>br/>Proceedings of a hrefhttps://ac.tuwien.ac.at/mfcs2022/ title47th International Symposium on Mathematical Foundations of Computer Science>MFCS 2022/a>br/>span classlinklist idLohreyRosowskiZetzsche2022a-linklist styledisplay:none;>[ span classjsbutton>a idLohreyRosowskiZetzsche2022a-bibtex-show  hrefjavascript:toggle(LohreyRosowskiZetzsche2022a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idLohreyRosowskiZetzsche2022a-bibtex-hide hrefjavascript:toggle(LohreyRosowskiZetzsche2022a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idLohreyRosowskiZetzsche2022a-abstract-show  hrefjavascript:toggle(LohreyRosowskiZetzsche2022a-abstract)>Show abstract/a>/span>span classjsbutton>a idLohreyRosowskiZetzsche2022a-abstract-hide hrefjavascript:toggle(LohreyRosowskiZetzsche2022a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2206.11756 title2206.11756>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.MFCS.2022.71 title10.4230/LIPIcs.MFCS.2022.71>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(LohreyRosowskiZetzsche2022a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/LohreyRosowskiZetzsche2022a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2206.11756 title2206.11756>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.MFCS.2022.71 title10.4230/LIPIcs.MFCS.2022.71>DOI/a> ]br/>/span>/noscript>div classabstract idLohreyRosowskiZetzsche2022a-abstract>span classabstractheading>Abstract/span>br/>		We show that the subset sum problem, the knapsack problem and the rational subset membership problem for permutation groups are NP-complete.Concerning the knapsack problem we obtain NP-completeness for every fixed n \geq 3, where n is the number of permutations in the knapsack equation. In other words: membership in products of three cyclic permutation groups is  NP-complete.  This sharpens a result of Luks, which states NP-completeness of the membership problem for products of three abelian permutation groups. We also consider the context-free membership problem in permutation groups and prove that it is PSPACE-complete but NP-complete for a restricted class of context-free grammars where acyclic derivation trees must have constant Horton-Strahler number. Our upper bounds hold for black box groups. The results for context-free membership problemsin permutation groups yield new complexity bounds for various intersection non-emptiness problems for DFAs and a single context-free grammar.	/div>script typetext/javascript>document.getElementById(LohreyRosowskiZetzsche2022a-abstract).style.displaynone;/script>div idLohreyRosowskiZetzsche2022a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{LohreyRosowskiZetzsche2022a,	AUTHOR		 {Lohrey, Markus and Rosowski, Andreas and Zetzsche, Georg},	TITLE		 {Membership problems in finite groups},	BOOKTITLE	 {Proc. of the 47th International Symposium on Mathematical Foundations of Computer Science (MFCS 2022)},	YEAR		 {2022},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	VOLUME		 {241},	ADDRESS	 {Dagstuhl, Germany},	SERIES		 {LIPIcs},	DOI		 {10.4230/LIPIcs.MFCS.2022.71}}/pre>/div>/div>br/>div classentry>span classtitle>Reachability in Bidirected Pushdown VASS/span>br/>with a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>, a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a>, a hrefhttps://cs.au.dk/~pavlogiannis/>Andreas Pavlogiannis/a>, and a hrefhttps://people.mpi-sws.org/~lschuetze/>Lia Schütze/a>br/>Proceedings of a hrefhttps://icalp2022.irif.fr/ title49th EATCS International Colloquium on Automata, Languages, and Programming>ICALP 2022/a>br/>span classlinklist idGanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-linklist styledisplay:none;>[ span classjsbutton>a idGanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-bibtex-show  hrefjavascript:toggle(GanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idGanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-bibtex-hide hrefjavascript:toggle(GanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idGanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-abstract-show  hrefjavascript:toggle(GanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-abstract)>Show abstract/a>/span>span classjsbutton>a idGanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-abstract-hide hrefjavascript:toggle(GanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2022.124 title10.4230/LIPIcs.ICALP.2022.124>DOI/a> | a hrefhttp://arxiv.org/abs/2204.11799 title2204.11799>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(GanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/GanardiMajumdarPavlogiannisSchuetzeZetzsche2022a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2022.124 title10.4230/LIPIcs.ICALP.2022.124>DOI/a> | a hrefhttp://arxiv.org/abs/2204.11799 title2204.11799>arXiv/a> ]br/>/span>/noscript>div classabstract idGanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-abstract>span classabstractheading>Abstract/span>br/>		A pushdown vector addition system with states (PVASS) extends the model of vector addition systems with a pushdown store.		A PVASS is said to be bidirected if every transition (pushing/popping a symbol or modifying a counter)		has an accompanying opposite transition that reverses the effect.		Bidirectedness arises naturally in many models; it can also be seen as a overapproximation of reachability.		We show that the reachability problem for bidirected PVASS is decidable in Ackermann		time and primitive recursive for any fixed dimension.		For the special case of one-dimensional bidirected PVASS, we show reachability is in PSPACE, and in fact in		polynomial time if the stack is polynomially bounded.		Our results are in contrast to the  directed setting, where decidability of reachability is a long-standing open problem already		for one dimensional PVASS, and there is a PSPACE-lower bound already for one-dimenstional PVASS with bounded stack.				The reachability relation in the bidirected (stateless) case is a congruence over N^d.		Our upper bounds exploit saturation techniques over congruences.		In particular, we show novel elementary-time constructions of semilinear representations of congruences generated by finitely many vector pairs.		For the special case of one-dimensional PVASS, we show a  saturation procedure over bounded-size counters.				We complement our upper bound with a TOWER-hardness result for arbitrary dimension and		k-EXPSPACE hardness in dimension 2k+6 using a technique by Lazić and Totzke		to implement iterative exponentiations.	/div>script typetext/javascript>document.getElementById(GanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-abstract).style.displaynone;/script>div idGanardiMajumdarPavlogiannisSchuetzeZetzsche2022a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{GanardiMajumdarPavlogiannisSchuetzeZetzsche2022a,	AUTHOR		 {Ganardi, Moses and Majumdar, Rupak and Pavlogiannis, Andreas and Sch{\u}tze, Lia and Zetzsche, Georg},	TITLE		 {Reachability in Bidirected Pushdown VASS},	BOOKTITLE	 {Proc. of the 49th EATCS International Colloquium on Automata, Languages, and Programming (ICALP 2022)},	YEAR		 {2022},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	VOLUME		 {229},	ADDRESS	 {Dagstuhl, Germany},	SERIES		 {LIPIcs},	DOI		 {10.4230/LIPIcs.ICALP.2022.124}}/pre>/div>/div>br/>div classentry>span classtitle>The complexity of bidirected reachability in valence systems/span>br/>with a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a> and a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a>br/>Proceedings of a hrefhttps://lics.siglog.org/lics22/index.php titleThirty-Seventh Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2022/a>br/>span classlinklist idGanardiMajumdarZetzsche2022a-linklist styledisplay:none;>[ span classjsbutton>a idGanardiMajumdarZetzsche2022a-bibtex-show  hrefjavascript:toggle(GanardiMajumdarZetzsche2022a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idGanardiMajumdarZetzsche2022a-bibtex-hide hrefjavascript:toggle(GanardiMajumdarZetzsche2022a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idGanardiMajumdarZetzsche2022a-abstract-show  hrefjavascript:toggle(GanardiMajumdarZetzsche2022a-abstract)>Show abstract/a>/span>span classjsbutton>a idGanardiMajumdarZetzsche2022a-abstract-hide hrefjavascript:toggle(GanardiMajumdarZetzsche2022a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1145/3531130.3533345 title10.1145/3531130.3533345>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(GanardiMajumdarZetzsche2022a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/GanardiMajumdarZetzsche2022a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1145/3531130.3533345 title10.1145/3531130.3533345>DOI/a> ]br/>/span>/noscript>div classabstract idGanardiMajumdarZetzsche2022a-abstract>span classabstractheading>Abstract/span>br/>		Reachability problems in infinite-state systems are often subject to extremely		high complexity. 		This motivates the investigation of efficient overapproximations, where we add transitions to		obtain a system in which reachability can be decided more easily. We consider		bidirected infinite-state systems, where for every transition there is a		transition with opposite effect.  We study bidirected reachability in the		framework of valence systems, an abstract model featuring finitely many control		states and an infinite-state storage that is specified by a finite graph.		By picking suitable graphs, valence systems can uniformly model counters as in vector addition systems,		pushdowns, integer counters, and combinations thereof.				We provide a comprehensive complexity landscape for bidirected reachability and show that		the complexity drops substantially (often to polynomial		time) from that of general reachability, for almost every storage mechanism		where reachability is known to be decidable.	/div>script typetext/javascript>document.getElementById(GanardiMajumdarZetzsche2022a-abstract).style.displaynone;/script>div idGanardiMajumdarZetzsche2022a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{GanardiMajumdarZetzsche2022a,	AUTHOR		 {Ganardi, Moses and Majumdar, Rupak and Zetzsche, Georg},	TITLE		 {The complexity of bidirected reachability in valence systems},	YEAR		 {2022},	BOOKTITLE	 {Proc. of the Thirty-Seventh Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2022)},	PUBLISHER	 {ACM},	PAGES		 {1--15},	DOI		 {10.1145/3531130.3533345}}/pre>/div>/div>br/>div classentry>span classtitle>Ramsey Quantifiers over Automatic Structures: Complexity and Applications to Verification/span>br/>with a hrefhttps://arg.cs.uni-kl.de/gruppe/bergstraesser/>Pascal Bergsträßer/a>, a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>, and a hrefhttps://anthonywlin.github.io/>Anthony W. Lin/a>br/>Proceedings of a hrefhttps://lics.siglog.org/lics22/index.php titleThirty-Seventh Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2022/a>br/>span classlinklist idBergstraesserGanardiLinZetzsche2022a-linklist styledisplay:none;>[ span classjsbutton>a idBergstraesserGanardiLinZetzsche2022a-bibtex-show  hrefjavascript:toggle(BergstraesserGanardiLinZetzsche2022a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBergstraesserGanardiLinZetzsche2022a-bibtex-hide hrefjavascript:toggle(BergstraesserGanardiLinZetzsche2022a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBergstraesserGanardiLinZetzsche2022a-abstract-show  hrefjavascript:toggle(BergstraesserGanardiLinZetzsche2022a-abstract)>Show abstract/a>/span>span classjsbutton>a idBergstraesserGanardiLinZetzsche2022a-abstract-hide hrefjavascript:toggle(BergstraesserGanardiLinZetzsche2022a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1145/3531130.3533346 title10.1145/3531130.3533346>DOI/a> | a hrefhttp://arxiv.org/abs/2205.09015 title2205.09015>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(BergstraesserGanardiLinZetzsche2022a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BergstraesserGanardiLinZetzsche2022a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1145/3531130.3533346 title10.1145/3531130.3533346>DOI/a> | a hrefhttp://arxiv.org/abs/2205.09015 title2205.09015>arXiv/a> ]br/>/span>/noscript>div classabstract idBergstraesserGanardiLinZetzsche2022a-abstract>span classabstractheading>Abstract/span>br/>		Automatic structures are infinite structures that are finitely represented by		synchronized finite-state automata. This paper concerns specifically automatic		structures over finite words and trees (ranked/unranked).		We investigate the ``directed version of Ramsey quantifiers, which		express the existence of an infinite  directed clique. This subsumes the standard		``undirected version of Ramsey quantifiers.		Interesting connections between Ramsey quantifiers and two problems in verification		are firstly observed:		(1) reachability with Büchi and generalized Büchi conditions in regular		model checking can be seen as Ramsey quantification over transitive automatic		graphs (i.e. whose edge relations are transitive), (2) checking monadic		decomposability (a.k.a. recognizability) of automatic relations can be		viewed as Ramsey quantification		over co-transitive automatic graphs (i.e. the complements of whose edge		relations are transitive). We provide a comprehensive complexity		landscape of Ramsey quantifiers in these three cases (general, transitive,		co-transitive), all between NL and EXP. In turn, this yields a		wealth of new results with precise complexity, e.g., verification of subtree/flat prefix rewriting, as well as monadic		decomposability over tree-automatic relations. 		We also obtain substantially simpler proofs, e.g., for NL complexity for monadic		decomposability over word-automatic relations (given by DFAs).	/div>script typetext/javascript>document.getElementById(BergstraesserGanardiLinZetzsche2022a-abstract).style.displaynone;/script>div idBergstraesserGanardiLinZetzsche2022a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BergstraesserGanardiLinZetzsche2022a,	AUTHOR		 {Bergstr{\a}{\ss}er, Pascal and Ganardi, Moses and Lin, Anthony W. and Zetzsche, Georg},	TITLE		 {Ramsey Quantifiers over Automatic Structures: Complexity and Applications to Verification},	YEAR		 {2022},	BOOKTITLE	 {Proc. of the Thirty-Seventh Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2022)},	PUBLISHER	 {ACM},	PAGES		 {1--14},	DOI		 {10.1145/3531130.3533346}}/pre>/div>/div>br/>div classentry>span classtitle>Existential definability over the subword ordering/span>br/>with Pascal Baumann, a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>, and a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Proceedings of a hrefhttps://stacs2022.sciencesconf.org title39th International Symposium on Theoretical Aspects of Computer Science>STACS 2022/a>br/>span classlinklist idBaumannGanardiThinniyamZetzsche2022a-linklist styledisplay:none;>[ span classjsbutton>a idBaumannGanardiThinniyamZetzsche2022a-bibtex-show  hrefjavascript:toggle(BaumannGanardiThinniyamZetzsche2022a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannGanardiThinniyamZetzsche2022a-bibtex-hide hrefjavascript:toggle(BaumannGanardiThinniyamZetzsche2022a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBaumannGanardiThinniyamZetzsche2022a-abstract-show  hrefjavascript:toggle(BaumannGanardiThinniyamZetzsche2022a-abstract)>Show abstract/a>/span>span classjsbutton>a idBaumannGanardiThinniyamZetzsche2022a-abstract-hide hrefjavascript:toggle(BaumannGanardiThinniyamZetzsche2022a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2022.7 title10.4230/LIPIcs.STACS.2022.7>DOI/a> | a hrefhttp://arxiv.org/abs/2210.15642 title2210.15642>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(BaumannGanardiThinniyamZetzsche2022a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannGanardiThinniyamZetzsche2022a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2022.7 title10.4230/LIPIcs.STACS.2022.7>DOI/a> | a hrefhttp://arxiv.org/abs/2210.15642 title2210.15642>arXiv/a> ]br/>/span>/noscript>div classabstract idBaumannGanardiThinniyamZetzsche2022a-abstract>span classabstractheading>Abstract/span>br/>		We study first-order logic (FO) over the structure consisting of finite words		over some alphabet~$A$, together with the (non-contiguous) subword ordering.		In terms of decidability of quantifier alternation fragments, this logic is		well-understood: If every word is available as a constant, then even the		$\Sigma_1$ (i.e.\ existential) fragment is undecidable, already for binary		alphabets $A$.				However, up to now, little is known about the expressiveness of the		quantifier alternation fragments: For example, the undecidability proof for		the existential fragment relies on Diophantine equations and only		shows that recursively enumerable languages over a singleton alphabet (and		some auxiliary predicates) are definable.				We show that if $|A|\ge 3$, then a relation is definable in the existential		fragment over $A$ with constants if and only if it is recursively enumerable.		This implies characterizations for all fragments~$\Sigma_i$: If $|A|\ge 3$,		then a relation is definable in $\Sigma_i$ if and only if it belongs to the		$i$-th level of the arithmetical hierarchy.  In addition, our result yields		an analogous complete description of the $\Sigma_i$-fragments for $i\ge 2$ of		the pure logic, where the words of $A^*$ are not available as		constants.	/div>script typetext/javascript>document.getElementById(BaumannGanardiThinniyamZetzsche2022a-abstract).style.displaynone;/script>div idBaumannGanardiThinniyamZetzsche2022a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BaumannGanardiThinniyamZetzsche2022a,	AUTHOR		 {Baumann, Pascal and Ganardi, Moses and Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {Existential definability over the subword ordering},	BOOKTITLE	 {Proc. of the 39th International Symposium on Theoretical Aspects of Computer Science (STACS 2022)},	YEAR		 {2022},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	VOLUME		 {219},	ADDRESS	 {Dagstuhl, Germany},	SERIES		 {LIPIcs},	DOI		 {10.4230/LIPIcs.STACS.2022.7}}/pre>/div>/div>br/>div classentry>span classtitle>Context-Bounded Verification of Thread Pools/span>br/>with Pascal Baumann, a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a>, and a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Proceedings of a hrefhttps://popl22.sigplan.org/ title49th ACM SIGPLAN Symposium on Principles of Programming Languages>POPL 2022/a>br/>span classlinklist idBaumannMajumdarThinniyamZetzsche2022a-linklist styledisplay:none;>[ span classjsbutton>a idBaumannMajumdarThinniyamZetzsche2022a-bibtex-show  hrefjavascript:toggle(BaumannMajumdarThinniyamZetzsche2022a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannMajumdarThinniyamZetzsche2022a-bibtex-hide hrefjavascript:toggle(BaumannMajumdarThinniyamZetzsche2022a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBaumannMajumdarThinniyamZetzsche2022a-abstract-show  hrefjavascript:toggle(BaumannMajumdarThinniyamZetzsche2022a-abstract)>Show abstract/a>/span>span classjsbutton>a idBaumannMajumdarThinniyamZetzsche2022a-abstract-hide hrefjavascript:toggle(BaumannMajumdarThinniyamZetzsche2022a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1145/3498678 title10.1145/3498678>DOI/a> | a hrefhttp://arxiv.org/abs/2111.09022 title2111.09022>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(BaumannMajumdarThinniyamZetzsche2022a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannMajumdarThinniyamZetzsche2022a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1145/3498678 title10.1145/3498678>DOI/a> | a hrefhttp://arxiv.org/abs/2111.09022 title2111.09022>arXiv/a> ]br/>/span>/noscript>div classabstract idBaumannMajumdarThinniyamZetzsche2022a-abstract>span classabstractheading>Abstract/span>br/>Thread pooling is a common programming idiom in which a fixed set of worker threadsare maintained to execute tasks concurrently.The workers repeatedly pick tasks and execute them to completion.Each task is sequential, with possibly recursive code, and taskscommunicate over shared memory.Executing a task can lead to more new tasks being spawned.We consider the safety verification problem for thread-pooled programs.We parameterize the problem with two parameters:the size of the thread pool as well as the number of context switches for each task.The size of the thread pool determines the number of workers running concurrently.The number of context switches determines how many times a worker can be swapped out while executinga single task---like many verification problems for multithreaded recursive programs, the context bounding is importantfor decidability.We show that the safety verification problem for thread-pooled, context-bounded, Boolean programsis EXPSPACE-complete, even if the size of the thread pool and the context bound are given in binary.Our main result, the EXPSPACE upper bound, is derived using a sequence of newsuccinct encoding techniques of independent language-theoretic interest.In particular, we show a polynomial-time construction of downward closuresof languages accepted by succinct pushdown automata as doubly succinct nondeterministic finite automata.While there are explicit doubly exponential lower bounds on the size of nondeterministicfinite automata accepting the downward closure, our result shows these automata can be compressed.We show that thread pooling significantly reduces computational power:in contrast, if only the context bound is provided in binary, but thereis no thread pooling, the safety verification problem becomes 3EXPSPACE-complete.Given the high complexity lower bounds of related problems involving binary parameters,the relatively low complexity of safety verification with thread-pooling comes as a surprise.  /div>script typetext/javascript>document.getElementById(BaumannMajumdarThinniyamZetzsche2022a-abstract).style.displaynone;/script>div idBaumannMajumdarThinniyamZetzsche2022a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BaumannMajumdarThinniyamZetzsche2022a,	AUTHOR		 {Baumann, Pascal and Majumdar, Rupak and Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {Context-Bounded Verification of Thread Pools},	BOOKTITLE	 {Proc. of the 49th ACM SIGPLAN Symposium on Principles of Programming Languages (POPL 2022)},	YEAR		 {2022},	PUBLISHER	 {ACM},	ADDRESS	 {USA},	SERIES		 {Proceedings of the ACM on Programming Languages},	DOI		 {10.1145/3498678}}/pre>/div>/div>br/>div classentry>span classtitle>Recent Advances on Reachability Problems for Valence Systems (Invited Talk)/span>br/>Proceedings of a hrefhttps://rp2021.csc.liv.ac.uk/ title15th International Conference on Reachability Problems>RP 2021/a>br/>span classlinklist idZetzsche2021a-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2021a-bibtex-show  hrefjavascript:toggle(Zetzsche2021a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2021a-bibtex-hide hrefjavascript:toggle(Zetzsche2021a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2021a-abstract-show  hrefjavascript:toggle(Zetzsche2021a-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2021a-abstract-hide hrefjavascript:toggle(Zetzsche2021a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1007/978-3-030-89716-1_4 title10.1007/978-3-030-89716-1_4>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2021a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2021a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1007/978-3-030-89716-1_4 title10.1007/978-3-030-89716-1_4>DOI/a> ]br/>/span>/noscript>div classabstract idZetzsche2021a-abstract>span classabstractheading>Abstract/span>br/>        Valence systems are an abstract model of computation that consists of a finite-state control and some storage mechanism. In contrast to traditional models, the storage mechanism is not fixed, but given as a parameter. This allows us to precisely state questions like: For which storage mechanisms is the reachability problem decidable?This survey reports on recent results that aim to understand the impact of the storage mechanism on decidability and complexity of several variants of the reachability problem. The considered problems are configuration reachability, model-checking first-order logic with reachability, and reachability under bounded context switching and scope-boundedness.  /div>script typetext/javascript>document.getElementById(Zetzsche2021a-abstract).style.displaynone;/script>div idZetzsche2021a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{Zetzsche2021a,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {Recent Advances on Reachability Problems for Valence Systems (Invited Talk)},	BOOKTITLE	 {Proc. of the 15th International Conference on Reachability Problems (RP 2021)},	YEAR		 {2021},	PUBLISHER	 {Springer},	ADDRESS	 {Cham},	PAGES		 {52--65},	SERIES		 {Lecture Notes in Computer Science},	VOLUME		 {13035},	DOI		 {10.1007/978-3-030-89716-1_4}}/pre>/div>/div>br/>div classentry>span classtitle>    General Decidability Results for Asynchronous Shared-Memory Programs: Higher-Order and Beyond  /span>br/>with a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a> and a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Proceedings of a hrefhttps://etaps.org/2021/tacas title27th International Conference on Tools and Algorithms for the Construction and Analysis of Systems>TACAS 2021/a>br/>span classaward>EAPLS Best Paper Award at ETAPS 2021/span>br/>span classlinklist idMajumdarThinniyamZetzsche2021a-linklist styledisplay:none;>[ span classjsbutton>a idMajumdarThinniyamZetzsche2021a-bibtex-show  hrefjavascript:toggle(MajumdarThinniyamZetzsche2021a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idMajumdarThinniyamZetzsche2021a-bibtex-hide hrefjavascript:toggle(MajumdarThinniyamZetzsche2021a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idMajumdarThinniyamZetzsche2021a-abstract-show  hrefjavascript:toggle(MajumdarThinniyamZetzsche2021a-abstract)>Show abstract/a>/span>span classjsbutton>a idMajumdarThinniyamZetzsche2021a-abstract-hide hrefjavascript:toggle(MajumdarThinniyamZetzsche2021a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2101.08611 title2101.08611>arXiv/a> | a hrefhttp://dx.doi.org/10.1007/978-3-030-72016-2_24 title10.1007/978-3-030-72016-2_24>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(MajumdarThinniyamZetzsche2021a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/MajumdarThinniyamZetzsche2021a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2101.08611 title2101.08611>arXiv/a> | a hrefhttp://dx.doi.org/10.1007/978-3-030-72016-2_24 title10.1007/978-3-030-72016-2_24>DOI/a> ]br/>/span>/noscript>div classabstract idMajumdarThinniyamZetzsche2021a-abstract>span classabstractheading>Abstract/span>br/>       The model of asynchronous programming arises in many contexts,       from low-level systems software to high-level web programming.       We take a language-theoretic perspective and show general       decidability and undecidabilit y results for asynchronous       programs that capture all known results as well as show       decidability of new and important classes.  As a main       consequence, we show decidability of safety, termination and       boundedness verification for \emph{higher-order} asynchronous       programs---such as OCaml programs using Lwt---and       undecidability of liveness verification already for order-2       asynchronous programs.  We show that, surprisingly, safety and       termination verification of asynchronous programs with handlers       from a language class are decidable \emph{if{}f} emptiness is       decidable for the underlying language class.       Moreover, we show that configuration reachability and liveness       (fair termination) verification are equivalent, and       decidability of these problems implies decidability of the       well-known ``equal-letters problem on languages.  Our results       close the decidability frontier for asynchronous programs.  /div>script typetext/javascript>document.getElementById(MajumdarThinniyamZetzsche2021a-abstract).style.displaynone;/script>div idMajumdarThinniyamZetzsche2021a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{MajumdarThinniyamZetzsche2021a,	AUTHOR		 {Majumdar, Rupak and Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {    General Decidability Results for Asynchronous Shared-Memory Programs: Higher-Order and Beyond  },	BOOKTITLE	 {Proc. of the 27th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS 2021)},	YEAR		 {2021},	PUBLISHER	 {Springer},	ADDRESS	 {Cham},	SERIES		 {Lecture Notes in Computer Science},	VOLUME		 {12651},	DOI		 {10.1007/978-3-030-72016-2_24}}/pre>/div>/div>br/>div classentry>span classtitle>Scope-Bounded Reachability in Valence Systems/span>br/>with Aneesh Shetty and a hrefhttps://www.cse.iitb.ac.in/~krishnas/>Krishna S./a>br/>Proceedings of a hrefhttps://qonfest2021.lacl.fr/concur21.php title32nd International Conference on Concurrency Theory>CONCUR 2021/a>br/>span classlinklist idShettyKrishnaZetzsche2021a-linklist styledisplay:none;>[ span classjsbutton>a idShettyKrishnaZetzsche2021a-bibtex-show  hrefjavascript:toggle(ShettyKrishnaZetzsche2021a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idShettyKrishnaZetzsche2021a-bibtex-hide hrefjavascript:toggle(ShettyKrishnaZetzsche2021a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idShettyKrishnaZetzsche2021a-abstract-show  hrefjavascript:toggle(ShettyKrishnaZetzsche2021a-abstract)>Show abstract/a>/span>span classjsbutton>a idShettyKrishnaZetzsche2021a-abstract-hide hrefjavascript:toggle(ShettyKrishnaZetzsche2021a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.CONCUR.2021.29 title10.4230/LIPIcs.CONCUR.2021.29>DOI/a> | a hrefhttp://arxiv.org/abs/2108.00963 title2108.00963>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(ShettyKrishnaZetzsche2021a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/ShettyKrishnaZetzsche2021a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.CONCUR.2021.29 title10.4230/LIPIcs.CONCUR.2021.29>DOI/a> | a hrefhttp://arxiv.org/abs/2108.00963 title2108.00963>arXiv/a> ]br/>/span>/noscript>div classabstract idShettyKrishnaZetzsche2021a-abstract>span classabstractheading>Abstract/span>br/>	   Multi-pushdown systems are a standard model for concurrent recursive programs, but they have an undecidable reachability problem. Therefore, there have been several proposals to underapproximate their sets of runs so that reachability in this underapproximation becomes decidable. One such underapproximation that covers a relatively high portion of runs is scope boundedness. In such a run, after each push to stack i, the corresponding pop operation must come within a bounded number of visits to stack i.In this work, we generalize this approach to a large class of infinite-state systems. For this, we consider the model of valence systems, which consist of a finite-state control and an infinite-state storage mechanism that is specified by a finite undirected graph. This framework captures pushdowns, vector addition systems, integer vector addition systems, and combinations thereof. For this framework, we propose a notion of scope boundedness that coincides with the classical notion when the storage mechanism happens to be a multi-pushdown.We show that with this notion, reachability can be decided in PSPACE for every storage mechanism in the framework. Moreover, we describe the full complexity landscape of this problem across all storage mechanisms, both in the case of (i) the scope bound being given as input and (ii) for fixed scope bounds. Finally, we provide an almost complete description of the complexity landscape if even a description of the storage mechanism is part of the input.  /div>script typetext/javascript>document.getElementById(ShettyKrishnaZetzsche2021a-abstract).style.displaynone;/script>div idShettyKrishnaZetzsche2021a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{ShettyKrishnaZetzsche2021a,	AUTHOR		 {Shetty, Aneesh and S., Krishna and Zetzsche, Georg},	TITLE		 {Scope-Bounded Reachability in Valence Systems},	YEAR		 {2021},	BOOKTITLE	 {Proc. of the 32nd International Conference on Concurrency Theory (CONCUR 2021)},	YEAR		 {2021},	SERIES		 {LIPIcs},	VOLUME		 {118},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},	DOI		 {10.4230/LIPIcs.CONCUR.2021.29}}/pre>/div>/div>br/>div classentry>span classtitle>A characterization of wreath products where knapsack is decidable/span>br/>with a hrefhttps://arg.cs.uni-kl.de/gruppe/bergstraesser/>Pascal Bergsträßer/a> and a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>br/>Proceedings of a hrefhttps://stacs2021.saarland-informatics-campus.de/ title38th International Symposium on Theoretical Aspects of Computer Science>STACS 2021/a>br/>span classlinklist idBergstraesserGanardiZetzsche2021a-linklist styledisplay:none;>[ span classjsbutton>a idBergstraesserGanardiZetzsche2021a-bibtex-show  hrefjavascript:toggle(BergstraesserGanardiZetzsche2021a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBergstraesserGanardiZetzsche2021a-bibtex-hide hrefjavascript:toggle(BergstraesserGanardiZetzsche2021a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBergstraesserGanardiZetzsche2021a-abstract-show  hrefjavascript:toggle(BergstraesserGanardiZetzsche2021a-abstract)>Show abstract/a>/span>span classjsbutton>a idBergstraesserGanardiZetzsche2021a-abstract-hide hrefjavascript:toggle(BergstraesserGanardiZetzsche2021a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2021.11 title10.4230/LIPIcs.STACS.2021.11>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BergstraesserGanardiZetzsche2021a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BergstraesserGanardiZetzsche2021a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2021.11 title10.4230/LIPIcs.STACS.2021.11>DOI/a> ]br/>/span>/noscript>div classabstract idBergstraesserGanardiZetzsche2021a-abstract>span classabstractheading>Abstract/span>br/>  The knapsack problem for groups was introduced by Miasnikov,  Nikolaev, and Ushakov. It is defined for each finitely generated  group $G$ and takes as input group elements  $g_1,\ldots,g_n,g\in G$ and asks whether there are  $x_1,\ldots,x_n\ge 0$ with $g_1^{x_1}\cdots  g_n^{x_n}g$. We study the knapsack problem for wreath products  $G\wr H$ of groups $G$ and $H$.    Our main result is a characterization of those wreath products  $G\wr H$ for which the knapsack problem is decidable. The  characterization is in terms of decidability properties of the  indiviual factors $G$ and $H$.  To this end, we introduce two  decision problems, the \emph{intersection knapsack problem} and its  restriction, the \emph{positive intersection knapsack problem}.  Moreover, we apply our main result to $H_3(\Z)$, the discrete  Heisenberg group, and to Baumslag-Solitar groups $\BS(1,q)$ for  $q\ge 1$. First, we show that the knapsack problem is undecidable  for $G\wr H_3(\Z)$ for any $G\ne 1$. This implies that for $G\ne 1$  and for infinite and virtually nilpotent groups $H$, the knapsack  problem for $G\wr H$ is decidable if and only if $H$ is virtually  abelian and solvability of systems of exponent equations is  decidable for $G$. Second, we show that the knapsack problem is  decidable for $G\wr\BS(1,q)$ if and only if solvability of systems  of exponent equations is decidable for $G$.  /div>script typetext/javascript>document.getElementById(BergstraesserGanardiZetzsche2021a-abstract).style.displaynone;/script>div idBergstraesserGanardiZetzsche2021a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BergstraesserGanardiZetzsche2021a,	AUTHOR		 {Bergstr{\a}{\ss}er, Pascal and Ganardi, Moses and Zetzsche, Georg},	TITLE		 {A characterization of wreath products where knapsack is decidable},	BOOKTITLE	 {Proc. of the 38th International Symposium on Theoretical Aspects of Computer Science (STACS 2021)},	YEAR		 {2021},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	VOLUME		 {187},	ADDRESS	 {Dagstuhl, Germany},	SERIES		 {LIPIcs},	DOI		 {10.4230/LIPIcs.STACS.2021.11}}/pre>/div>/div>br/>div classentry>span classtitle>Context-Bounded Verification of Liveness Properties for Multithreaded Shared-Memory Programs/span>br/>with Pascal Baumann, a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a>, and a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Proceedings of a hrefhttps://popl21.sigplan.org/ title48th ACM SIGPLAN Symposium on Principles of Programming Languages>POPL 2021/a>br/>span classaward>Distinguished Paper Award/span>br/>span classlinklist idBaumannMajumdarThinniyamZetzsche2021a-linklist styledisplay:none;>[ span classjsbutton>a idBaumannMajumdarThinniyamZetzsche2021a-bibtex-show  hrefjavascript:toggle(BaumannMajumdarThinniyamZetzsche2021a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannMajumdarThinniyamZetzsche2021a-bibtex-hide hrefjavascript:toggle(BaumannMajumdarThinniyamZetzsche2021a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBaumannMajumdarThinniyamZetzsche2021a-abstract-show  hrefjavascript:toggle(BaumannMajumdarThinniyamZetzsche2021a-abstract)>Show abstract/a>/span>span classjsbutton>a idBaumannMajumdarThinniyamZetzsche2021a-abstract-hide hrefjavascript:toggle(BaumannMajumdarThinniyamZetzsche2021a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1145/3434325 title10.1145/3434325>DOI/a> | a hrefhttp://arxiv.org/abs/2011.04581 title2011.04581>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(BaumannMajumdarThinniyamZetzsche2021a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannMajumdarThinniyamZetzsche2021a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1145/3434325 title10.1145/3434325>DOI/a> | a hrefhttp://arxiv.org/abs/2011.04581 title2011.04581>arXiv/a> ]br/>/span>/noscript>div classabstract idBaumannMajumdarThinniyamZetzsche2021a-abstract>span classabstractheading>Abstract/span>br/>    We study context-bounded verification of liveness properties of    multi-threaded, shared-memory programs, where each thread can    spawn additional threads.  Our main result shows that    context-bounded fair termination is decidable for the model;    context-bounded implies that each spawned thread can be context    switched a fixed constant number of times.  Our proof is    technical, since fair termination requires reasoning about the    composition of unboundedly many threads each with unboundedly    large stacks.  In fact, techniques for related problems, which    depend crucially on replacing the pushdown threads with    finite-state threads, are not applicable.  Instead, we introduce    an extension of vector addition systems with states (VASS), called    VASS with balloons (VASSB), as an intermediate model; it is an    infinite-state model of independent interest.  A VASSB allows    tokens that are themselves markings (balloons).  We show that    context bounded fair termination reduces to fair termination for    VASSB.  We show the latter problem is decidable by showing a    series of reductions: from fair termination to configuration    reachability for VASSB and thence to the reachability problem for    VASS.  For a lower bound, fair termination is known to be    non-elementary already in the special case where threads run to    completion (no context switches).    We also show that the simpler problem of context-bounded    termination is 2EXPSPACE-complete, matching the complexity    bound---and indeed the techniques---for safety verification.    Additionally, we show the related problem of \emph{fair    starvation}, which checks if some thread can be starved along a    fair run, is also decidable in the context-bounded case.  The    decidability employs an intricate reduction from fair starvation    to fair termination.  Like fair termination, this problem is also    non-elementary.  /div>script typetext/javascript>document.getElementById(BaumannMajumdarThinniyamZetzsche2021a-abstract).style.displaynone;/script>div idBaumannMajumdarThinniyamZetzsche2021a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BaumannMajumdarThinniyamZetzsche2021a,	AUTHOR		 {Baumann, Pascal and Majumdar, Rupak and Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {Context-Bounded Verification of Liveness Properties for Multithreaded Shared-Memory Programs},	BOOKTITLE	 {Proc. of the 48th ACM SIGPLAN Symposium on Principles of Programming Languages (POPL 2021)},	YEAR		 {2021},	PUBLISHER	 {ACM},	ADDRESS	 {USA},	SERIES		 {Proceedings of the ACM on Programming Languages},	DOI		 {10.1145/3434325}}/pre>/div>/div>br/>div classentry>span classtitle>Knapsack and the power word problem in solvable Baumslag-Solitar groups/span>br/>with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>br/>Proceedings of a hrefhttp://mfcs.mff.cuni.cz/2020/ title45th International Symposium on Mathematical Foundations of Computer Science>MFCS 2020/a>br/>span classlinklist idLohreyZetzsche2020a-linklist styledisplay:none;>[ span classjsbutton>a idLohreyZetzsche2020a-bibtex-show  hrefjavascript:toggle(LohreyZetzsche2020a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idLohreyZetzsche2020a-bibtex-hide hrefjavascript:toggle(LohreyZetzsche2020a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | a hrefhttp://arxiv.org/abs/2002.03837 title2002.03837>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.MFCS.2020.67 title10.4230/LIPIcs.MFCS.2020.67>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(LohreyZetzsche2020a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/LohreyZetzsche2020a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2002.03837 title2002.03837>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.MFCS.2020.67 title10.4230/LIPIcs.MFCS.2020.67>DOI/a> ]br/>/span>/noscript>div idLohreyZetzsche2020a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{LohreyZetzsche2020a,	AUTHOR		 {Lohrey, Markus and Zetzsche, Georg},	TITLE		 {Knapsack and the power word problem in solvable Baumslag-Solitar groups},	YEAR		 {2020},	BOOKTITLE	 {Proc. of the 45th International Symposium on Mathematical Foundations of Computer Science (MFCS 2020)},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	VOLUME		 {170},	ADDRESS	 {Dagstuhl, Germany},	SERIES		 {LIPIcs},	DOI		 {10.4230/LIPIcs.MFCS.2020.67}}/pre>/div>/div>br/>div classentry>span classtitle>The complexity of bounded context switching with dynamic thread creation/span>br/>with Pascal Baumann, a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a>, and a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Proceedings of a hrefhttps://icalp2020.saarland-informatics-campus.de/ title47th International Colloquium on Automata, Languages, and Programming>ICALP 2020/a>br/>span classlinklist idBaumannMajumdarThinniyamZetzsche2020a-linklist styledisplay:none;>[ span classjsbutton>a idBaumannMajumdarThinniyamZetzsche2020a-bibtex-show  hrefjavascript:toggle(BaumannMajumdarThinniyamZetzsche2020a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannMajumdarThinniyamZetzsche2020a-bibtex-hide hrefjavascript:toggle(BaumannMajumdarThinniyamZetzsche2020a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2020.111 title10.4230/LIPIcs.ICALP.2020.111>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BaumannMajumdarThinniyamZetzsche2020a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannMajumdarThinniyamZetzsche2020a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2020.111 title10.4230/LIPIcs.ICALP.2020.111>DOI/a> ]br/>/span>/noscript>div idBaumannMajumdarThinniyamZetzsche2020a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BaumannMajumdarThinniyamZetzsche2020a,	AUTHOR		 {Baumann, Pascal and Majumdar, Rupak and Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {The complexity of bounded context switching with dynamic thread creation},	YEAR		 {2020},	BOOKTITLE	 {Proc. of the 47th International Colloquium on Automata, Languages, and Programming (ICALP 2020)},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	VOLUME		 {168},	ADDRESS	 {Dagstuhl, Germany},	SERIES		 {LIPIcs},	DOI		 {10.4230/LIPIcs.ICALP.2020.111}}/pre>/div>/div>br/>div classentry>span classtitle>Rational subsets of Baumslag-Solitar groups/span>br/>with a hrefhttps://michael.cadilhac.name/>Michaël Cadilhac/a> and a hrefhttps://warwick.ac.uk/fac/sci/dcs/people/dmitry_chistikov>Dmitry Chistikov/a>br/>Proceedings of a hrefhttps://icalp2020.saarland-informatics-campus.de/ title47th International Colloquium on Automata, Languages, and Programming>ICALP 2020/a>br/>span classlinklist idCadilhacChistikovZetzsche2020a-linklist styledisplay:none;>[ span classjsbutton>a idCadilhacChistikovZetzsche2020a-bibtex-show  hrefjavascript:toggle(CadilhacChistikovZetzsche2020a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idCadilhacChistikovZetzsche2020a-bibtex-hide hrefjavascript:toggle(CadilhacChistikovZetzsche2020a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2020.116 title10.4230/LIPIcs.ICALP.2020.116>DOI/a> | a hrefhttp://arxiv.org/abs/2006.11898 title2006.11898>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(CadilhacChistikovZetzsche2020a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/CadilhacChistikovZetzsche2020a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2020.116 title10.4230/LIPIcs.ICALP.2020.116>DOI/a> | a hrefhttp://arxiv.org/abs/2006.11898 title2006.11898>arXiv/a> ]br/>/span>/noscript>div idCadilhacChistikovZetzsche2020a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{CadilhacChistikovZetzsche2020a,	TITLE		 {Rational subsets of Baumslag-Solitar groups},	AUTHOR		 {Cadilhac, Micha{\e}l and Chistikov, Dmitry and Zetzsche, Georg},	YEAR		 {2020},	BOOKTITLE	 {Proc. of the 47th International Colloquium on Automata, Languages, and Programming (ICALP 2020)},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	VOLUME		 {168},	ADDRESS	 {Dagstuhl, Germany},	SERIES		 {LIPIcs},	DOI		 {10.4230/LIPIcs.ICALP.2020.116}}/pre>/div>/div>br/>div classentry>span classtitle>The complexity of knapsack problems in wreath products/span>br/>with a hrefhttps://www.eti.uni-siegen.de/ti/mitarbeiter/figelius/>Michael Figelius/a>, a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>, and a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>br/>Proceedings of a hrefhttps://icalp2020.saarland-informatics-campus.de/ title47th International Colloquium on Automata, Languages, and Programming>ICALP 2020/a>br/>span classlinklist idFigeliusGanardiLohreyZetzsche2020a-linklist styledisplay:none;>[ span classjsbutton>a idFigeliusGanardiLohreyZetzsche2020a-bibtex-show  hrefjavascript:toggle(FigeliusGanardiLohreyZetzsche2020a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idFigeliusGanardiLohreyZetzsche2020a-bibtex-hide hrefjavascript:toggle(FigeliusGanardiLohreyZetzsche2020a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | a hrefhttp://arxiv.org/abs/2002.08086 title2002.08086>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2020.126 title10.4230/LIPIcs.ICALP.2020.126>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(FigeliusGanardiLohreyZetzsche2020a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/FigeliusGanardiLohreyZetzsche2020a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2002.08086 title2002.08086>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2020.126 title10.4230/LIPIcs.ICALP.2020.126>DOI/a> ]br/>/span>/noscript>div idFigeliusGanardiLohreyZetzsche2020a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{FigeliusGanardiLohreyZetzsche2020a,	TITLE		 {The complexity of knapsack problems in wreath products},	AUTHOR		 {Figelius, Michael and Ganardi, Moses and Lohrey, Markus and Zetzsche, Georg},	YEAR		 {2020},	BOOKTITLE	 {Proc. of the 47th International Colloquium on Automata, Languages, and Programming (ICALP 2020)},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	VOLUME		 {168},	ADDRESS	 {Dagstuhl, Germany},	SERIES		 {LIPIcs},	DOI		 {10.4230/LIPIcs.ICALP.2020.126}}/pre>/div>/div>br/>div classentry>span classtitle>Extensions of Omega-Regular Languages/span>br/>with a hrefhttps://www.mimuw.edu.pl/~bojan/>Mikołaj Bojańczyk/a>, a hrefhttps://edon.github.io/>Edon Kelmendi/a>, and Rafał Stefańskibr/>Proceedings of a hrefhttps://lics.siglog.org/lics20/index.php titleThirty-Fifth Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2020/a>br/>span classlinklist idBojanczykKelmendiStefanskiZetzsche2020a-linklist styledisplay:none;>[ span classjsbutton>a idBojanczykKelmendiStefanskiZetzsche2020a-bibtex-show  hrefjavascript:toggle(BojanczykKelmendiStefanskiZetzsche2020a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBojanczykKelmendiStefanskiZetzsche2020a-bibtex-hide hrefjavascript:toggle(BojanczykKelmendiStefanskiZetzsche2020a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBojanczykKelmendiStefanskiZetzsche2020a-abstract-show  hrefjavascript:toggle(BojanczykKelmendiStefanskiZetzsche2020a-abstract)>Show abstract/a>/span>span classjsbutton>a idBojanczykKelmendiStefanskiZetzsche2020a-abstract-hide hrefjavascript:toggle(BojanczykKelmendiStefanskiZetzsche2020a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2002.09393 title2002.09393>arXiv/a> | a hrefhttp://dx.doi.org/10.1145/3373718.3394779 title10.1145/3373718.3394779>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BojanczykKelmendiStefanskiZetzsche2020a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BojanczykKelmendiStefanskiZetzsche2020a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2002.09393 title2002.09393>arXiv/a> | a hrefhttp://dx.doi.org/10.1145/3373718.3394779 title10.1145/3373718.3394779>DOI/a> ]br/>/span>/noscript>div classabstract idBojanczykKelmendiStefanskiZetzsche2020a-abstract>span classabstractheading>Abstract/span>br/>      We consider extensions of monadic second order logic over      $\omega$-words, which are obtained by adding one language that      is not $\omega$-regular.  We show that if the added language $L$      has a neutral letter, then the resulting logic is necessarily      undecidable. A corollary is that the $\omega$-regular languages      are the only decidable Boolean-closed full trio over      $\omega$-words.  /div>script typetext/javascript>document.getElementById(BojanczykKelmendiStefanskiZetzsche2020a-abstract).style.displaynone;/script>div idBojanczykKelmendiStefanskiZetzsche2020a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BojanczykKelmendiStefanskiZetzsche2020a,	AUTHOR		 {Boja{\{n}}czyk, Miko{\l}aj and Kelmendi, Edon and Stefa{\{n}}ski, Rafa{\l} and Zetzsche, Georg},	TITLE		 {Extensions of Omega-Regular Languages},	YEAR		 {2020},	BOOKTITLE	 {Proc. of the Thirty-Fifth Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2020)},	PUBLISHER	 {ACM},	PAGES		 {266--272},	EDITOR		 {Holger Hermanns and Lijun Zhang and Naoki Kobayashi and Dale Miller},	DOI		 {10.1145/3373718.3394779}}/pre>/div>/div>br/>div classentry>span classtitle>An Approach to Regular Separability in Vector Addition Systems/span>br/>with a hrefhttps://www.mimuw.edu.pl/~wczerwin/>Wojciech Czerwiński/a>br/>Proceedings of a hrefhttps://lics.siglog.org/lics20/index.php titleThirty-Fifth Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2020/a>br/>span classlinklist idCzerwinskiZetzsche2020a-linklist styledisplay:none;>[ span classjsbutton>a idCzerwinskiZetzsche2020a-bibtex-show  hrefjavascript:toggle(CzerwinskiZetzsche2020a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idCzerwinskiZetzsche2020a-bibtex-hide hrefjavascript:toggle(CzerwinskiZetzsche2020a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idCzerwinskiZetzsche2020a-abstract-show  hrefjavascript:toggle(CzerwinskiZetzsche2020a-abstract)>Show abstract/a>/span>span classjsbutton>a idCzerwinskiZetzsche2020a-abstract-hide hrefjavascript:toggle(CzerwinskiZetzsche2020a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2007.00111 title2007.00111>arXiv/a> | a hrefhttp://dx.doi.org/10.1145/3373718.3394776 title10.1145/3373718.3394776>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(CzerwinskiZetzsche2020a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/CzerwinskiZetzsche2020a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2007.00111 title2007.00111>arXiv/a> | a hrefhttp://dx.doi.org/10.1145/3373718.3394776 title10.1145/3373718.3394776>DOI/a> ]br/>/span>/noscript>div classabstract idCzerwinskiZetzsche2020a-abstract>span classabstractheading>Abstract/span>br/>     We study the problem of regular separability of languages of     vector addition systems with states (VASS).  It asks whether for     two given VASS languages $K$ and $L$, there exists a regular     language $R$ that includes $K$ and is disjoint from $L$. While     decidability of the problem in full generality remains an open     question, there are several subclasses for which decidability has     been shown: It is decidable for (i)~one-dimensional VASS,     (ii)~VASS coverability languages, (iii)~languages of integer     VASS, and (iv)~commutative VASS languages.     We propose a general approach to deciding regular     separability. We use it to decide regular separability of an     arbitrary VASS language from any language in the classes~(i),     (ii), and~(iii). This generalizes all previous results,     including~(iv).  /div>script typetext/javascript>document.getElementById(CzerwinskiZetzsche2020a-abstract).style.displaynone;/script>div idCzerwinskiZetzsche2020a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{CzerwinskiZetzsche2020a,	AUTHOR		 {Czerwi{\{n}}ski, Wojciech and Zetzsche, Georg},	TITLE		 {An Approach to Regular Separability in Vector Addition Systems},	BOOKTITLE	 {Proc. of the Thirty-Fifth Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2020)},	PUBLISHER	 {ACM},	PAGES		 {341--354},	EDITOR		 {Holger Hermanns and Lijun Zhang and Naoki Kobayashi and Dale Miller},	YEAR		 {2020},	DOI		 {10.1145/3373718.3394776}}/pre>/div>/div>br/>div classentry>span classtitle>Regular Separability and Intersection Emptiness are Independent Problems/span>br/>with a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Proceedings of a hrefhttp://www.fsttcs.org.in/2019/ title39th IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science>FSTTCS 2019/a>br/>span classlinklist idThinniyamZetzsche2019a-linklist styledisplay:none;>[ span classjsbutton>a idThinniyamZetzsche2019a-bibtex-show  hrefjavascript:toggle(ThinniyamZetzsche2019a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idThinniyamZetzsche2019a-bibtex-hide hrefjavascript:toggle(ThinniyamZetzsche2019a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | a hrefhttp://arxiv.org/abs/1908.04038 title1908.04038>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(ThinniyamZetzsche2019a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/ThinniyamZetzsche2019a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1908.04038 title1908.04038>arXiv/a> ]br/>/span>/noscript>div idThinniyamZetzsche2019a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{ThinniyamZetzsche2019a,	AUTHOR		 {Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {Regular Separability and Intersection Emptiness are Independent Problems},	BOOKTITLE	 {Proc. of the 39th IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS 2019)},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum f{\u}r Informatik},	VOLUME		 {150},	ADDRESS	 {Dagstuhl, Germany},	YEAR		 {2019},	SERIES		 {LIPIcs}}/pre>/div>/div>br/>div classentry>span classtitle>Coverability Is Undecidable in One-Dimensional Pushdown Vector Addition Systems with Resets/span>br/>with a hrefhttps://www.irif.fr/en/users/schmitz/index/>Sylvain Schmitz/a>br/>Proceedings of a hrefhttps://sites.uclouvain.be/rp2019/ title13th International Conference on Reachability Problems>RP 2019/a>br/>span classlinklist idSchmitzZetzsche2019a-linklist styledisplay:none;>[ span classjsbutton>a idSchmitzZetzsche2019a-bibtex-show  hrefjavascript:toggle(SchmitzZetzsche2019a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idSchmitzZetzsche2019a-bibtex-hide hrefjavascript:toggle(SchmitzZetzsche2019a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idSchmitzZetzsche2019a-abstract-show  hrefjavascript:toggle(SchmitzZetzsche2019a-abstract)>Show abstract/a>/span>span classjsbutton>a idSchmitzZetzsche2019a-abstract-hide hrefjavascript:toggle(SchmitzZetzsche2019a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/1906.07069 title1906.07069>arXiv/a> | a hrefhttp://dx.doi.org/10.1007/978-3-030-30806-3_15 title10.1007/978-3-030-30806-3_15>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(SchmitzZetzsche2019a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/SchmitzZetzsche2019a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1906.07069 title1906.07069>arXiv/a> | a hrefhttp://dx.doi.org/10.1007/978-3-030-30806-3_15 title10.1007/978-3-030-30806-3_15>DOI/a> ]br/>/span>/noscript>div classabstract idSchmitzZetzsche2019a-abstract>span classabstractheading>Abstract/span>br/>    We consider the model of pushdown vector addition systems with    resets. These consist of vector addition systems that have access    to a pushdown stack and have instructions to reset counters. For    this model, we study the coverability problem. In the absence of    resets, this problem is known to be decidable for one-dimensional    pushdown vector addition systems, but decidability is open for    general pushdown vector addition systems. Moreover, coverability    is known to be decidable for reset vector addition systems without    a pushdown stack. We show in this note that the problem is    undecidable for one-dimensional pushdown vector addition systems    with resets.  /div>script typetext/javascript>document.getElementById(SchmitzZetzsche2019a-abstract).style.displaynone;/script>div idSchmitzZetzsche2019a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{SchmitzZetzsche2019a,	AUTHOR		 {Schmitz, Sylvain and Zetzsche, Georg},	TITLE		 {Coverability Is Undecidable in One-Dimensional Pushdown Vector Addition Systems with Resets},	BOOKTITLE	 {Proc. of the 13th International Conference on Reachability Problems (RP 2019)},	YEAR		 {2019},	PUBLISHER	 {Springer},	ADDRESS	 {Cham},	SERIES		 {Lecture Notes in Computer Science},	VOLUME		 {11674},	DOI		 {10.1007/978-3-030-30806-3_15}}/pre>/div>/div>br/>div classentry>span classtitle>Presburger arithmetic with stars, rational subsets of graph groups, and nested zero tests/span>br/>with a hrefhttps://www.cs.ox.ac.uk/people/christoph.haase/>Christoph Haase/a>br/>Proceedings of a hrefhttps://lics.siglog.org/lics19/index.php titleThirty-Fourth Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2019/a>br/>span classlinklist idHaaseZetzsche2019a-linklist styledisplay:none;>[ span classjsbutton>a idHaaseZetzsche2019a-bibtex-show  hrefjavascript:toggle(HaaseZetzsche2019a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idHaaseZetzsche2019a-bibtex-hide hrefjavascript:toggle(HaaseZetzsche2019a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idHaaseZetzsche2019a-abstract-show  hrefjavascript:toggle(HaaseZetzsche2019a-abstract)>Show abstract/a>/span>span classjsbutton>a idHaaseZetzsche2019a-abstract-hide hrefjavascript:toggle(HaaseZetzsche2019a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/HaaseZetzsche2019a.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1109/LICS.2019.8785850 title10.1109/LICS.2019.8785850>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(HaaseZetzsche2019a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/HaaseZetzsche2019a.bib>BibTeX/a> | a hrefdoc/HaaseZetzsche2019a.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1109/LICS.2019.8785850 title10.1109/LICS.2019.8785850>DOI/a> ]br/>/span>/noscript>div classabstract idHaaseZetzsche2019a-abstract>span classabstractheading>Abstract/span>br/>      We study the computational complexity of existential Presburger  arithmetic with (possibly nested occurrences of) a Kleene-star  operator. In addition to being a natural extension of Presburger  arithmetic, our investigation is motivated by two other decision  problems.  br/>  The first problem is the rational subset membership problem in graph  groups. A graph group is an infinite group specified by a finite  undirected graph. While a characterisation of graph groups with a  decidable rational subset membership problem was given by Lohrey and  Steinberg J. Algebra, 320(2) (2008), it has been an open  problem (i) whether the decidable fragment has elementary complexity  and (ii) what is the complexity for each fixed graph group. The  second problem is the reachability problem for integer vector  addition systems with states and nested zero tests.  br/>  We prove that the satisfiability problem for existential Presburger  arithmetic with stars is NEXP-complete and that all three  problems are polynomially inter-reducible. Moreover, we consider for  each problem a variant with a fixed parameter: We fix the  star-height in the logic, the group for the membership problem, and  the number of distinct zero-tests in the integer vector addition  systems. We establish NP-completeness of all problems with fixed  parameters.  br/>  In particular, this enables us to obtain a complete description of  the complexity landscape of the rational subset membership problem  for fixed graph groups: If the graph is a clique, the problem is  NL-complete. If the graph is a disjoint union of cliques, it is  PTIME-complete. If it is a transitive forest (and not a union of  cliques), the problem is NP-complete. Otherwise, the problem is  undecidable.  /div>script typetext/javascript>document.getElementById(HaaseZetzsche2019a-abstract).style.displaynone;/script>div idHaaseZetzsche2019a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{HaaseZetzsche2019a,	AUTHOR		 {Haase, Christoph and Zetzsche, Georg},	TITLE		 {Presburger arithmetic with stars, rational subsets of graph groups, and nested zero tests},	PUBLISHER	 {IEEE},	PAGES		 {1--14},	BOOKTITLE	 {Proc. of the Thirty-Fourth Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2019)},	YEAR		 {2019},	DOI		 {10.1109/LICS.2019.8785850}}/pre>/div>/div>br/>div classentry>span classtitle>Languages ordered by the subword order/span>br/>with a hrefhttp://eiche.theoinf.tu-ilmenau.de/kuske/>Dietrich Kuske/a>br/>Proceedings of a hrefhttps://conf.researchr.org/track/etaps-2019/fossacs-2019-papers title22nd International Conference on Foundations of Software Science and Computation Structures>FoSSaCS 2019/a>br/>span classlinklist idKuskeZetzsche2019a-linklist styledisplay:none;>[ span classjsbutton>a idKuskeZetzsche2019a-bibtex-show  hrefjavascript:toggle(KuskeZetzsche2019a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idKuskeZetzsche2019a-bibtex-hide hrefjavascript:toggle(KuskeZetzsche2019a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idKuskeZetzsche2019a-abstract-show  hrefjavascript:toggle(KuskeZetzsche2019a-abstract)>Show abstract/a>/span>span classjsbutton>a idKuskeZetzsche2019a-abstract-hide hrefjavascript:toggle(KuskeZetzsche2019a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/1901.02194 title1901.02194>arXiv/a> | a hrefhttp://dx.doi.org/10.1007/978-3-030-17127-8_20 title10.1007/978-3-030-17127-8_20>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(KuskeZetzsche2019a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/KuskeZetzsche2019a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1901.02194 title1901.02194>arXiv/a> | a hrefhttp://dx.doi.org/10.1007/978-3-030-17127-8_20 title10.1007/978-3-030-17127-8_20>DOI/a> ]br/>/span>/noscript>div classabstract idKuskeZetzsche2019a-abstract>span classabstractheading>Abstract/span>br/>      We consider a language together with the subword relation, the cover  relation, and regular predicates. For such structures, we consider  the extension of first-order logic by threshold- and modulo-counting  quantifiers. Depending on the language, the used predicates, and the  fragment of the logic, we determine four new combinations that yield  decidable theories. These results extend earlier ones where only the  language of all words without the cover relation and fragments of  first-order logic were considered.  /div>script typetext/javascript>document.getElementById(KuskeZetzsche2019a-abstract).style.displaynone;/script>div idKuskeZetzsche2019a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{KuskeZetzsche2019a,	AUTHOR		 {Kuske, Dietrich and Zetzsche, Georg},	TITLE		 {Languages ordered by the subword order},	BOOKTITLE	 {Proc. of the 22nd International Conference on Foundations of Software Science and Computation Structures (FoSSaCS 2019)},	PAGES		 {348--364},	SERIES		 {Lecture Notes in Computer Science},	VOLUME		 {11425},	PUBLISHER	 {Springer},	ADDRESS	 {Cham},	YEAR		 {2019},	DOI		 {10.1007/978-3-030-17127-8_20}}/pre>/div>/div>br/>div classentry>span classtitle>Bounded Context Switching for Valence Systems/span>br/>with a hrefhttp://www.tcs.cs.tu-bs.de/group/meyer/home.html>Roland Meyer/a> and a hrefhttp://www.tcs.cs.tu-bs.de/group/muskalla/home.html>Sebastian Muskalla/a>br/>Proceedings of a hrefhttp://lcs.ios.ac.cn/concur2018/ title29th International Conference on Concurrency Theory>CONCUR 2018/a>br/>span classlinklist idMeyerMuskallaZetzsche2018a-linklist styledisplay:none;>[ span classjsbutton>a idMeyerMuskallaZetzsche2018a-bibtex-show  hrefjavascript:toggle(MeyerMuskallaZetzsche2018a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idMeyerMuskallaZetzsche2018a-bibtex-hide hrefjavascript:toggle(MeyerMuskallaZetzsche2018a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idMeyerMuskallaZetzsche2018a-abstract-show  hrefjavascript:toggle(MeyerMuskallaZetzsche2018a-abstract)>Show abstract/a>/span>span classjsbutton>a idMeyerMuskallaZetzsche2018a-abstract-hide hrefjavascript:toggle(MeyerMuskallaZetzsche2018a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.CONCUR.2018.12 title10.4230/LIPIcs.CONCUR.2018.12>DOI/a> | a hrefhttp://arxiv.org/abs/1803.09703 title1803.09703>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(MeyerMuskallaZetzsche2018a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/MeyerMuskallaZetzsche2018a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.CONCUR.2018.12 title10.4230/LIPIcs.CONCUR.2018.12>DOI/a> | a hrefhttp://arxiv.org/abs/1803.09703 title1803.09703>arXiv/a> ]br/>/span>/noscript>div classabstract idMeyerMuskallaZetzsche2018a-abstract>span classabstractheading>Abstract/span>br/>    We study valence systems, finite-control programs over    infinite-state memories modeled in terms of graph monoids.  Our    contribution is a notion of bounded context switching (BCS).    Valence systems generalize pushdowns, concurrent pushdowns, and    Petri nets.  In these settings, our definition conservatively    generalizes existing notions.  The main finding is that    reachability within a bounded number of context switches is in    $\NPTIME$, independent of the memory (the graph monoid).  Our    proof is genuinely algebraic, and therefore contributes a new way    to think about BCS.  /div>script typetext/javascript>document.getElementById(MeyerMuskallaZetzsche2018a-abstract).style.displaynone;/script>div idMeyerMuskallaZetzsche2018a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{MeyerMuskallaZetzsche2018a,	AUTHOR		 {Meyer, Roland and Muskalla, Sebastian and Zetzsche, Georg},	TITLE		 {Bounded Context Switching for Valence Systems},	YEAR		 {2018},	BOOKTITLE	 {Proc. of the 29th International Conference on Concurrency Theory (CONCUR 2018)},	PAGES		 {12:1--12:18},	YEAR		 {2018},	SERIES		 {LIPIcs},	VOLUME		 {118},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},	DOI		 {10.4230/LIPIcs.CONCUR.2018.12}}/pre>/div>/div>br/>div classentry>span classtitle>Unboundedness problems for languages of vector addition systems/span>br/>with a hrefhttps://www.mimuw.edu.pl/~wczerwin/>Wojciech Czerwiński/a> and a hrefhttp://www.mimuw.edu.pl/~ph209519/>Piotr Hofman/a>br/>Proceedings of a hrefhttp://iuuk.mff.cuni.cz/~icalp2018/ title45th International Colloquium on Automata, Languages, and Programming>ICALP 2018/a>br/>span classlinklist idCzerwinskiHofmanZetzsche2018a-linklist styledisplay:none;>[ span classjsbutton>a idCzerwinskiHofmanZetzsche2018a-bibtex-show  hrefjavascript:toggle(CzerwinskiHofmanZetzsche2018a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idCzerwinskiHofmanZetzsche2018a-bibtex-hide hrefjavascript:toggle(CzerwinskiHofmanZetzsche2018a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idCzerwinskiHofmanZetzsche2018a-abstract-show  hrefjavascript:toggle(CzerwinskiHofmanZetzsche2018a-abstract)>Show abstract/a>/span>span classjsbutton>a idCzerwinskiHofmanZetzsche2018a-abstract-hide hrefjavascript:toggle(CzerwinskiHofmanZetzsche2018a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/1802.06683 title1802.06683>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2018.119 title10.4230/LIPIcs.ICALP.2018.119>DOI/a> | a hrefdoc/CzerwinskiHofmanZetzsche2018a.pdf titleVersion >PDF/a> ]br/>/span>script typetext/javascript>document.getElementById(CzerwinskiHofmanZetzsche2018a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/CzerwinskiHofmanZetzsche2018a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1802.06683 title1802.06683>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.ICALP.2018.119 title10.4230/LIPIcs.ICALP.2018.119>DOI/a> | a hrefdoc/CzerwinskiHofmanZetzsche2018a.pdf titleVersion >PDF/a> ]br/>/span>/noscript>div classabstract idCzerwinskiHofmanZetzsche2018a-abstract>span classabstractheading>Abstract/span>br/>      A vector addition system (VAS) with an initial and a final marking  and transition labels induces a language. In part because the  reachability problem in VAS remains far from being well-understood,  it is difficult to devise decision procedures for such languages.  This is especially true for checking properties that state  the existence of infinitely many words of a particular  shape. Informally, we call these \emph{unboundedness properties}.    We present a simple set of axioms for predicates that can express  unboundedness properties.  Our main result is that such a  predicate is decidable for VAS languages as soon as it is decidable  for regular languages. Among other results, this allows us to show  decidability of (i)~separability by bounded regular languages,  (ii)~unboundedness of occurring factors from a language $K$ with  mild conditions on $K$, and (iii)~universality of the set of factors.  /div>script typetext/javascript>document.getElementById(CzerwinskiHofmanZetzsche2018a-abstract).style.displaynone;/script>div idCzerwinskiHofmanZetzsche2018a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{CzerwinskiHofmanZetzsche2018a,	AUTHOR		 {Czerwi{\{n}}ski, Wojciech and Hofman, Piotr and Zetzsche, Georg},	TITLE		 {Unboundedness problems for languages of vector addition systems},	YEAR		 {2018},	BOOKTITLE	 {Proc. of the 45th International Colloquium on Automata, Languages, and Programming (ICALP 2018)},	PAGES		 {119:1--119:15},	SERIES		 {Leibniz International Proceedings in Informatics (LIPIcs)},	YEAR		 {2018},	VOLUME		 {107},	EDITOR		 {Ioannis Chatzigiannakis and Christos Kaklamanis and D{\a}niel Marx and Donald Sannella},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},	ADDRESS	 {Dagstuhl, Germany},	DOI		 {10.4230/LIPIcs.ICALP.2018.119}}/pre>/div>/div>br/>div classentry>span classtitle>Separability by piecewise testable languages and downward closures beyond subwords/span>br/>Proceedings of a hrefhttps://lics.siglog.org/lics18/index.php titleThirty-Third Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2018/a>br/>span classlinklist idZetzsche2018a-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2018a-bibtex-show  hrefjavascript:toggle(Zetzsche2018a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2018a-bibtex-hide hrefjavascript:toggle(Zetzsche2018a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2018a-abstract-show  hrefjavascript:toggle(Zetzsche2018a-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2018a-abstract-hide hrefjavascript:toggle(Zetzsche2018a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/Zetzsche2018a.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1145/3209108.3209201 title10.1145/3209108.3209201>DOI/a> | a hrefhttp://arxiv.org/abs/1802.07397 title1802.07397>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2018a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2018a.bib>BibTeX/a> | a hrefdoc/Zetzsche2018a.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1145/3209108.3209201 title10.1145/3209108.3209201>DOI/a> | a hrefhttp://arxiv.org/abs/1802.07397 title1802.07397>arXiv/a> ]br/>/span>/noscript>div classabstract idZetzsche2018a-abstract>span classabstractheading>Abstract/span>br/>  We introduce a flexible class of well-quasi-orderings (WQOs) on  words that generalizes the ordering of (not necessarily contiguous)  subwords.  Each such WQO induces a class of piecewise testable languages (PTLs)  as Boolean combinations of upward closed sets. In this way, a range  of regular language classes arises as PTLs. Moreover, each of the  WQOs guarantees regularity of all downward closed sets.  br/>  We consider two problems. First, we study which (perhaps  non-regular) language classes allow to decide whether two given  languages are separable by a PTL with respect to a given  WQO. Second, we want to effectively compute downward closures with  respect to these WQOs.  br/>  Our first main result is that for each of the WQOs, under mild  assumptions, both problems reduce to the simultaneous unboundedness  problem (SUP) and are thus solvable for many powerful system  models. In the second main result, we apply the framework to show  decidability of separability of regular languages by  $\mathcal{B}\Sigma_1, \mathsf{mod}$, a fragment of  first-order logic with modular predicates.  /div>script typetext/javascript>document.getElementById(Zetzsche2018a-abstract).style.displaynone;/script>div idZetzsche2018a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{Zetzsche2018a,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {Separability by piecewise testable languages and downward closures beyond subwords},	YEAR		 {2018},	BOOKTITLE	 {Proc. of the Thirty-Third Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2018)},	PAGES		 {929--938},	YEAR		 {2018},	EDITOR		 {Anuj Dawar and Erich Gr{\a}del},	PUBLISHER	 {ACM},	YEAR		 {2018},	DOI		 {10.1145/3209108.3209201}}/pre>/div>/div>br/>div classentry>span classtitle>Knapsack problems for wreath products/span>br/>with a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>, a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/koenig/>Daniel König/a>, and a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>br/>Proceedings of a hrefhttps://stacs2018.sciencesconf.org/ title35th International Symposium on Theoretical Aspects of Computer Science>STACS 2018/a>br/>span classlinklist idGanardiKoenigLohreyZetzsche2017a-linklist styledisplay:none;>[ span classjsbutton>a idGanardiKoenigLohreyZetzsche2017a-bibtex-show  hrefjavascript:toggle(GanardiKoenigLohreyZetzsche2017a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idGanardiKoenigLohreyZetzsche2017a-bibtex-hide hrefjavascript:toggle(GanardiKoenigLohreyZetzsche2017a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idGanardiKoenigLohreyZetzsche2017a-abstract-show  hrefjavascript:toggle(GanardiKoenigLohreyZetzsche2017a-abstract)>Show abstract/a>/span>span classjsbutton>a idGanardiKoenigLohreyZetzsche2017a-abstract-hide hrefjavascript:toggle(GanardiKoenigLohreyZetzsche2017a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/1709.09598 title1709.09598>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2018.32 title10.4230/LIPIcs.STACS.2018.32>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(GanardiKoenigLohreyZetzsche2017a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/GanardiKoenigLohreyZetzsche2017a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1709.09598 title1709.09598>arXiv/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2018.32 title10.4230/LIPIcs.STACS.2018.32>DOI/a> ]br/>/span>/noscript>div classabstract idGanardiKoenigLohreyZetzsche2017a-abstract>span classabstractheading>Abstract/span>br/>    In recent years, knapsack problems for (in general    non-commutative) groups have attracted attention.  In this paper,    the knapsack problem for wreath products is studied. It turns out    that decidability of knapsack is not preserved under wreath    product. On the other hand, the class of knapsack-semilinear    groups, where solutions sets of knapsack equations are effectively    semilinear, is closed under wreath product.  As a consequence, we    obtain the decidability of knapsack for free solvable    groups. Finally, it is shown that for every non-trivial abelian    group $G$, knapsack (as well as the related subset sum problem)    for the wreath product $G \wr \Z$ is $\NP$-complete.  /div>script typetext/javascript>document.getElementById(GanardiKoenigLohreyZetzsche2017a-abstract).style.displaynone;/script>div idGanardiKoenigLohreyZetzsche2017a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{GanardiKoenigLohreyZetzsche2017a,	AUTHOR		 {Ganardi, Moses and K{\o}nig, Daniel and Lohrey, Markus and Zetzsche, Georg},	TITLE		 {Knapsack problems for wreath products},	YEAR		 {2018},	PAGES		 {32:1--32:13},	SERIES		 {Leibniz International Proceedings in Informatics (LIPIcs)},	EDITOR		 {Rolf Niedermeier and Brigitte Val{\{e}}e},	ADDRESS	 {Dagstuhl, Germany},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},	VOLUME		 {96},	BOOKTITLE	 {Proc. of the 35th International Symposium on Theoretical Aspects of Computer Science (STACS 2018)},	DOI		 {10.4230/LIPIcs.STACS.2018.32}}/pre>/div>/div>br/>div classentry>span classtitle>Decidability, Complexity, and Expressiveness of First-Order Logic Over the Subword Ordering/span>br/>with a hrefhttp://www.lsv.ens-cachan.fr/~halfon/>Simon Halfon/a> and a hrefhttp://www.lsv.ens-cachan.fr/~phs/>Philippe Schnoebelen/a>br/>Proceedings of a hrefhttp://lics.rwth-aachen.de/lics17/ titleThirty-Second Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2017/a>br/>span classlinklist idHalfonSchnoebelenZetzsche2017a-linklist styledisplay:none;>[ span classjsbutton>a idHalfonSchnoebelenZetzsche2017a-bibtex-show  hrefjavascript:toggle(HalfonSchnoebelenZetzsche2017a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idHalfonSchnoebelenZetzsche2017a-bibtex-hide hrefjavascript:toggle(HalfonSchnoebelenZetzsche2017a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idHalfonSchnoebelenZetzsche2017a-abstract-show  hrefjavascript:toggle(HalfonSchnoebelenZetzsche2017a-abstract)>Show abstract/a>/span>span classjsbutton>a idHalfonSchnoebelenZetzsche2017a-abstract-hide hrefjavascript:toggle(HalfonSchnoebelenZetzsche2017a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/1701.07470 title1701.07470>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(HalfonSchnoebelenZetzsche2017a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/HalfonSchnoebelenZetzsche2017a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1701.07470 title1701.07470>arXiv/a> ]br/>/span>/noscript>div classabstract idHalfonSchnoebelenZetzsche2017a-abstract>span classabstractheading>Abstract/span>br/>	 We consider first-order logic over the subword ordering on finite         words, where each word is available as a constant. Our first result is that the         $\Sigma_1$ theory is undecidable (already over two letters).  	br/>	We investigate         the decidability border by considering fragments where all but a certain number         of variables are alternation bounded, meaning that the variable must always be         quantified over languages with a bounded number of letter alternations. We         prove that when at most two variables are not alternation bounded, the $\Sigma_1$         fragment is decidable, and that it becomes undecidable when three variables are         not alternation bounded. Regarding higher quantifier alternation depths, we         prove that the $\Sigma_2$ fragment is undecidable already for one variable without         alternation bound and that when all variables are alternation bounded, the         entire first-order theory is decidable. 	/div>script typetext/javascript>document.getElementById(HalfonSchnoebelenZetzsche2017a-abstract).style.displaynone;/script>div idHalfonSchnoebelenZetzsche2017a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{HalfonSchnoebelenZetzsche2017a,	AUTHOR		 {Halfon, Simon and Schnoebelen, Philippe and Zetzsche, Georg},	TITLE		 {Decidability, Complexity, and Expressiveness of First-Order Logic Over the Subword Ordering},	BOOKTITLE	 {Proc. of the Thirty-Second Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2017)},	PAGES		 {1--12},	PUBLISHER	 {IEEE Computer Society},	YEAR		 {2017}}/pre>/div>/div>br/>div classentry>span classtitle>The Complexity of Knapsack in Graph Groups/span>br/>with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>br/>Proceedings of a hrefhttps://stacs2017.thi.uni-hannover.de/ title34th International Symposium on Theoretical Aspects of Computer Science>STACS 2017/a>br/>span classlinklist idLohreyZetzsche2017a-linklist styledisplay:none;>[ span classjsbutton>a idLohreyZetzsche2017a-bibtex-show  hrefjavascript:toggle(LohreyZetzsche2017a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idLohreyZetzsche2017a-bibtex-hide hrefjavascript:toggle(LohreyZetzsche2017a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idLohreyZetzsche2017a-abstract-show  hrefjavascript:toggle(LohreyZetzsche2017a-abstract)>Show abstract/a>/span>span classjsbutton>a idLohreyZetzsche2017a-abstract-hide hrefjavascript:toggle(LohreyZetzsche2017a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/LohreyZetzsche2017a.pdf titleVersion >PDF (conference)/a> | a hrefdoc/LohreyZetzsche2017a-full.pdf titleVersion >PDF (full)/a> ]br/>/span>script typetext/javascript>document.getElementById(LohreyZetzsche2017a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/LohreyZetzsche2017a.bib>BibTeX/a> | a hrefdoc/LohreyZetzsche2017a.pdf titleVersion >PDF (conference)/a> | a hrefdoc/LohreyZetzsche2017a-full.pdf titleVersion >PDF (full)/a> ]br/>/span>/noscript>div classabstract idLohreyZetzsche2017a-abstract>span classabstractheading>Abstract/span>br/>		Myasnikov et al. have introduced the knapsack problem for arbitrary finitely		generated groups.  In previous work, the authors proved that for each graph		group, the knapsack problem can be solved in NP. Here, we determine the		exact complexity of the problem for every graph group. While the problem is		TC0-complete for complete graphs, it is LogCFL-complete for each		(non-complete) transitive forest. For every remaining graph, the problem is		NP-complete.	/div>script typetext/javascript>document.getElementById(LohreyZetzsche2017a-abstract).style.displaynone;/script>div idLohreyZetzsche2017a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{LohreyZetzsche2017a,	AUTHOR		 {Lohrey, Markus and Zetzsche, Georg},	TITLE		 {The Complexity of Knapsack in Graph Groups},	YEAR		 {2017},	PAGES		 {52:1--52:14},	SERIES		 {Leibniz International Proceedings in Informatics (LIPIcs)},	EDITOR		 {Heribert Vollmer and Brigitte Val{\{e}}e},	ADDRESS	 {Dagstuhl, Germany},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},	VOLUME		 {66},	BOOKTITLE	 {Proc. of the 34th International Symposium on Theoretical Aspects of Computer Science (STACS 2017)}}/pre>/div>/div>br/>div classentry>span classtitle>Knapsack and subset sum problems in nilpotent, polycyclic, and co-context-free groups/span>br/>with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/koenig/>Daniel König/a> and a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>br/>Proceedings of a hrefhttp://jointmathematicsmeetings.org/meetings/national/jmm2015/2168_program_ss2.html#title titleAMS Special Session on Groups, Algorithms, and Cryptography (San Antonio, Texas, 2015)>AMS Special Session on Groups, Algorithms, and Cryptography (San Antonio, Texas, 2015)/a>br/>span classlinklist idKoenigLohreyZetzsche2015a-linklist styledisplay:none;>[ span classjsbutton>a idKoenigLohreyZetzsche2015a-bibtex-show  hrefjavascript:toggle(KoenigLohreyZetzsche2015a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idKoenigLohreyZetzsche2015a-bibtex-hide hrefjavascript:toggle(KoenigLohreyZetzsche2015a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | a hrefhttp://arxiv.org/abs/1507.05145 title1507.05145>arXiv/a> | a hrefdoc/KoenigLohreyZetzsche2015a.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1090/conm/677 title10.1090/conm/677>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(KoenigLohreyZetzsche2015a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/KoenigLohreyZetzsche2015a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1507.05145 title1507.05145>arXiv/a> | a hrefdoc/KoenigLohreyZetzsche2015a.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1090/conm/677 title10.1090/conm/677>DOI/a> ]br/>/span>/noscript>div idKoenigLohreyZetzsche2015a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{KoenigLohreyZetzsche2015a,	AUTHOR		 {K{\o}nig, Daniel and Lohrey, Markus and Zetzsche, Georg},	TITLE		 {Knapsack and subset sum problems in nilpotent, polycyclic, and co-context-free groups},	BOOKTITLE	 {Proc. of the AMS Special Session on Groups, Algorithms, and Cryptography (San Antonio, Texas, 2015)},	PUBLISHER	 {American Mathematical Society},	ADDRESS	 {Providence, RI, USA},	SERIES		 {Contemporary Mathematics},	VOLUME		 {677},	YEAR		 {2016},	PAGES		 {129},	DOI		 {10.1090/conm/677}}/pre>/div>/div>br/>div classentry>span classtitle>The Complexity of Downward Closure Comparisons/span>br/>Proceedings of a hrefhttp://www.easyconferences.eu/icalp2016/ title43rd International Colloquium on Automata, Languages and Programming>ICALP 2016/a>br/>span classlinklist idZetzsche2016a-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2016a-bibtex-show  hrefjavascript:toggle(Zetzsche2016a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2016a-bibtex-hide hrefjavascript:toggle(Zetzsche2016a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2016a-abstract-show  hrefjavascript:toggle(Zetzsche2016a-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2016a-abstract-hide hrefjavascript:toggle(Zetzsche2016a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/Zetzsche2016a.pdf titleVersion >PDF/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2016a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2016a.bib>BibTeX/a> | a hrefdoc/Zetzsche2016a.pdf titleVersion >PDF/a> ]br/>/span>/noscript>div classabstract idZetzsche2016a-abstract>span classabstractheading>Abstract/span>br/>		The downward closure of a language is the set of all (not necessarily		contiguous) subwords of its members. It is well-known that the downward		closure of every language is regular. Moreover, recent results show		that downward closures are computable for quite powerful system models.		br/>		One advantage of abstracting a language by its downward closure is that then,		equivalence and inclusion become decidable. In this work, we study the		complexity of these two problems. More precisely, we consider the following		decision problems: Given languages $K$ and $L$ from classes $\C$ and $\D$,		respectively, does the downward closure of $K$ include (equal) that of $L$?		br/>		These problems are investigated for finite automata, one-counter automata,		context-free grammars, and reversal-bounded counter automata. For each		combination, we prove a completeness result either for fixed or for arbitrary		alphabets.  Moreover, for Petri net languages, we show that both problems are		Ackermann-hard and for higher-order pushdown automata of order $k$, we prove		hardness for complements of nondeterministic $k$-fold exponential time.	/div>script typetext/javascript>document.getElementById(Zetzsche2016a-abstract).style.displaynone;/script>div idZetzsche2016a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{Zetzsche2016a,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {The Complexity of Downward Closure Comparisons},	YEAR		 {2016},	BOOKTITLE	 {Proc. of the 43rd International Colloquium on Automata, Languages and Programming (ICALP 2016)},	PAGES		 {123:1--123:14},	SERIES		 {Leibniz International Proceedings in Informatics (LIPIcs)},	EDITOR		 {Chatzigiannakis, Ioannis and Mitzenmacher, Michael and Rabani, Yuval and Sangiorgi, Davide},	ADDRESS	 {Dagstuhl, Germany},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},	VOLUME		 {55},	YEAR		 {2016}}/pre>/div>/div>br/>div classentry>span classtitle>The complexity of regular abstractions of one-counter languages/span>br/>with a hrefhttp://www.it.uu.se/katalog/mohat117>Mohamed Faouzi Atig/a>, a hrefhttps://warwick.ac.uk/fac/sci/dcs/people/dmitry_chistikov>Dmitry Chistikov/a>, a hrefhttp://www.mimuw.edu.pl/~ph209519/>Piotr Hofman/a>, a hrefhttp://www.cmi.ac.in/~kumar/>K Narayan Kumar/a>, and a hrefhttps://www.imsc.res.in/prakash_saivasan>Prakash Saivasan/a>br/>Proceedings of a hrefhttp://lics.rwth-aachen.de/lics16/ titleThirty-First Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2016/a>br/>span classlinklist idAtigChistikovHofmanKumarSaivasanZetzsche2015a-linklist styledisplay:none;>[ span classjsbutton>a idAtigChistikovHofmanKumarSaivasanZetzsche2015a-bibtex-show  hrefjavascript:toggle(AtigChistikovHofmanKumarSaivasanZetzsche2015a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idAtigChistikovHofmanKumarSaivasanZetzsche2015a-bibtex-hide hrefjavascript:toggle(AtigChistikovHofmanKumarSaivasanZetzsche2015a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idAtigChistikovHofmanKumarSaivasanZetzsche2015a-abstract-show  hrefjavascript:toggle(AtigChistikovHofmanKumarSaivasanZetzsche2015a-abstract)>Show abstract/a>/span>span classjsbutton>a idAtigChistikovHofmanKumarSaivasanZetzsche2015a-abstract-hide hrefjavascript:toggle(AtigChistikovHofmanKumarSaivasanZetzsche2015a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/1602.03419 title1602.03419>arXiv/a> ]br/>/span>script typetext/javascript>document.getElementById(AtigChistikovHofmanKumarSaivasanZetzsche2015a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/AtigChistikovHofmanKumarSaivasanZetzsche2015a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1602.03419 title1602.03419>arXiv/a> ]br/>/span>/noscript>div classabstract idAtigChistikovHofmanKumarSaivasanZetzsche2015a-abstract>span classabstractheading>Abstract/span>br/>		We study the computational and descriptional complexity		of the following transformation: Given a one-counter automaton (OCA) A,		construct a nondeterministic finite automaton (NFA) B		that recognizes an abstraction of the language of A:		its (1) downward closure, (2) upward closure, or (3) Parikh image.		For the Parikh image over a fixed alphabet and for the upward and		downward closures, we find polynomial-time algorithms that compute		such an NFA.  For the Parikh image with the alphabet as part of		the input, we find a quasi-polynomial time algorithm and prove		a completeness result: we construct a sequence of OCA that admits		a polynomial-time algorithm iff there is one for all OCA.		For all three abstractions, it was previously unknown		if appropriate NFA of sub-exponential size exist.	/div>script typetext/javascript>document.getElementById(AtigChistikovHofmanKumarSaivasanZetzsche2015a-abstract).style.displaynone;/script>div idAtigChistikovHofmanKumarSaivasanZetzsche2015a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{AtigChistikovHofmanKumarSaivasanZetzsche2015a,	AUTHOR		 {Atig, Mohamed Faouzi and Chistikov, Dmitry and Hofman, Piotr and Kumar, K Narayan and Saivasan, Prakash and Zetzsche, Georg},	TITLE		 {The complexity of regular abstractions of one-counter languages},	YEAR		 {2016},	PAGES		 {207--216},	PUBLISHER	 {ACM},	ADDRESS	 {New York, NY, USA},	BOOKTITLE	 {Proc. of the Thirty-First Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2016)}}/pre>/div>/div>br/>div classentry>span classtitle>First-order logic with reachability for infinite-state systems/span>br/>with a hrefhttp://emanueledosualdo.com/>Emanuele DOsualdo/a> and a hrefhttp://www.tcs.cs.tu-bs.de/group/meyer/home.html>Roland Meyer/a>br/>Proceedings of a hrefhttp://lics.rwth-aachen.de/lics16/ titleThirty-First Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2016/a>br/>span classlinklist idDOsualdoMeyerZetzsche2016a-linklist styledisplay:none;>[ span classjsbutton>a idDOsualdoMeyerZetzsche2016a-bibtex-show  hrefjavascript:toggle(DOsualdoMeyerZetzsche2016a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idDOsualdoMeyerZetzsche2016a-bibtex-hide hrefjavascript:toggle(DOsualdoMeyerZetzsche2016a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idDOsualdoMeyerZetzsche2016a-abstract-show  hrefjavascript:toggle(DOsualdoMeyerZetzsche2016a-abstract)>Show abstract/a>/span>span classjsbutton>a idDOsualdoMeyerZetzsche2016a-abstract-hide hrefjavascript:toggle(DOsualdoMeyerZetzsche2016a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/DOsualdoMeyerZetzsche2016a.pdf titleVersion >PDF/a> ]br/>/span>script typetext/javascript>document.getElementById(DOsualdoMeyerZetzsche2016a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/DOsualdoMeyerZetzsche2016a.bib>BibTeX/a> | a hrefdoc/DOsualdoMeyerZetzsche2016a.pdf titleVersion >PDF/a> ]br/>/span>/noscript>div classabstract idDOsualdoMeyerZetzsche2016a-abstract>span classabstractheading>Abstract/span>br/>		First-order logic with the reachability predicate (FOR)		is an important means of specification in system analysis.		Its decidability status is known for some individual		types of infinite-state systems such as pushdown (decidable)		and vector addition systems (undecidable).				This work aims at a general understanding of which types of		systems admit decidability.  As a unifying model, we employ		valence systems over graph monoids, which feature a		finite-state control and are parameterized by a monoid to		represent their storage mechanism.  As special cases, this		includes pushdown systems, various types of counter systems		(such as vector addition systems) and combinations thereof.		Our main result is a complete characterization of those		graph monoids where FOR is decidable for the resulting		transition systems.	/div>script typetext/javascript>document.getElementById(DOsualdoMeyerZetzsche2016a-abstract).style.displaynone;/script>div idDOsualdoMeyerZetzsche2016a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{DOsualdoMeyerZetzsche2016a,	AUTHOR		 {DOsualdo, Emanuele and Meyer, Roland and Zetzsche, Georg},	TITLE		 {First-order logic with reachability for infinite-state systems},	YEAR		 {2016},	PAGES		 {457--466},	PUBLISHER	 {ACM},	ADDRESS	 {New York, NY, USA},	BOOKTITLE	 {Proc. of the Thirty-First Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2016)}}/pre>/div>/div>br/>div classentry>span classtitle>Knapsack in Graph Groups, HNN-Extensions and Amalgamated Products/span>br/>with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>br/>Proceedings of a hrefhttp://www.univ-orleans.fr/lifo/events/STACS2016/ title33rd International Symposium on Theoretical Aspects of Computer Science>STACS 2016/a>br/>span classlinklist idLohreyZetzsche2016a-linklist styledisplay:none;>[ span classjsbutton>a idLohreyZetzsche2016a-bibtex-show  hrefjavascript:toggle(LohreyZetzsche2016a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idLohreyZetzsche2016a-bibtex-hide hrefjavascript:toggle(LohreyZetzsche2016a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idLohreyZetzsche2016a-abstract-show  hrefjavascript:toggle(LohreyZetzsche2016a-abstract)>Show abstract/a>/span>span classjsbutton>a idLohreyZetzsche2016a-abstract-hide hrefjavascript:toggle(LohreyZetzsche2016a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2016.50 title10.4230/LIPIcs.STACS.2016.50>DOI/a> | a hrefhttp://arxiv.org/abs/1509.05957 title1509.05957>arXiv/a> | a hrefdoc/LohreyZetzsche2016a-conference.pdf titleVersion >PDF (conference)/a> | a hrefdoc/LohreyZetzsche2016a-full.pdf titleVersion >PDF (full)/a> | a hrefdoc/STACS2016-LohreyZetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(LohreyZetzsche2016a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/LohreyZetzsche2016a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2016.50 title10.4230/LIPIcs.STACS.2016.50>DOI/a> | a hrefhttp://arxiv.org/abs/1509.05957 title1509.05957>arXiv/a> | a hrefdoc/LohreyZetzsche2016a-conference.pdf titleVersion >PDF (conference)/a> | a hrefdoc/LohreyZetzsche2016a-full.pdf titleVersion >PDF (full)/a> | a hrefdoc/STACS2016-LohreyZetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idLohreyZetzsche2016a-abstract>span classabstractheading>Abstract/span>br/>		It is shown that the knapsack problem, which was introduced by Myasnikov et al.		for arbitrary finitely generated groups, can be solved in NP for graph		groups. This result even holds if the group elements are represented in a		compressed form by SLPs, which generalizes the classical NP-completeness		result of the integer knapsack problem. We also prove general transfer results:		NP-membership of the knapsack problem is passed on to finite		extensions, HNN-extensions over finite associated subgroups, and amalgamated		products with finite identified subgroups.	/div>script typetext/javascript>document.getElementById(LohreyZetzsche2016a-abstract).style.displaynone;/script>div idLohreyZetzsche2016a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{LohreyZetzsche2016a,	AUTHOR		 {Lohrey, Markus and Zetzsche, Georg},	TITLE		 {Knapsack in Graph Groups, HNN-Extensions and Amalgamated Products},	PAGES		 {50:1--50:14},	SERIES		 {Leibniz International Proceedings in Informatics (LIPIcs)},	EDITOR		 {Nicolas Ollinger and Heribert Vollmer},	ADDRESS	 {Dagstuhl, Germany},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},	VOLUME		 {47},	BOOKTITLE	 {Proc. of the 33rd International Symposium on Theoretical Aspects of Computer Science (STACS 2016)},	YEAR		 {2016},	DOI		 {10.4230/LIPIcs.STACS.2016.50}}/pre>/div>/div>br/>div classentry>span classtitle>The Emptiness Problem for Valence Automata or: Another Decidable Extension of Petri Nets/span>br/>Proceedings of a hrefhttp://rp2015.mimuw.edu.pl/ title9th International Workshop on Reachability Problems>RP 2015/a>br/>span classlinklist idZetzsche2015c-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2015c-bibtex-show  hrefjavascript:toggle(Zetzsche2015c-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2015c-bibtex-hide hrefjavascript:toggle(Zetzsche2015c-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2015c-abstract-show  hrefjavascript:toggle(Zetzsche2015c-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2015c-abstract-hide hrefjavascript:toggle(Zetzsche2015c-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1007/978-3-319-24537-9_15 title10.1007/978-3-319-24537-9_15>DOI/a> | a hrefdoc/Zetzsche2015c.pdf titleVersion >PDF/a> | a hrefdoc/Zetzsche2015c-full.pdf titleVersion >PDF (full)/a> | a hrefdoc/RP2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2015c-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2015c.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1007/978-3-319-24537-9_15 title10.1007/978-3-319-24537-9_15>DOI/a> | a hrefdoc/Zetzsche2015c.pdf titleVersion >PDF/a> | a hrefdoc/Zetzsche2015c-full.pdf titleVersion >PDF (full)/a> | a hrefdoc/RP2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idZetzsche2015c-abstract>span classabstractheading>Abstract/span>br/>	This work studies which storage mechanisms in automata permit	decidability of the reachability problem. The question is formalized	using valence automata, an abstract model that generalizes automata with	storage. For each of a variety of storage mechanisms, one can choose a	(typically infinite) monoid $M$ such that valence automata over $M$ are	equivalent to (one-way) automata with this type of storage.	br/>	In fact, many interesting storage mechanisms can be realized by monoids defined	by finite graphs, called graph monoids.  Hence, we study for which graph	monoids the emptiness problem for valence automata is decidable. A particular	model realized by graph monoids is that of Petri nets with a pushdown stack.	For these, decidability is a long-standing open question and we do not answer	it here.	br/>	However, if one excludes subgraphs corresponding to this model, a	characterization can be achieved. This characterization yields a new extension	of Petri nets with a decidable reachability problem.  Moreover, we provide a	description of those storage mechanisms for which decidability remains open.	This leads to a natural model that generalizes both pushdown Petri nets and	priority multicounter machines.	/div>script typetext/javascript>document.getElementById(Zetzsche2015c-abstract).style.displaynone;/script>div idZetzsche2015c-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{Zetzsche2015c,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {The Emptiness Problem for Valence Automata or: Another Decidable Extension of Petri Nets},	EDITOR		 {Miko{\l}aj Boja{\{n}}czyk and S{\l}awomir Lasota and Igor Potapov},	SERIES		 {LNCS},	VOLUME		 {9328},	PAGES		 {166--178},	PUBLISHER	 {Springer},	ADDRESS	 {Berlin Heidelberg},	BOOKTITLE	 {Proc. of the 9th International Workshop on Reachability Problems (RP 2015)},	YEAR		 {2015},	DOI		 {10.1007/978-3-319-24537-9_15}}/pre>/div>/div>br/>div classentry>span classtitle>An Approach to Computing Downward Closures/span>br/>Proceedings of a hrefhttp://www.kurims.kyoto-u.ac.jp/icalp2015/ title42nd International Colloquium on Automata, Languages and Programming>ICALP 2015/a>br/>span classaward>Best Student Paper Award in Track B/span>br/>span classlinklist idZetzsche2015b-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2015b-bibtex-show  hrefjavascript:toggle(Zetzsche2015b-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2015b-bibtex-hide hrefjavascript:toggle(Zetzsche2015b-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2015b-abstract-show  hrefjavascript:toggle(Zetzsche2015b-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2015b-abstract-hide hrefjavascript:toggle(Zetzsche2015b-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1007/978-3-662-47666-6_35 title10.1007/978-3-662-47666-6_35>DOI/a> | a hrefhttp://arxiv.org/abs/1503.01068 title1503.01068>arXiv/a> | a hrefdoc/Zetzsche2015b.pdf titleVersion >PDF (full)/a> | a hrefdoc/ICALP2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2015b-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2015b.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1007/978-3-662-47666-6_35 title10.1007/978-3-662-47666-6_35>DOI/a> | a hrefhttp://arxiv.org/abs/1503.01068 title1503.01068>arXiv/a> | a hrefdoc/Zetzsche2015b.pdf titleVersion >PDF (full)/a> | a hrefdoc/ICALP2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idZetzsche2015b-abstract>span classabstractheading>Abstract/span>br/>                The downward closure of a word language is the set                of all (not necessarily contiguous) subwords of its                members. It is well-known that the downward closure of                any language is regular. While the downward closure                appears to be a powerful abstraction, algorithms for                computing a finite automaton for the downward closure                of a given language have been established only for few                language classes.		br/>                This work presents a simple general method for computing                downward closures. For language classes that are closed                under rational transductions, it is shown that the                computation of downward closures can be reduced to                checking a certain unboundedness property.		br/>                This result is used to prove that downward closures                are computable for (i) every language class with                effectively semilinear Parikh images that are closed                under rational transductions, (ii) matrix languages,                and (iii) indexed languages (equivalently, languages                accepted by higher-order pushdown automata of order~2).	/div>script typetext/javascript>document.getElementById(Zetzsche2015b-abstract).style.displaynone;/script>div idZetzsche2015b-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{Zetzsche2015b,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {An Approach to Computing Downward Closures},	EDITOR		 {Magn{\{u}}s M. Halld{\{o}}rsson and Kazuo Iwama and Naoki Kobayashi and Bettina Speckmann},	SERIES		 {LNCS},	VOLUME		 {9135},	PAGES		 {440--451},	PUBLISHER	 {Springer},	ADDRESS	 {Berlin Heidelberg},	YEAR		 {2015},	BOOKTITLE	 {Proc. of the 42nd International Colloquium on Automata, Languages and Programming (ICALP 2015)},	DOI		 {10.1007/978-3-662-47666-6_35}}/pre>/div>/div>br/>div classentry>span classtitle>Computing downward closures for stacked counter automata/span>br/>Proceedings of a hrefhttp://www14.in.tum.de/STACS2015/ title32nd International Symposium on Theoretical Aspects of Computer Science>STACS 2015/a>br/>span classlinklist idZetzsche2015a-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2015a-bibtex-show  hrefjavascript:toggle(Zetzsche2015a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2015a-bibtex-hide hrefjavascript:toggle(Zetzsche2015a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2015a-abstract-show  hrefjavascript:toggle(Zetzsche2015a-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2015a-abstract-hide hrefjavascript:toggle(Zetzsche2015a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2015.743 title10.4230/LIPIcs.STACS.2015.743>DOI/a> | a hrefhttp://arxiv.org/abs/1409.7922 title1409.7922>arXiv/a> | a hrefdoc/Zetzsche2015a.pdf titleVersion >PDF/a> | a hrefdoc/STACS2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2015a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2015a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2015.743 title10.4230/LIPIcs.STACS.2015.743>DOI/a> | a hrefhttp://arxiv.org/abs/1409.7922 title1409.7922>arXiv/a> | a hrefdoc/Zetzsche2015a.pdf titleVersion >PDF/a> | a hrefdoc/STACS2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idZetzsche2015a-abstract>span classabstractheading>Abstract/span>br/>		The downward closure of a language $L$ of words is the set of all (not		necessarily contiguous) subwords of members of $L$. It is well known that the		downward closure of any language is regular. Although the downward		closure seems to be a promising abstraction, there are only few language		classes for which an automaton for the downward closure is known to be		computable.		br/>		It is shown here that for stacked counter automata, the downward closure is		computable.  Stacked counter automata are finite automata with a storage		mechanism obtained by \emph{adding blind counters} and \emph{building stacks}.		Hence, they generalize pushdown and blind counter automata.		br/>		The class of languages accepted by these automata are precisely those in the		hierarchy obtained from the context-free languages by alternating two closure		operators: imposing semilinear constraints and taking the algebraic extension.		The main tool for computing downward closures is the new concept of Parikh		annotations.  As a second application of Parikh annotations, it is shown that		the hierarchy above is strict at every level.	/div>script typetext/javascript>document.getElementById(Zetzsche2015a-abstract).style.displaynone;/script>div idZetzsche2015a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{Zetzsche2015a,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {Computing downward closures for stacked counter automata},	PAGES		 {743--756},	SERIES		 {Leibniz International Proceedings in Informatics (LIPIcs)},	EDITOR		 {Ernst W. Mayr and Nicolas Ollinger},	ADDRESS	 {Dagstuhl, Germany},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},	VOLUME		 {30},	BOOKTITLE	 {Proc. of the 32nd International Symposium on Theoretical Aspects of Computer Science (STACS 2015)},	YEAR		 {2015},	DOI		 {10.4230/LIPIcs.STACS.2015.743}}/pre>/div>/div>br/>div classentry>span classtitle>The Monoid of Queue Actions/span>br/>with a hrefhttp://www.tcs.ifi.lmu.de/mitarbeiter/martin-huschenbett>Martin Huschenbett/a> and a hrefhttp://eiche.theoinf.tu-ilmenau.de/kuske/>Dietrich Kuske/a>br/>Proceedings of a hrefhttp://www.inf.u-szeged.hu/mfcs2014/ title39th International Symposium on Mathematical Foundations of Computer Science>MFCS 2014/a>br/>span classlinklist idHuschenbettKuskeZetzsche2014a-linklist styledisplay:none;>[ span classjsbutton>a idHuschenbettKuskeZetzsche2014a-bibtex-show  hrefjavascript:toggle(HuschenbettKuskeZetzsche2014a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idHuschenbettKuskeZetzsche2014a-bibtex-hide hrefjavascript:toggle(HuschenbettKuskeZetzsche2014a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idHuschenbettKuskeZetzsche2014a-abstract-show  hrefjavascript:toggle(HuschenbettKuskeZetzsche2014a-abstract)>Show abstract/a>/span>span classjsbutton>a idHuschenbettKuskeZetzsche2014a-abstract-hide hrefjavascript:toggle(HuschenbettKuskeZetzsche2014a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1007/978-3-662-44522-8_29 title10.1007/978-3-662-44522-8_29>DOI/a> | a hrefhttp://arxiv.org/abs/1404.5479 title1404.5479>arXiv/a> | a hrefdoc/HuschenbettKuskeZetzsche2014a-conference.pdf titleVersion >PDF (conference)/a> | a hrefdoc/HuschenbettKuskeZetzsche2014a-full.pdf titleVersion >PDF (full)/a> ]br/>/span>script typetext/javascript>document.getElementById(HuschenbettKuskeZetzsche2014a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/HuschenbettKuskeZetzsche2014a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1007/978-3-662-44522-8_29 title10.1007/978-3-662-44522-8_29>DOI/a> | a hrefhttp://arxiv.org/abs/1404.5479 title1404.5479>arXiv/a> | a hrefdoc/HuschenbettKuskeZetzsche2014a-conference.pdf titleVersion >PDF (conference)/a> | a hrefdoc/HuschenbettKuskeZetzsche2014a-full.pdf titleVersion >PDF (full)/a> ]br/>/span>/noscript>div classabstract idHuschenbettKuskeZetzsche2014a-abstract>span classabstractheading>Abstract/span>br/>		We investigate the monoid of transformations that are induced by		sequences of writing to and reading from a queue storage. We describe		this monoid by means of a confluent and terminating semi-Thue system		and study some of its basic algebraic properties, e.g., conjugacy.		Moreover, we show that while several properties concerning its		rational subsets are undecidable, their uniform membership problem is		NL-complete. Furthermore, we present an algebraic characterization of		this monoids recognizable subsets. Finally, we prove that it is not		Thurston-automatic. 	/div>script typetext/javascript>document.getElementById(HuschenbettKuskeZetzsche2014a-abstract).style.displaynone;/script>div idHuschenbettKuskeZetzsche2014a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{HuschenbettKuskeZetzsche2014a,	AUTHOR		 {Huschenbett, Martin and Kuske, Dietrich and Zetzsche, Georg},	TITLE		 {The Monoid of Queue Actions},	BOOKTITLE	 {Proc. of the 39th International Symposium on Mathematical Foundations of Computer Science (MFCS 2014)},	VOLUME		 {8634},	EDITOR		 {Csuhaj-Varj{\{u}}, Erzs{\{e}}bet and Dietzfelbinger, Martin and {\{E}}sik, Zolt{\{a}}n},	SERIES		 {LNCS},	PUBLISHER	 {Springer},	ADDRESS	 {Berlin Heidelberg},	PAGES		 {340--351},	YEAR		 {2014},	DOI		 {10.1007/978-3-662-44522-8_29}}/pre>/div>/div>br/>div classentry>span classtitle>On Boolean closed full trios and rational Kripke frames/span>br/>with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>br/>Proceedings of a hrefhttp://stacs2014.sciencesconf.org/ title31st International Symposium on Theoretical Aspects of Computer Science>STACS 2014/a>br/>span classlinklist idLohreyZetzsche2014a-linklist styledisplay:none;>[ span classjsbutton>a idLohreyZetzsche2014a-bibtex-show  hrefjavascript:toggle(LohreyZetzsche2014a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idLohreyZetzsche2014a-bibtex-hide hrefjavascript:toggle(LohreyZetzsche2014a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idLohreyZetzsche2014a-abstract-show  hrefjavascript:toggle(LohreyZetzsche2014a-abstract)>Show abstract/a>/span>span classjsbutton>a idLohreyZetzsche2014a-abstract-hide hrefjavascript:toggle(LohreyZetzsche2014a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2014.530 title10.4230/LIPIcs.STACS.2014.530>DOI/a> | a hrefdoc/LohreyZetzsche2014a.pdf titleVersion >PDF/a> | a hrefdoc/STACS2014-LohreyZetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(LohreyZetzsche2014a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/LohreyZetzsche2014a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.4230/LIPIcs.STACS.2014.530 title10.4230/LIPIcs.STACS.2014.530>DOI/a> | a hrefdoc/LohreyZetzsche2014a.pdf titleVersion >PDF/a> | a hrefdoc/STACS2014-LohreyZetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idLohreyZetzsche2014a-abstract>span classabstractheading>Abstract/span>br/>		A Boolean closed full trio is a class of languages that is closed under the		Boolean operations (union, intersection, and complementation) and rational		transductions. It is well-known that the regular languages constitute such a		Boolean closed full trio. It is shown here that every such language class that		contains any non-regular language already includes the whole arithmetical		hierarchy (and even the one relative to this language).		br/>		A consequence of this result is that aside from the regular languages, no full		trio generated by one language is closed under complementation.		br/>		Our construction also shows that there is a fixed rational Kripke frame such		that assigning an arbitrary non-regular language to some variable allows the		definition of any language from the arithmetical hierarchy in the		corresponding Kripke structure using multimodal logic.	/div>script typetext/javascript>document.getElementById(LohreyZetzsche2014a-abstract).style.displaynone;/script>div idLohreyZetzsche2014a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{LohreyZetzsche2014a,	AUTHOR		 {Lohrey, Markus and Zetzsche, Georg},	TITLE		 {On {Boolean} closed full trios and rational {Kripke} frames},	BOOKTITLE	 {Proc. of the 31st International Symposium on Theoretical Aspects of Computer Science (STACS 2014)},	PAGES		 {530--541},	SERIES		 {Leibniz International Proceedings in Informatics (LIPIcs)},	VOLUME		 {25},	EDITOR		 {Mayr, Ernst W. and Portier, Natacha},	PUBLISHER	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},	ADDRESS	 {Dagstuhl, Germany},	YEAR		 {2014},	DOI		 {10.4230/LIPIcs.STACS.2014.530}}/pre>/div>/div>br/>div classentry>span classtitle>Semilinearity and Context-Freeness of Languages Accepted by Valence Automata/span>br/>with Phoebe Buckheisterbr/>Proceedings of a hrefhttp://ist.ac.at/mfcs13/ title38th International Symposium on Mathematical Foundations of Computer Science>MFCS 2013/a>br/>span classlinklist idBuckheisterZetzsche2013a-linklist styledisplay:none;>[ span classjsbutton>a idBuckheisterZetzsche2013a-bibtex-show  hrefjavascript:toggle(BuckheisterZetzsche2013a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBuckheisterZetzsche2013a-bibtex-hide hrefjavascript:toggle(BuckheisterZetzsche2013a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBuckheisterZetzsche2013a-abstract-show  hrefjavascript:toggle(BuckheisterZetzsche2013a-abstract)>Show abstract/a>/span>span classjsbutton>a idBuckheisterZetzsche2013a-abstract-hide hrefjavascript:toggle(BuckheisterZetzsche2013a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1007/978-3-642-40313-2_22 title10.1007/978-3-642-40313-2_22>DOI/a> | a hrefhttp://arxiv.org/abs/1306.3260 title1306.3260>arXiv/a> | a hrefdoc/BuckheisterZetzsche2013a-conference.pdf titleVersion >PDF (conference)/a> | a hrefdoc/BuckheisterZetzsche2013a-full.pdf titleVersion >PDF (full)/a> | a hrefdoc/MFCS2013-BuckheisterZetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(BuckheisterZetzsche2013a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BuckheisterZetzsche2013a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1007/978-3-642-40313-2_22 title10.1007/978-3-642-40313-2_22>DOI/a> | a hrefhttp://arxiv.org/abs/1306.3260 title1306.3260>arXiv/a> | a hrefdoc/BuckheisterZetzsche2013a-conference.pdf titleVersion >PDF (conference)/a> | a hrefdoc/BuckheisterZetzsche2013a-full.pdf titleVersion >PDF (full)/a> | a hrefdoc/MFCS2013-BuckheisterZetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idBuckheisterZetzsche2013a-abstract>span classabstractheading>Abstract/span>br/>		Valence automata are a generalization of various models of automata with		storage.  Here, each edge carries, in addition to an input word, an element of		a monoid. A computation is considered valid if multiplying the monoid elements		on the visited edges yields the identity element. By choosing suitable		monoids, a variety of automata models can be obtained as special valence		automata.		This work is concerned with the accepting power of valence automata.		Specifically, we ask for which monoids valence automata can accept only		context-free languages or only languages with semilinear Parikh image,		respectively.		First, we present a characterization of those graph products (of monoids) for		which valence automata accept only context-free languages. Second, we provide a		necessary and sufficient condition for a graph product of copies of the		bicyclic monoid and the integers to yield only languages with semilinear Parikh		image when used as a storage mechanism in valence automata. Third, we show that		all languages accepted by valence automata over torsion groups have a		semilinear Parikh image.	/div>script typetext/javascript>document.getElementById(BuckheisterZetzsche2013a-abstract).style.displaynone;/script>div idBuckheisterZetzsche2013a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{BuckheisterZetzsche2013a,	AUTHOR		 {Buckheister, P. and Zetzsche, Georg},	TITLE		 {Semilinearity and Context-Freeness of Languages Accepted by Valence Automata},	YEAR		 {2013},	BOOKTITLE	 {Proc. of the 38th International Symposium on Mathematical Foundations of Computer Science (MFCS 2013)},	EDITOR		 {Chatterjee, Krishnendu and Sgall, Jir{\{i}}},	PUBLISHER	 {Springer},	ADDRESS	 {Berlin Heidelberg},	PAGES		 {231--242},	VOLUME		 {8087},	SERIES		 {LNCS},	DOI		 {10.1007/978-3-642-40313-2_22}}/pre>/div>/div>br/>div classentry>span classtitle>Rational Subsets and Submonoids of Wreath Products/span>br/>with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a> and a hrefhttp://www.sci.ccny.cuny.edu/~benjamin/>Benjamin Steinberg/a>br/>Proceedings of a hrefhttp://www.icalp2013.lu.lv/ title40th International Colloquium on Automata, Languages and Programming>ICALP 2013/a>br/>span classlinklist idLohreySteinbergZetzsche2013a-linklist styledisplay:none;>[ span classjsbutton>a idLohreySteinbergZetzsche2013a-bibtex-show  hrefjavascript:toggle(LohreySteinbergZetzsche2013a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idLohreySteinbergZetzsche2013a-bibtex-hide hrefjavascript:toggle(LohreySteinbergZetzsche2013a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idLohreySteinbergZetzsche2013a-abstract-show  hrefjavascript:toggle(LohreySteinbergZetzsche2013a-abstract)>Show abstract/a>/span>span classjsbutton>a idLohreySteinbergZetzsche2013a-abstract-hide hrefjavascript:toggle(LohreySteinbergZetzsche2013a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1007/978-3-642-39212-2_33 title10.1007/978-3-642-39212-2_33>DOI/a> | a hrefhttp://arxiv.org/abs/1302.2455 title1302.2455>arXiv/a> | a hrefdoc/LohreySteinbergZetzsche2013a.pdf titleVersion >PDF/a> | a hrefdoc/ICALP2013-LohreySteinbergZetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(LohreySteinbergZetzsche2013a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/LohreySteinbergZetzsche2013a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1007/978-3-642-39212-2_33 title10.1007/978-3-642-39212-2_33>DOI/a> | a hrefhttp://arxiv.org/abs/1302.2455 title1302.2455>arXiv/a> | a hrefdoc/LohreySteinbergZetzsche2013a.pdf titleVersion >PDF/a> | a hrefdoc/ICALP2013-LohreySteinbergZetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idLohreySteinbergZetzsche2013a-abstract>span classabstractheading>Abstract/span>br/>		It is shown that membership in rational subsets of wreath		products $H \wr V$ with $H$ a finite group and $V$ a virtually		free group is decidable. On the other hand, it is shown that		there exists a fixed finitely generated submonoid in the wreath		product $\mathbb{Z}\wr\mathbb{Z}$ with an undecidable		membership problem.	/div>script typetext/javascript>document.getElementById(LohreySteinbergZetzsche2013a-abstract).style.displaynone;/script>div idLohreySteinbergZetzsche2013a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{LohreySteinbergZetzsche2013a,	AUTHOR		 {Lohrey, Markus and Steinberg, Benjamin and Zetzsche, Georg},	TITLE		 {Rational Subsets and Submonoids of Wreath Products},	BOOKTITLE	 {Proc. of the 40th International Colloquium on Automata, Languages and Programming (ICALP 2013)},	EDITOR		 {Fedor V. Fomin and R{\{u}}si{\c{n}}{\v{s}} Freivalds and Marta Kwiatkowska and David Peleg},	PUBLISHER	 {Springer},	ADDRESS	 {Berlin Heidelberg},	VOLUME		 {7966},	SERIES		 {LNCS},	YEAR		 {2013},	PAGES		 {361--372},	DOI		 {10.1007/978-3-642-39212-2_33}}/pre>/div>/div>br/>div classentry>span classtitle>Silent Transitions in Automata with Storage/span>br/>Proceedings of a hrefhttp://www.icalp2013.lu.lv/ title40th International Colloquium on Automata, Languages and Programming>ICALP 2013/a>br/>span classlinklist idZetzsche2013a-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2013a-bibtex-show  hrefjavascript:toggle(Zetzsche2013a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2013a-bibtex-hide hrefjavascript:toggle(Zetzsche2013a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2013a-abstract-show  hrefjavascript:toggle(Zetzsche2013a-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2013a-abstract-hide hrefjavascript:toggle(Zetzsche2013a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1007/978-3-642-39212-2_39 title10.1007/978-3-642-39212-2_39>DOI/a> | a hrefhttp://arxiv.org/abs/1302.3798 title1302.3798>arXiv/a> | a hrefdoc/ICALP2013-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2013a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2013a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1007/978-3-642-39212-2_39 title10.1007/978-3-642-39212-2_39>DOI/a> | a hrefhttp://arxiv.org/abs/1302.3798 title1302.3798>arXiv/a> | a hrefdoc/ICALP2013-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idZetzsche2013a-abstract>span classabstractheading>Abstract/span>br/>		We consider the computational power of silent transitions in one-way automata		with storage.  Specifically, we ask which storage mechanisms admit a		transformation of a given automaton into one that accepts the same language		and reads at least one input symbol in each step.		br/>		We study this question using the model of valence automata.  Here, a finite		automaton is equipped with a storage mechanism that is given by a monoid.		br/>		This work presents generalizations of known results on silent transitions.		For two classes of monoids, it provides characterizations of those monoids that		allow the removal of silent transitions.  Both classes are defined by		graph products of copies of the bicyclic monoid and the group of integers.  The		first class contains pushdown storages as well as the blind counters while the		second class contains the blind and the partially blind counters.	/div>script typetext/javascript>document.getElementById(Zetzsche2013a-abstract).style.displaynone;/script>div idZetzsche2013a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{Zetzsche2013a,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {Silent Transitions in Automata with Storage},	BOOKTITLE	 {Proc. of the 40th International Colloquium on Automata, Languages and Programming (ICALP 2013)},	EDITOR		 {Fedor V. Fomin and R{\{u}}si{\c{n}}{\v{s}} Freivalds and Marta Kwiatkowska and David Peleg},	PUBLISHER	 {Springer},	ADDRESS	 {Berlin Heidelberg},	VOLUME		 {7966},	SERIES		 {LNCS},	YEAR		 {2013},	PAGES		 {434--445},	DOI		 {10.1007/978-3-642-39212-2_39}}/pre>/div>/div>br/>div classentry>span classtitle>A Sufficient Condition for Erasing Productions to Be Avoidable/span>br/>Proceedings of a hrefhttp://dlt2011.disco.unimib.it/ title15th International Conference on Developments in Language Theory>DLT 2011/a>br/>span classlinklist idZetzsche2011c-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2011c-bibtex-show  hrefjavascript:toggle(Zetzsche2011c-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2011c-bibtex-hide hrefjavascript:toggle(Zetzsche2011c-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2011c-abstract-show  hrefjavascript:toggle(Zetzsche2011c-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2011c-abstract-hide hrefjavascript:toggle(Zetzsche2011c-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1007/978-3-642-22321-1_39 title10.1007/978-3-642-22321-1_39>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2011c-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2011c.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1007/978-3-642-22321-1_39 title10.1007/978-3-642-22321-1_39>DOI/a> ]br/>/span>/noscript>div classabstract idZetzsche2011c-abstract>span classabstractheading>Abstract/span>br/>		In each grammar model, it is an important question whether erasing productions		are necessary to generate all languages.  Using the concept of grammars with		control languages by Salomaa, which offers a uniform treatment of a variety of		grammar models, we present a condition on the class of control languages that		guarantees that erasing productions are avoidable in the resulting grammar		model. On the one hand, this generalizes the previous result that in Petri net		controlled grammars, erasing productions can be eliminated. On the other hand,		it allows us to infer that the same is true for vector grammars.	/div>script typetext/javascript>document.getElementById(Zetzsche2011c-abstract).style.displaynone;/script>div idZetzsche2011c-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{Zetzsche2011c,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {A Sufficient Condition for Erasing Productions to Be Avoidable},	BOOKTITLE	 {Proc. of the 15th International Conference on Developments in Language Theory (DLT 2011)},	EDITOR		 {Giancarlo Mauri and Alberto Leporati},	PUBLISHER	 {Springer},	ADDRESS	 {Berlin Heidelberg},	VOLUME		 {6795},	SERIES		 {LNCS},	PAGES		 {452--463},	YEAR		 {2011},	DOI		 {10.1007/978-3-642-22321-1_39}}/pre>/div>/div>br/>div classentry>span classtitle>On the Capabilities of Grammars, Automata, and Transducers Controlled by Monoids/span>br/>Proceedings of a hrefhttp://icalp11.inf.ethz.ch/ title38th International Colloquium on Automata, Languages and Programming>ICALP 2011/a>br/>span classlinklist idZetzsche2011b-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2011b-bibtex-show  hrefjavascript:toggle(Zetzsche2011b-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2011b-bibtex-hide hrefjavascript:toggle(Zetzsche2011b-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2011b-abstract-show  hrefjavascript:toggle(Zetzsche2011b-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2011b-abstract-hide hrefjavascript:toggle(Zetzsche2011b-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/1103.3361 title1103.3361>arXiv/a> | a hrefhttp://dx.doi.org/10.1007/978-3-642-22012-8_17 title10.1007/978-3-642-22012-8_17>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2011b-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2011b.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1103.3361 title1103.3361>arXiv/a> | a hrefhttp://dx.doi.org/10.1007/978-3-642-22012-8_17 title10.1007/978-3-642-22012-8_17>DOI/a> ]br/>/span>/noscript>div classabstract idZetzsche2011b-abstract>span classabstractheading>Abstract/span>br/>		During recent decades, classical models in language theory have been extended		by control mechanisms defined by monoids.  We study which monoids cause the		extensions of context-free grammars, finite automata, or finite state		transducers to exceed the capacity of the original model.  Furthermore, we		investigate when, in the extended automata model, the nondeterministic variant		differs from the deterministic one in capacity.  We show that all these		conditions are in fact equivalent and present an algebraic characterization. In		particular, the open question of whether every language generated by a valence		grammar over a finite monoid is context-free is provided with a positive		answer.	/div>script typetext/javascript>document.getElementById(Zetzsche2011b-abstract).style.displaynone;/script>div idZetzsche2011b-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{Zetzsche2011b,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {On the Capabilities of Grammars, Automata, and Transducers Controlled by Monoids},	BOOKTITLE	 {Proc. of the 38th International Colloquium on Automata, Languages and Programming (ICALP 2011)},	EDITOR		 {Luca Aceto et al.},	PUBLISHER	 {Springer},	ADDRESS	 {Berlin Heidelberg},	VOLUME		 {6756},	SERIES		 {LNCS},	PAGES		 {222--233},	YEAR		 {2011},	DOI		 {10.1007/978-3-642-22012-8_17}}/pre>/div>/div>br/>div classentry>span classtitle>On Erasing Productions in Random Context Grammars/span>br/>Proceedings of a hrefhttp://icalp10.inria.fr/ title37th International Colloquium on Automata, Languages and Programming>ICALP 2010/a>br/>span classlinklist idZetzsche2010-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2010-bibtex-show  hrefjavascript:toggle(Zetzsche2010-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2010-bibtex-hide hrefjavascript:toggle(Zetzsche2010-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2010-abstract-show  hrefjavascript:toggle(Zetzsche2010-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2010-abstract-hide hrefjavascript:toggle(Zetzsche2010-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1007/978-3-642-14162-1_15 title10.1007/978-3-642-14162-1_15>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2010-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2010.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1007/978-3-642-14162-1_15 title10.1007/978-3-642-14162-1_15>DOI/a> ]br/>/span>/noscript>div classabstract idZetzsche2010-abstract>span classabstractheading>Abstract/span>br/>		Three open questions in the theory of regulated		rewriting are addressed.  The first is whether every		permitting random context grammar has a non-erasing		equivalent.  The second asks whether the same is true		for matrix grammars without appearance checking.  The		third concerns whether permitting random context		grammars have the same generative capacity as matrix		grammars without appearance checking.				The main result is a positive answer to the first		question. For the other two, conjectures are		presented. It is then deduced from the main result		that at least one of the two holds.	/div>script typetext/javascript>document.getElementById(Zetzsche2010-abstract).style.displaynone;/script>div idZetzsche2010-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{Zetzsche2010,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {On Erasing Productions in Random Context Grammars},	BOOKTITLE	 {Proc. of the 37th International Colloquium on Automata, Languages and Programming (ICALP 2010)},	EDITOR		 {        Abramsky, Samson and        Gavoille, Cyril and        Kirchner, Claude and        Meyer auf der Heide, Friedhelm and        Spirakis, Paul 	},	VOLUME		 {6199},	SERIES		 {LNCS},	PUBLISHER	 {Springer},	ADDRESS	 {Berlin Heidelberg},	PAGES		 {175--186},	YEAR		 {2010},	DOI		 {10.1007/978-3-642-14162-1_15}}/pre>/div>/div>br/>div classentry>span classtitle>Erasing in Petri Net Languages and Matrix Grammars/span>br/>Proceedings of a hrefhttp://www-dlt2009.informatik.uni-stuttgart.de/ title13th International Conference on Developments in Language Theory>DLT 2009/a>br/>span classlinklist idZetzsche09-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche09-bibtex-show  hrefjavascript:toggle(Zetzsche09-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche09-bibtex-hide hrefjavascript:toggle(Zetzsche09-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche09-abstract-show  hrefjavascript:toggle(Zetzsche09-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche09-abstract-hide hrefjavascript:toggle(Zetzsche09-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1007/978-3-642-02737-6_40 title10.1007/978-3-642-02737-6_40>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche09-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche09.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1007/978-3-642-02737-6_40 title10.1007/978-3-642-02737-6_40>DOI/a> ]br/>/span>/noscript>div classabstract idZetzsche09-abstract>span classabstractheading>Abstract/span>br/>		It is shown that applying linear erasing to a Petri net		language yields a language generated by a non-erasing		matrix grammar.  The proof uses Petri net controlled		grammars. These are context-free grammars, where the		application of productions has to comply with a firing		sequence in a Petri net. Petri net controlled grammars are		equivalent to arbitrary matrix grammars (without		appearance checking), but a certain restriction on them		(linear Petri net controlled grammars) leads to the class		of languages generated by non-erasing matrix grammars.				It is also shown that in Petri net controlled grammars		(with final markings and arbitrary labeling), erasing		rules can be eliminated, which yields a reformulation of		the problem of whether erasing rules in matrix grammars		can be eliminated.	/div>script typetext/javascript>document.getElementById(Zetzsche09-abstract).style.displaynone;/script>div idZetzsche09-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{Zetzsche09,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {Erasing in {Petri} Net Languages and Matrix Grammars},	BOOKTITLE	 {Proc. of the 13th International Conference on Developments in Language Theory (DLT 2009)},	EDITOR		 {Diekert, Volker and Nowotka, Dirk},	PAGES		 {490--501},	VOLUME		 {5583},	YEAR		 {2009},	SERIES		 {LNCS},	PUBLISHER	 {Springer},	ADDRESS	 {Berlin Heidelberg},	DOI		 {10.1007/978-3-642-02737-6_40}}/pre>/div>/div>br/>div classentry>span classtitle>Labeled Step Sequences in Petri Nets/span>br/>with a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/jantzen_eng.html>Matthias Jantzen/a>br/>Proceedings of a hrefhttp://ictt.xidian.edu.cn/atpn2008/Pages/ATPN_main.jsp titleInternational Conference on Applications and Theory of Petri nets>PETRI NETS 2008/a>br/>span classlinklist idJantzenZetzsche2008a-linklist styledisplay:none;>[ span classjsbutton>a idJantzenZetzsche2008a-bibtex-show  hrefjavascript:toggle(JantzenZetzsche2008a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idJantzenZetzsche2008a-bibtex-hide hrefjavascript:toggle(JantzenZetzsche2008a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idJantzenZetzsche2008a-abstract-show  hrefjavascript:toggle(JantzenZetzsche2008a-abstract)>Show abstract/a>/span>span classjsbutton>a idJantzenZetzsche2008a-abstract-hide hrefjavascript:toggle(JantzenZetzsche2008a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1007/978-3-540-68746-7_19 title10.1007/978-3-540-68746-7_19>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(JantzenZetzsche2008a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/JantzenZetzsche2008a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1007/978-3-540-68746-7_19 title10.1007/978-3-540-68746-7_19>DOI/a> ]br/>/span>/noscript>div classabstract idJantzenZetzsche2008a-abstract>span classabstractheading>Abstract/span>br/>		We compare various modes of firing transitions in Petri nets		and define classes of languages defined this way.  We define		languages through steps, i. e. sets of transitions, maximal		steps, multi-steps, and maximal multi-steps of transitions		in Petri nets, but in a different manner than those defined		in Burk 81a,Burk 83, by considering labeled transitions.		We will show that we obtain a hierarchy of families of		languages defined by multiple use of transition in firing		transitions in a single multistep.  Except for the maximal		multi-steps all classes can be simulated by sequential		firing of transitions.	/div>script typetext/javascript>document.getElementById(JantzenZetzsche2008a-abstract).style.displaynone;/script>div idJantzenZetzsche2008a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{JantzenZetzsche2008a,	AUTHOR		 {Jantzen, Matthias and Zetzsche, Georg},	TITLE		 {Labeled Step Sequences in Petri Nets},	BOOKTITLE	 {Proc. of the International Conference on Applications and Theory of Petri nets (PETRI NETS 2008)},	ADDRESS	 {Berlin Heidelberg},	YEAR		 {2008},	PAGES		 {270--287},	EDITOR		 {van Hee, Kees M. and Valk, R{\u}diger},	PUBLISHER	 {Springer},	VOLUME		 {5062},	SERIES		 {LNCS},	DOI		 {10.1007/978-3-540-68746-7_19}}/pre>/div>/div>br/>div classheading2>Journal articles/div>br/>div classentry>span classtitle>Existential definability over the subword ordering/span>br/>with Pascal Baumann, a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a>, and a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Logical Methods in Computer Science 19, 2023br/>span classlinklist idBaumannGanardiThinniyamZetzsche2023a-linklist styledisplay:none;>[ span classjsbutton>a idBaumannGanardiThinniyamZetzsche2023a-bibtex-show  hrefjavascript:toggle(BaumannGanardiThinniyamZetzsche2023a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBaumannGanardiThinniyamZetzsche2023a-bibtex-hide hrefjavascript:toggle(BaumannGanardiThinniyamZetzsche2023a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBaumannGanardiThinniyamZetzsche2023a-abstract-show  hrefjavascript:toggle(BaumannGanardiThinniyamZetzsche2023a-abstract)>Show abstract/a>/span>span classjsbutton>a idBaumannGanardiThinniyamZetzsche2023a-abstract-hide hrefjavascript:toggle(BaumannGanardiThinniyamZetzsche2023a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/2210.15642 title2210.15642>arXiv/a> | a hrefhttp://dx.doi.org/10.46298/lmcs-19(4:35)2023 title10.46298/lmcs-19(4:35)2023>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(BaumannGanardiThinniyamZetzsche2023a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BaumannGanardiThinniyamZetzsche2023a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/2210.15642 title2210.15642>arXiv/a> | a hrefhttp://dx.doi.org/10.46298/lmcs-19(4:35)2023 title10.46298/lmcs-19(4:35)2023>DOI/a> ]br/>/span>/noscript>div classabstract idBaumannGanardiThinniyamZetzsche2023a-abstract>span classabstractheading>Abstract/span>br/>		  We study first-order logic (FO) over the structure consisting of finite words  over some alphabet~$A$, together with the (non-contiguous) subword ordering.  In terms of decidability of quantifier alternation fragments, this logic is  well-understood: If every word is available as a constant, then even the  $\Sigma_1$ (i.e., existential) fragment is undecidable, already for binary  alphabets $A$.  However, up to now, little is known about the expressiveness of the  quantifier alternation fragments: For example, the undecidability proof for  the existential fragment relies on Diophantine equations and only  shows that recursively enumerable languages over a singleton alphabet (and  some auxiliary predicates) are definable.  We show that if $|A|\ge 3$, then a relation is definable in the existential  fragment over $A$ with constants if and only if it is recursively enumerable.  This implies characterizations for all fragments~$\Sigma_i$: If $|A|\ge 3$,  then a relation is definable in $\Sigma_i$ if and only if it belongs to the  $i$-th level of the arithmetical hierarchy.  In addition, our result yields  an analogous complete description of the $\Sigma_i$-fragments for $i\ge 2$ of  the \emph{pure logic}, where the words of $A^*$ are not available as  constants.	/div>script typetext/javascript>document.getElementById(BaumannGanardiThinniyamZetzsche2023a-abstract).style.displaynone;/script>div idBaumannGanardiThinniyamZetzsche2023a-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{BaumannGanardiThinniyamZetzsche2023a,	AUTHOR		 {Baumann, Pascal and Ganardi, Moses and Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {Existential definability over the subword ordering},	YEAR		 {2023},	JOURNAL	 {Logical Methods in Computer Science},	VOLUME		 {19},	DOI		 {10.46298/lmcs-19(4:35)2023}}/pre>/div>/div>br/>div classentry>span classtitle>Knapsack and the power word problem in Baumslag-Solitar Groups/span>br/>with a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a> and a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>br/>International Journal of Algebra and Computation 33, 2023br/>span classlinklist idGanardiLohreyZetzsche2023a-linklist styledisplay:none;>[ span classjsbutton>a idGanardiLohreyZetzsche2023a-bibtex-show  hrefjavascript:toggle(GanardiLohreyZetzsche2023a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idGanardiLohreyZetzsche2023a-bibtex-hide hrefjavascript:toggle(GanardiLohreyZetzsche2023a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idGanardiLohreyZetzsche2023a-abstract-show  hrefjavascript:toggle(GanardiLohreyZetzsche2023a-abstract)>Show abstract/a>/span>span classjsbutton>a idGanardiLohreyZetzsche2023a-abstract-hide hrefjavascript:toggle(GanardiLohreyZetzsche2023a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1142/S0218196723500285 title10.1142/S0218196723500285>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(GanardiLohreyZetzsche2023a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/GanardiLohreyZetzsche2023a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1142/S0218196723500285 title10.1142/S0218196723500285>DOI/a> ]br/>/span>/noscript>div classabstract idGanardiLohreyZetzsche2023a-abstract>span classabstractheading>Abstract/span>br/>		        We prove that the power word problem for certain metabelian subgroups of $GL(2,\mathbb{C})$ (including the        solvable Baumslag-Solitar groups $BS(1,q)  \langle a,t \mid t a t^{-1}  a^q \rangle$) belongs to the circuit complexity class        $TC^0$. In the power word problem, the input consists of group elements $g_1, \ldots, g_d$ and binary encoded integers        $n_1, \ldots, n_d$ and it is asked whether $g_1^{n_1} \cdots g_d^{n_d}  1$ holds.      Moreover, we prove that the knapsack problem        for $\BS(1,q)$ is $\NP$-complete. In the knapsack problem, the input consists of group elements $g_1, \ldots, g_d,h$        and it is asked whether the equation $g_1^{x_1} \cdots g_d^{x_d}  h$ has a solution in $\N^d$. For the more general case of a system        of so-called exponent equations, where the exponent variables $x_i$ can occur multiple times, we show that solvability is undecidable for        $BS(1,q)$.	/div>script typetext/javascript>document.getElementById(GanardiLohreyZetzsche2023a-abstract).style.displaynone;/script>div idGanardiLohreyZetzsche2023a-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{GanardiLohreyZetzsche2023a,	AUTHOR		 {Ganardi, Moses and Lohrey, Markus and Zetzsche, Georg},	TITLE		 {Knapsack and the power word problem in Baumslag-Solitar Groups},	YEAR		 {2023},	JOURNAL	 {International Journal of Algebra and Computation},	VOLUME		 {33},	PAGES		 {617--639},	DOI		 {10.1142/S0218196723500285}}/pre>/div>/div>br/>div classentry>span classtitle>Closure properties of knapsack semilinear groups/span>br/>with a hrefhttps://www.eti.uni-siegen.de/ti/mitarbeiter/figelius/>Michael Figelius/a> and a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>br/>Journal of Algebra 589, 2022br/>span classlinklist idFigeliusLohreyZetzsche2021a-linklist styledisplay:none;>[ span classjsbutton>a idFigeliusLohreyZetzsche2021a-bibtex-show  hrefjavascript:toggle(FigeliusLohreyZetzsche2021a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idFigeliusLohreyZetzsche2021a-bibtex-hide hrefjavascript:toggle(FigeliusLohreyZetzsche2021a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idFigeliusLohreyZetzsche2021a-abstract-show  hrefjavascript:toggle(FigeliusLohreyZetzsche2021a-abstract)>Show abstract/a>/span>span classjsbutton>a idFigeliusLohreyZetzsche2021a-abstract-hide hrefjavascript:toggle(FigeliusLohreyZetzsche2021a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/1911.12857 title1911.12857>arXiv/a> | a hrefhttp://dx.doi.org/10.1016/j.jalgebra.2021.08.016 title10.1016/j.jalgebra.2021.08.016>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(FigeliusLohreyZetzsche2021a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/FigeliusLohreyZetzsche2021a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1911.12857 title1911.12857>arXiv/a> | a hrefhttp://dx.doi.org/10.1016/j.jalgebra.2021.08.016 title10.1016/j.jalgebra.2021.08.016>DOI/a> ]br/>/span>/noscript>div classabstract idFigeliusLohreyZetzsche2021a-abstract>span classabstractheading>Abstract/span>br/>		A knapsack equation in a group $G$ is an equation of the form $g_1^{x_1}\cdots g_k^{x_k}g$, where $g_1,\ldots,g_k,g$ are elements of G and $x_1,\ldots,x_k$ are variables that take values in the natural numbers. We study the class of groups G for which all knapsack equations have effectively semilinear solution sets. We show that the following group constructions preserve effective semilinearity: graph products, amalgamated free products with finite amalgamated subgroups, HNN-extensions with finite associated subgroups, and finite extensions. Moreover, we study a complexity measure, called magnitude, of the resulting semilinear solution sets. More precisely, we are interested in the growth of the magnitude in terms of the length of the knapsack equation (measured in number of generators). We investigate how this growth changes under the above group operations.	/div>script typetext/javascript>document.getElementById(FigeliusLohreyZetzsche2021a-abstract).style.displaynone;/script>div idFigeliusLohreyZetzsche2021a-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{FigeliusLohreyZetzsche2021a,	AUTHOR		 {Figelius, Michael and Lohrey, Markus and Zetzsche, Georg},	TITLE		 {Closure properties of knapsack semilinear groups},	JOURNAL	 {Journal of Algebra},	VOLUME		 {589},	YEAR		 {2022},	PAGES		 {437--482},	DOI		 {10.1016/j.jalgebra.2021.08.016}}/pre>/div>/div>br/>div classentry>span classtitle>The Emptiness Problem for Valence Automata over Graph Monoids/span>br/>Information and Computation 277, 2021br/>Special Issue on a hrefhttp://rp2015.mimuw.edu.pl/ title9th International Workshop on Reachability Problems>RP 2015/a>br/>span classlinklist idZetzsche2021b-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2021b-bibtex-show  hrefjavascript:toggle(Zetzsche2021b-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2021b-bibtex-hide hrefjavascript:toggle(Zetzsche2021b-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2021b-abstract-show  hrefjavascript:toggle(Zetzsche2021b-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2021b-abstract-hide hrefjavascript:toggle(Zetzsche2021b-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/Zetzsche2021b.pdf titleVersion >PDF/a> | a hrefhttp://arxiv.org/abs/1710.07528 title1710.07528>arXiv/a> | a hrefhttp://dx.doi.org/10.1016/j.ic.2020.104583 title10.1016/j.ic.2020.104583>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2021b-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2021b.bib>BibTeX/a> | a hrefdoc/Zetzsche2021b.pdf titleVersion >PDF/a> | a hrefhttp://arxiv.org/abs/1710.07528 title1710.07528>arXiv/a> | a hrefhttp://dx.doi.org/10.1016/j.ic.2020.104583 title10.1016/j.ic.2020.104583>DOI/a> ]br/>/span>/noscript>div classabstract idZetzsche2021b-abstract>span classabstractheading>Abstract/span>br/>	    This work studies which storage mechanisms in automata	    permit decidability of the emptiness problem. The question	    is formalized using valence automata, an abstract model of	    automata in which the storage mechanism is given by a	    monoid. For each of a variety of storage mechanisms, one	    can choose a (typically infinite) monoid $M$ such that	    valence automata over $M$ are equivalent to (one-way)	    automata with this type of storage.  In fact, many	    important storage mechanisms can be realized by monoids	    defined by finite graphs, called graph monoids.  Examples	    include pushdown stacks, partially blind counters (which	    behave like Petri net places), blind counters (which may	    attain negative values), and combinations thereof.	    br/>	    Hence, we study for which graph monoids the emptiness	    problem for valence automata is decidable. A particular	    model realized by graph monoids is that of Petri nets with	    a pushdown stack.  For these, decidability is a	    long-standing open question and we do not answer it here.	    br/>	    However, if one excludes subgraphs corresponding to this	    model, a characterization can be achieved.  Moreover, we	    provide a description of those storage mechanisms for	    which decidability remains open.  This leads to a model	    that naturally generalizes both pushdown Petri nets and	    the priority multicounter machines introduced by	    Reinhardt.	    br/>	    The cases that are proven decidable constitute a natural	    and apparently new extension of Petri nets with decidable	    reachability. It is finally shown that this model can be	    combined with another such extension by Atig and Ganty: We	    present a further decidability result that subsumes both	    of these Petri net extensions.	/div>script typetext/javascript>document.getElementById(Zetzsche2021b-abstract).style.displaynone;/script>div idZetzsche2021b-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{Zetzsche2021b,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {The Emptiness Problem for Valence Automata over Graph Monoids},	YEAR		 {2021},	JOURNAL	 {Information and Computation},	VOLUME		 {277},	DOI		 {10.1016/j.ic.2020.104583}}/pre>/div>/div>br/>div classentry>span classtitle>General Decidability Results for Asynchronous Shared-Memory Programs: Higher-Order and Beyond/span>br/>with a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a> and a hrefhttps://people.mpi-sws.org/~thinniyam>Ramanathan S. Thinniyam/a>br/>Logical Methods in Computer Science 18, 2022br/>Special Issue on a hrefhttps://etaps.org/2021/tacas title27th International Conference on Tools and Algorithms for the Construction and Analysis of Systems>TACAS 2021/a>br/>span classlinklist idMajumdarThinniyamZetzsche2022a-linklist styledisplay:none;>[ span classjsbutton>a idMajumdarThinniyamZetzsche2022a-bibtex-show  hrefjavascript:toggle(MajumdarThinniyamZetzsche2022a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idMajumdarThinniyamZetzsche2022a-bibtex-hide hrefjavascript:toggle(MajumdarThinniyamZetzsche2022a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idMajumdarThinniyamZetzsche2022a-abstract-show  hrefjavascript:toggle(MajumdarThinniyamZetzsche2022a-abstract)>Show abstract/a>/span>span classjsbutton>a idMajumdarThinniyamZetzsche2022a-abstract-hide hrefjavascript:toggle(MajumdarThinniyamZetzsche2022a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.46298/lmcs-18(4:2)2022 title10.46298/lmcs-18(4:2)2022>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(MajumdarThinniyamZetzsche2022a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/MajumdarThinniyamZetzsche2022a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.46298/lmcs-18(4:2)2022 title10.46298/lmcs-18(4:2)2022>DOI/a> ]br/>/span>/noscript>div classabstract idMajumdarThinniyamZetzsche2022a-abstract>span classabstractheading>Abstract/span>br/>                The model of asynchronous programming arises in many contexts, from low-level systems software to high-level web programming. We take a language-theoretic perspective and show general decidability and undecidability results for asynchronous programs that capture all known results as well as show decidability of new and important classes. As a main consequence, we show decidability of safety, termination and boundedness verification for higher-order asynchronous programs -- such as OCaml programs using Lwt -- and undecidability of liveness verification already for order-2 asynchronous programs. We show that under mild assumptions, surprisingly, safety and termination verification of asynchronous programs with handlers from a language class are decidable iff emptiness is decidable for the underlying language class. Moreover, we show that configuration reachability and liveness (fair termination) verification are equivalent, and decidability of these problems implies decidability of the well-known equal-letters problem on languages. Our results close the decidability frontier for asynchronous programs.	/div>script typetext/javascript>document.getElementById(MajumdarThinniyamZetzsche2022a-abstract).style.displaynone;/script>div idMajumdarThinniyamZetzsche2022a-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{MajumdarThinniyamZetzsche2022a,	AUTHOR		 {Majumdar, Rupak and Thinniyam, Ramanathan S. and Zetzsche, Georg},	TITLE		 {General Decidability Results for Asynchronous Shared-Memory Programs: Higher-Order and Beyond},	YEAR		 {2022},	JOURNAL	 {Logical Methods in Computer Science},	VOLUME		 {18},	DOI		 {10.46298/lmcs-18(4:2)2022}}/pre>/div>/div>br/>div classentry>span classtitle>Knapsack in Graph Groups/span>br/>with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>br/>Theory of Computing Systems 62, 2018br/>Special Issue on a hrefhttp://www.univ-orleans.fr/lifo/events/STACS2016/ title33rd International Symposium on Theoretical Aspects of Computer Science>STACS 2016/a>br/>span classlinklist idLohreyZetzsche2017b-linklist styledisplay:none;>[ span classjsbutton>a idLohreyZetzsche2017b-bibtex-show  hrefjavascript:toggle(LohreyZetzsche2017b-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idLohreyZetzsche2017b-bibtex-hide hrefjavascript:toggle(LohreyZetzsche2017b-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idLohreyZetzsche2017b-abstract-show  hrefjavascript:toggle(LohreyZetzsche2017b-abstract)>Show abstract/a>/span>span classjsbutton>a idLohreyZetzsche2017b-abstract-hide hrefjavascript:toggle(LohreyZetzsche2017b-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/LohreyZetzsche2017b.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1007/s00224-017-9808-3 title10.1007/s00224-017-9808-3>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(LohreyZetzsche2017b-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/LohreyZetzsche2017b.bib>BibTeX/a> | a hrefdoc/LohreyZetzsche2017b.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1007/s00224-017-9808-3 title10.1007/s00224-017-9808-3>DOI/a> ]br/>/span>/noscript>div classabstract idLohreyZetzsche2017b-abstract>span classabstractheading>Abstract/span>br/>		It is shown that the knapsack problem, which was introduced by Myasnikov et al.		for arbitrary finitely generated groups, can be solved in {\sf NP} for every graph		group. This result even holds if the group elements are represented in a		compressed form by so called straight-line programs, which generalizes the classical {\sf NP}-completeness		result of the integer knapsack problem. If group elements are represented explicitly		by words over the generators, then knapsack for a graph group belongs the class		{\sf LogCFL} (a subclass of {\sf P}) if the graph group can be built up from the trivial		group using the operations of free product and direct product with $\Z$. In all other cases,		the knapsack problem is {\sf NP}-complete.	/div>script typetext/javascript>document.getElementById(LohreyZetzsche2017b-abstract).style.displaynone;/script>div idLohreyZetzsche2017b-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{LohreyZetzsche2017b,	AUTHOR		 {Lohrey, Markus and Zetzsche, Georg},	TITLE		 {Knapsack in Graph Groups},	YEAR		 {2018},	JOURNAL	 {Theory of Computing Systems},	VOLUME		 {62},	PAGES		 {192--246},	DOI		 {10.1007/s00224-017-9808-3},	NOTE		 {Combines papers at STACS 2016 {\&} 2017}}/pre>/div>/div>br/>div classentry>span classtitle>The Monoid of Queue Actions/span>br/>with a hrefhttp://www.tcs.ifi.lmu.de/mitarbeiter/martin-huschenbett>Martin Huschenbett/a> and a hrefhttp://eiche.theoinf.tu-ilmenau.de/kuske/>Dietrich Kuske/a>br/>Semigroup Forum 95, 2017br/>span classlinklist idHuschenbettKuskeZetzsche2017a-linklist styledisplay:none;>[ span classjsbutton>a idHuschenbettKuskeZetzsche2017a-bibtex-show  hrefjavascript:toggle(HuschenbettKuskeZetzsche2017a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idHuschenbettKuskeZetzsche2017a-bibtex-hide hrefjavascript:toggle(HuschenbettKuskeZetzsche2017a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idHuschenbettKuskeZetzsche2017a-abstract-show  hrefjavascript:toggle(HuschenbettKuskeZetzsche2017a-abstract)>Show abstract/a>/span>span classjsbutton>a idHuschenbettKuskeZetzsche2017a-abstract-hide hrefjavascript:toggle(HuschenbettKuskeZetzsche2017a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/1404.5479 title1404.5479>arXiv/a> | a hrefdoc/HuschenbettKuskeZetzsche2017a.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1007/s00233-016-9835-4 title10.1007/s00233-016-9835-4>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(HuschenbettKuskeZetzsche2017a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/HuschenbettKuskeZetzsche2017a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1404.5479 title1404.5479>arXiv/a> | a hrefdoc/HuschenbettKuskeZetzsche2017a.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1007/s00233-016-9835-4 title10.1007/s00233-016-9835-4>DOI/a> ]br/>/span>/noscript>div classabstract idHuschenbettKuskeZetzsche2017a-abstract>span classabstractheading>Abstract/span>br/>		We investigate the monoid of transformations that are induced by		sequences of writing to and reading from a queue storage. We describe		this monoid by means of a confluent and terminating semi-Thue system		and study some of its basic algebraic properties, e.g., conjugacy.		Moreover, we show that while several properties concerning its		rational subsets are undecidable, their uniform membership problem is		NL-complete. Furthermore, we present an algebraic characterization of		this monoids recognizable subsets. Finally, we prove that it is not		Thurston-automatic. 	/div>script typetext/javascript>document.getElementById(HuschenbettKuskeZetzsche2017a-abstract).style.displaynone;/script>div idHuschenbettKuskeZetzsche2017a-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{HuschenbettKuskeZetzsche2017a,	AUTHOR		 {Huschenbett, Martin and Kuske, Dietrich and Zetzsche, Georg},	TITLE		 {The Monoid of Queue Actions},	YEAR		 {2017},	JOURNAL	 {Semigroup Forum},	VOLUME		 {95},	PAGES		 {475--508},	DOI		 {10.1007/s00233-016-9835-4}}/pre>/div>/div>br/>div classentry>span classtitle>A Characterization for Decidable Separability by Piecewise Testable Languages/span>br/>with a hrefhttps://www.mimuw.edu.pl/~wczerwin/>Wojciech Czerwiński/a>, a hrefhttp://www.theoinf.uni-bayreuth.de/en/team/martens_wim/>Wim Martens/a>, a hrefhttp://is.uni-paderborn.de/fachgebiete/fg-engels/personen/visitenkarten/dr-lorijn-van-rooijen/visitenkarte.html>Lorijn van Rooijen/a>, and a hrefhttp://www.labri.fr/perso/zeitoun/>Marc Zeitoun/a>br/>Discrete Mathematics and Theoretical Computer Science 19(4), 2017br/>Special Issue on a hrefhttps://sites.google.com/site/fct2015gdansk/home title20th International Symposium on Fundamentals of Computation Theory>FCT 2015/a>br/>span classlinklist idCzerwinskiMartensRooijenZeitounZetzsche2017a-linklist styledisplay:none;>[ span classjsbutton>a idCzerwinskiMartensRooijenZeitounZetzsche2017a-bibtex-show  hrefjavascript:toggle(CzerwinskiMartensRooijenZeitounZetzsche2017a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idCzerwinskiMartensRooijenZeitounZetzsche2017a-bibtex-hide hrefjavascript:toggle(CzerwinskiMartensRooijenZeitounZetzsche2017a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idCzerwinskiMartensRooijenZeitounZetzsche2017a-abstract-show  hrefjavascript:toggle(CzerwinskiMartensRooijenZeitounZetzsche2017a-abstract)>Show abstract/a>/span>span classjsbutton>a idCzerwinskiMartensRooijenZeitounZetzsche2017a-abstract-hide hrefjavascript:toggle(CzerwinskiMartensRooijenZeitounZetzsche2017a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/1410.1042 title1410.1042>arXiv/a> | a hrefhttp://dx.doi.org/10.23638/DMTCS-19-4-1 title10.23638/DMTCS-19-4-1>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(CzerwinskiMartensRooijenZeitounZetzsche2017a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/CzerwinskiMartensRooijenZeitounZetzsche2017a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1410.1042 title1410.1042>arXiv/a> | a hrefhttp://dx.doi.org/10.23638/DMTCS-19-4-1 title10.23638/DMTCS-19-4-1>DOI/a> ]br/>/span>/noscript>div classabstract idCzerwinskiMartensRooijenZeitounZetzsche2017a-abstract>span classabstractheading>Abstract/span>br/>		The separability problem for word languages of a class $\C$ by languages of		a class $\S$ asks, for two given languages $I$ and $E$ from $\C$, whether		there exists a language $S$ from $\S$ that includes $I$ and excludes $E$,		that is, $I \subseteq S$ and $S\cap E  \emptyset$. In this work, we assume		some mild closure properties for $\C$ and study for which such classes $\C$,		separability by piecewise testable languages (PTL) is decidable. We		characterize these classes in terms of decidability of (two variants of) an		unboundedness problem. From this we deduce that separability by PTL is		decidable for a number of language classes, such as the context-free		languages and languages of labeled vector addition systems. Furthermore, it		follows that separability by PTL is decidable if and only if one can compute		for any language of the class its downward closure wrt.\ the \subword		ordering (i.e., if the set of \subwords of any language of the class		is effectively regular).		br/>		The obtained decidability results contrast some undecidability		results. In fact, for all the (non-regular) language classes we		present as examples with decidable separability, it is undecidable		whether a given language is a PTL itself.		br/>		Our characterization involves a result of independent interest,		which states that for \emph{any} kind of languages $I$ and $E$,		non-separability is equivalent to the existence of common patterns		in $I$ and $E$.	/div>script typetext/javascript>document.getElementById(CzerwinskiMartensRooijenZeitounZetzsche2017a-abstract).style.displaynone;/script>div idCzerwinskiMartensRooijenZeitounZetzsche2017a-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{CzerwinskiMartensRooijenZeitounZetzsche2017a,	AUTHOR		 {Czerwi{\{n}}ski, Wojciech and Martens, Wim and van Rooijen, Lorijn and Zeitoun, Marc and Zetzsche, Georg},	TITLE		 {A Characterization for Decidable Separability by Piecewise Testable Languages},	YEAR		 {2017},	JOURNAL	 {Discrete Mathematics and Theoretical Computer Science},	VOLUME		 {19},	NUMBER		 {4},	YEAR		 {2017},	DOI		 {10.23638/DMTCS-19-4-1}}/pre>/div>/div>br/>div classentry>span classtitle>On Boolean closed full trios and rational Kripke frames/span>br/>with a hrefhttp://eiche.theoinf.tu-ilmenau.de/kuske/>Dietrich Kuske/a> and a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>br/>Theory of Computing Systems 60, 2017br/>Special Issue on a hrefhttp://stacs2014.sciencesconf.org/ title31st International Symposium on Theoretical Aspects of Computer Science>STACS 2014/a>br/>span classlinklist idZetzscheKuskeLohrey2017a-linklist styledisplay:none;>[ span classjsbutton>a idZetzscheKuskeLohrey2017a-bibtex-show  hrefjavascript:toggle(ZetzscheKuskeLohrey2017a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzscheKuskeLohrey2017a-bibtex-hide hrefjavascript:toggle(ZetzscheKuskeLohrey2017a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzscheKuskeLohrey2017a-abstract-show  hrefjavascript:toggle(ZetzscheKuskeLohrey2017a-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzscheKuskeLohrey2017a-abstract-hide hrefjavascript:toggle(ZetzscheKuskeLohrey2017a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/ZetzscheKuskeLohrey2017a.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1007/s00224-016-9694-0 title10.1007/s00224-016-9694-0>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(ZetzscheKuskeLohrey2017a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/ZetzscheKuskeLohrey2017a.bib>BibTeX/a> | a hrefdoc/ZetzscheKuskeLohrey2017a.pdf titleVersion >PDF/a> | a hrefhttp://dx.doi.org/10.1007/s00224-016-9694-0 title10.1007/s00224-016-9694-0>DOI/a> ]br/>/span>/noscript>div classabstract idZetzscheKuskeLohrey2017a-abstract>span classabstractheading>Abstract/span>br/>		We study what languages can be constructed from a non-regular		language $L$ using Boolean operations and (synchronized) rational		transductions. If all rational transductions are allowed, one can		construct the whole arithemtical hierarchy relative to $L$. If only		synchronized rational transductions are allowed, we present		non-regular languages that allow to construct at least languages		arbitrarily high in the arithmetical hierarchy and we present		non-regular languages that allow to construct only decidable		languages.		br/>      			A consequence of the results is that aside from the regular		languages, no full trio generated by a single language is closed under		complementation.		br/>      			Our construction also shows that there is a fixed rational Kripke		frame such that assigning an arbitrary non-regular language to some		variable allows the definition of any language from the arithmetical		hierarchy in the corresponding Kripke structure using multimodal		logic.	/div>script typetext/javascript>document.getElementById(ZetzscheKuskeLohrey2017a-abstract).style.displaynone;/script>div idZetzscheKuskeLohrey2017a-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{ZetzscheKuskeLohrey2017a,	AUTHOR		 {Zetzsche, Georg and Kuske, Dietrich and Lohrey, Markus},	TITLE		 {On {Boolean} closed full trios and rational {Kripke} frames},	VOLUME		 {60},	PAGES		 {438--472},	YEAR		 {2017},	JOURNAL	 {Theory of Computing Systems},	DOI		 {10.1007/s00224-016-9694-0}}/pre>/div>/div>br/>div classentry>span classtitle>Monoids as Storage Mechanisms/span>br/>Bulletin of the EATCS 120, 2016br/>span classlinklist idZetzsche2016d-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2016d-bibtex-show  hrefjavascript:toggle(Zetzsche2016d-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2016d-bibtex-hide hrefjavascript:toggle(Zetzsche2016d-bibtex) styledisplay:none;>Hide BibTeX/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2016d-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2016d.bib>BibTeX/a> ]br/>/span>/noscript>div idZetzsche2016d-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{Zetzsche2016d,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {Monoids as Storage Mechanisms},	YEAR		 {2016},	JOURNAL	 {Bulletin of the EATCS},	VOLUME		 {120},	PAGES		 {237--249},	NOTE		 {Invited abstract due to EATCS Distinguished Dissertation Award}}/pre>/div>/div>br/>div classentry>span classtitle>Permutations of context-free, ET0L and indexed languages/span>br/>with a hrefhttp://www-circa.mcs.st-and.ac.uk/~tara/index.html>Tara Brough/a>, a hrefhttp://www.macs.hw.ac.uk/~lc45/>Laura Ciobanu/a>, and a hrefhttps://sites.google.com/site/melderau/>Murray Elder/a>br/>Discrete Mathematics and Theoretical Computer Science 17(3), 2016br/>span classlinklist idBroughCiobanuElderZetzsche2016a-linklist styledisplay:none;>[ span classjsbutton>a idBroughCiobanuElderZetzsche2016a-bibtex-show  hrefjavascript:toggle(BroughCiobanuElderZetzsche2016a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idBroughCiobanuElderZetzsche2016a-bibtex-hide hrefjavascript:toggle(BroughCiobanuElderZetzsche2016a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idBroughCiobanuElderZetzsche2016a-abstract-show  hrefjavascript:toggle(BroughCiobanuElderZetzsche2016a-abstract)>Show abstract/a>/span>span classjsbutton>a idBroughCiobanuElderZetzsche2016a-abstract-hide hrefjavascript:toggle(BroughCiobanuElderZetzsche2016a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://arxiv.org/abs/1604.05431 title1604.05431>arXiv/a> | a hrefhttps://hal.inria.fr/hal-01352858 title>HAL/a> ]br/>/span>script typetext/javascript>document.getElementById(BroughCiobanuElderZetzsche2016a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/BroughCiobanuElderZetzsche2016a.bib>BibTeX/a> | a hrefhttp://arxiv.org/abs/1604.05431 title1604.05431>arXiv/a> | a hrefhttps://hal.inria.fr/hal-01352858 title>HAL/a> ]br/>/span>/noscript>div classabstract idBroughCiobanuElderZetzsche2016a-abstract>span classabstractheading>Abstract/span>br/>		For a language $L$, we consider its cyclic closure, and more generally the		language $C^k(L)$, which consists of all words obtained by partitioning words		from $L$ into $k$ factors and permuting them.  We prove that the classes of		ET0L and EDT0L languages are closed under the operators $C^k$.  This both		sharpens and generalises Brandstädts result that if $L$ is context-free then		$C^k(L)$ is context-sensitive and not context-free  in general for $k\geq 3$.		We also show  that the cyclic closure of an indexed language is indexed.	/div>script typetext/javascript>document.getElementById(BroughCiobanuElderZetzsche2016a-abstract).style.displaynone;/script>div idBroughCiobanuElderZetzsche2016a-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{BroughCiobanuElderZetzsche2016a,	AUTHOR		 {Brough, Tara and Ciobanu, Laura and Elder, Murray and Zetzsche, Georg},	TITLE		 {Permutations of context-free, ET0L and indexed languages},	YEAR		 {2016},	JOURNAL	 {Discrete Mathematics and Theoretical Computer Science},	VOLUME		 {17},	NUMBER		 {3},	YEAR		 {2016},	PAGES		 {167--178}}/pre>/div>/div>br/>div classentry>span classtitle>Rational subsets and submonoids of wreath products/span>br/>with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a> and a hrefhttp://www.sci.ccny.cuny.edu/~benjamin/>Benjamin Steinberg/a>br/>Information and Computation 243, 2015br/>Special Issue on a hrefhttp://www.icalp2013.lu.lv/ title40th International Colloquium on Automata, Languages and Programming>ICALP 2013/a>br/>span classlinklist idLohreySteinbergZetzsche2015a-linklist styledisplay:none;>[ span classjsbutton>a idLohreySteinbergZetzsche2015a-bibtex-show  hrefjavascript:toggle(LohreySteinbergZetzsche2015a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idLohreySteinbergZetzsche2015a-bibtex-hide hrefjavascript:toggle(LohreySteinbergZetzsche2015a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idLohreySteinbergZetzsche2015a-abstract-show  hrefjavascript:toggle(LohreySteinbergZetzsche2015a-abstract)>Show abstract/a>/span>span classjsbutton>a idLohreySteinbergZetzsche2015a-abstract-hide hrefjavascript:toggle(LohreySteinbergZetzsche2015a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1016/j.ic.2014.12.014 title10.1016/j.ic.2014.12.014>DOI/a> | a hrefhttp://arxiv.org/abs/1302.2455 title1302.2455>arXiv/a> | a hrefdoc/LohreySteinbergZetzsche2015a.pdf titleVersion >PDF/a> ]br/>/span>script typetext/javascript>document.getElementById(LohreySteinbergZetzsche2015a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/LohreySteinbergZetzsche2015a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1016/j.ic.2014.12.014 title10.1016/j.ic.2014.12.014>DOI/a> | a hrefhttp://arxiv.org/abs/1302.2455 title1302.2455>arXiv/a> | a hrefdoc/LohreySteinbergZetzsche2015a.pdf titleVersion >PDF/a> ]br/>/span>/noscript>div classabstract idLohreySteinbergZetzsche2015a-abstract>span classabstractheading>Abstract/span>br/>		It is shown that membership in rational subsets of wreath		products $H \wr V$ with $H$ a finite group and $V$ a virtually		free group is decidable. On the other hand, it is shown that		there exists a fixed finitely generated submonoid in the wreath		product $\mathbb{Z}\wr\mathbb{Z}$ with an undecidable		membership problem.	/div>script typetext/javascript>document.getElementById(LohreySteinbergZetzsche2015a-abstract).style.displaynone;/script>div idLohreySteinbergZetzsche2015a-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{LohreySteinbergZetzsche2015a,	AUTHOR		 {Lohrey, Markus and Steinberg, Benjamin and Zetzsche, Georg},	TITLE		 {Rational subsets and submonoids of wreath products},	JOURNAL	 {Information and Computation},	VOLUME		 {243},	PAGES		 {191--204},	YEAR		 {2015},	DOI		 {10.1016/j.ic.2014.12.014}}/pre>/div>/div>br/>div classentry>span classtitle>Toward Understanding the Generative Capacity of Erasing Rules in Matrix Grammars/span>br/>International Journal of Foundations of Computer Science 22(2), 2011br/>Special Issue on a hrefhttp://www-dlt2009.informatik.uni-stuttgart.de/ title13th International Conference on Developments in Language Theory>DLT 2009/a>br/>span classlinklist idZetzsche2011a-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2011a-bibtex-show  hrefjavascript:toggle(Zetzsche2011a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2011a-bibtex-hide hrefjavascript:toggle(Zetzsche2011a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2011a-abstract-show  hrefjavascript:toggle(Zetzsche2011a-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2011a-abstract-hide hrefjavascript:toggle(Zetzsche2011a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.1142/S0129054111008118 title10.1142/S0129054111008118>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2011a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2011a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1142/S0129054111008118 title10.1142/S0129054111008118>DOI/a> ]br/>/span>/noscript>div classabstract idZetzsche2011a-abstract>span classabstractheading>Abstract/span>br/>		This article presents approaches to the open problem of whether erasing		rules can be eliminated in matrix grammars.  The class of languages		generated by non-erasing matrix grammars is characterized by the newly		introduced linear Petri net grammars.  Petri net grammars are known to be		equivalent to arbitrary matrix grammars (without appearance checking). In		linear Petri net grammars, the marking has to be linear in size with		respect to the length of the sentential form.  The characterization by		linear Petri net grammars is then used to show that applying linear erasing		to a Petri net language yields a language generated by a non-erasing matrix		grammar.  It is also shown that in Petri net grammars (with final markings		and arbitrary labeling), erasing rules can be eliminated, which yields two		reformulations of the problem of whether erasing rules in matrix grammars		can be eliminated.	/div>script typetext/javascript>document.getElementById(Zetzsche2011a-abstract).style.displaynone;/script>div idZetzsche2011a-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{Zetzsche2011a,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {Toward Understanding the Generative Capacity of Erasing Rules in Matrix Grammars},	JOURNAL	 {International Journal of Foundations of Computer Science},	VOLUME		 {22},	NUMBER		 {2},	PAGES		 {411--426},	YEAR		 {2011},	DOI		 {10.1142/S0129054111008118}}/pre>/div>/div>br/>div classentry>span classtitle>Properties of Multiset Language Classes Defined by Multiset Pushdown Automata/span>br/>with a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/kudlek_eng.html>Manfred Kudlek/a> and a hrefhttps://cgi.csc.liv.ac.uk/~patrick/>Patrick Totzke/a>br/>Fundamenta Informaticae 93(1-3), 2009br/>Special Issue on a hrefhttp://www2.informatik.hu-berlin.de/ki/CSP2008/index.html titleWorkshop on Concurrency, Specification and Programming>CS&P 2008/a>br/>span classlinklist idKudlekTotzkeZetzsche2009a-linklist styledisplay:none;>[ span classjsbutton>a idKudlekTotzkeZetzsche2009a-bibtex-show  hrefjavascript:toggle(KudlekTotzkeZetzsche2009a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idKudlekTotzkeZetzsche2009a-bibtex-hide hrefjavascript:toggle(KudlekTotzkeZetzsche2009a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idKudlekTotzkeZetzsche2009a-abstract-show  hrefjavascript:toggle(KudlekTotzkeZetzsche2009a-abstract)>Show abstract/a>/span>span classjsbutton>a idKudlekTotzkeZetzsche2009a-abstract-hide hrefjavascript:toggle(KudlekTotzkeZetzsche2009a-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.3233/FI-2009-0099 title10.3233/FI-2009-0099>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(KudlekTotzkeZetzsche2009a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/KudlekTotzkeZetzsche2009a.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.3233/FI-2009-0099 title10.3233/FI-2009-0099>DOI/a> ]br/>/span>/noscript>div classabstract idKudlekTotzkeZetzsche2009a-abstract>span classabstractheading>Abstract/span>br/>		The previously introduced multiset language classes		defined by multiset pushdown automata are being		explored with respect to their closure properties and		alternative characterizations.	/div>script typetext/javascript>document.getElementById(KudlekTotzkeZetzsche2009a-abstract).style.displaynone;/script>div idKudlekTotzkeZetzsche2009a-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{KudlekTotzkeZetzsche2009a,	AUTHOR		 {Kudlek, Manfred and Totzke, Patrick and Zetzsche, Georg},	TITLE		 {Properties of Multiset Language Classes Defined by Multiset Pushdown Automata},	JOURNAL	 {Fundamenta Informaticae},	VOLUME		 {93},	PAGES		 {235--244},	NUMBER		 {1-3},	YEAR		 {2009},	DOI		 {10.3233/FI-2009-0099}}/pre>/div>/div>br/>div classentry>span classtitle>Multiset Pushdown Automata/span>br/>with a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/kudlek_eng.html>Manfred Kudlek/a> and a hrefhttps://cgi.csc.liv.ac.uk/~patrick/>Patrick Totzke/a>br/>Fundamenta Informaticae 93(1-3), 2009br/>Special Issue on a hrefhttp://www2.informatik.hu-berlin.de/ki/CSP2008/index.html titleWorkshop on Concurrency, Specification and Programming>CS&P 2008/a>br/>span classlinklist idKudlekTotzkeZetzsche2009-linklist styledisplay:none;>[ span classjsbutton>a idKudlekTotzkeZetzsche2009-bibtex-show  hrefjavascript:toggle(KudlekTotzkeZetzsche2009-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idKudlekTotzkeZetzsche2009-bibtex-hide hrefjavascript:toggle(KudlekTotzkeZetzsche2009-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idKudlekTotzkeZetzsche2009-abstract-show  hrefjavascript:toggle(KudlekTotzkeZetzsche2009-abstract)>Show abstract/a>/span>span classjsbutton>a idKudlekTotzkeZetzsche2009-abstract-hide hrefjavascript:toggle(KudlekTotzkeZetzsche2009-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://dx.doi.org/10.3233/FI-2009-0098 title10.3233/FI-2009-0098>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(KudlekTotzkeZetzsche2009-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/KudlekTotzkeZetzsche2009.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.3233/FI-2009-0098 title10.3233/FI-2009-0098>DOI/a> ]br/>/span>/noscript>div classabstract idKudlekTotzkeZetzsche2009-abstract>span classabstractheading>Abstract/span>br/>		Multiset finite Automata, a model equivalent to		regular commutative grammars, are extended with a		multiset store and the accepting power of this		extended model of computation is investigated. This		type of multiset automata come in two flavours,		varying only in the ability of testing the storage		for emptiness. This paper establishes normal forms		and relates the derived language classes to each		other as well as to known multiset language classes.	/div>script typetext/javascript>document.getElementById(KudlekTotzkeZetzsche2009-abstract).style.displaynone;/script>div idKudlekTotzkeZetzsche2009-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{KudlekTotzkeZetzsche2009,	AUTHOR		 {Kudlek, Manfred and Totzke, Patrick and Zetzsche, Georg},	TITLE		 {Multiset Pushdown Automata},	JOURNAL	 {Fundamenta Informaticae},	VOLUME		 {93},	PAGES		 {221--233},	NUMBER		 {1-3},	YEAR		 {2009},	DOI		 {10.3233/FI-2009-0098}}/pre>/div>/div>br/>div classentry>span classtitle>Petri Net Controlled Finite Automata/span>br/>with a hrefhttp://bertiemuller.wordpress.com/>Berndt Farwer/a>, a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/jantzen_eng.html>Matthias Jantzen/a>, a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/kudlek_eng.html>Manfred Kudlek/a>, and a hrefhttp://www.dipf.de/de/mitarbeiter/roelke>Heiko Rölke/a>br/>Fundamenta Informaticae 85(1-4), 2008br/>Special Issue on a hrefhttp://www.mimuw.edu.pl/~csp/1024/index.htm titleWorkshop on Concurrency, Specification and Programming>CS&P 2007/a>br/>span classlinklist idFaJaKuRoZe2008-linklist styledisplay:none;>[ span classjsbutton>a idFaJaKuRoZe2008-bibtex-show  hrefjavascript:toggle(FaJaKuRoZe2008-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idFaJaKuRoZe2008-bibtex-hide hrefjavascript:toggle(FaJaKuRoZe2008-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idFaJaKuRoZe2008-abstract-show  hrefjavascript:toggle(FaJaKuRoZe2008-abstract)>Show abstract/a>/span>span classjsbutton>a idFaJaKuRoZe2008-abstract-hide hrefjavascript:toggle(FaJaKuRoZe2008-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(FaJaKuRoZe2008-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/FaJaKuRoZe2008.bib>BibTeX/a> ]br/>/span>/noscript>div classabstract idFaJaKuRoZe2008-abstract>span classabstractheading>Abstract/span>br/>		We present a generalization of finite automata using		Petri nets as control, called Concurrent Finite Automata		for short.  Several modes of acceptance, defined by final		markings of the Petri net, are introduced, and their		equivalence is shown.  The class of languages obtained by		l-free concurrent finite automata contains both the class		of regular sets and the class of Petri net languages		defined by final marking, and is contained in the class		of context-sensitive languages.	/div>script typetext/javascript>document.getElementById(FaJaKuRoZe2008-abstract).style.displaynone;/script>div idFaJaKuRoZe2008-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{FaJaKuRoZe2008,	AUTHOR		 {Farwer, Berndt and Jantzen, Matthias and Kudlek, Manfred and R{\o}lke, Heiko and Zetzsche, Georg},	TITLE		 {Petri Net Controlled Finite Automata},	JOURNAL	 {Fundamenta Informaticae},	VOLUME		 {85},	PAGES		 {111--121},	NUMBER		 {1-4},	YEAR		 {2008}}/pre>/div>/div>br/>div classentry>span classtitle>Language Classes Defined by Concurrent Finite Automata/span>br/>with a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/jantzen_eng.html>Matthias Jantzen/a> and a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/kudlek_eng.html>Manfred Kudlek/a>br/>Fundamenta Informaticae 85(1-4), 2008br/>Special Issue on a hrefhttp://www.mimuw.edu.pl/~csp/1024/index.htm titleWorkshop on Concurrency, Specification and Programming>CS&P 2007/a>br/>span classlinklist idJantzenKudlekZetzsche2008-linklist styledisplay:none;>[ span classjsbutton>a idJantzenKudlekZetzsche2008-bibtex-show  hrefjavascript:toggle(JantzenKudlekZetzsche2008-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idJantzenKudlekZetzsche2008-bibtex-hide hrefjavascript:toggle(JantzenKudlekZetzsche2008-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idJantzenKudlekZetzsche2008-abstract-show  hrefjavascript:toggle(JantzenKudlekZetzsche2008-abstract)>Show abstract/a>/span>span classjsbutton>a idJantzenKudlekZetzsche2008-abstract-hide hrefjavascript:toggle(JantzenKudlekZetzsche2008-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(JantzenKudlekZetzsche2008-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/JantzenKudlekZetzsche2008.bib>BibTeX/a> ]br/>/span>/noscript>div classabstract idJantzenKudlekZetzsche2008-abstract>span classabstractheading>Abstract/span>br/>		This paper presents results regarding the various		relations among the language classes defined by		Concurrent Finite Automata, relations to other language		classes, as well as decidability and closure properties.	/div>script typetext/javascript>document.getElementById(JantzenKudlekZetzsche2008-abstract).style.displaynone;/script>div idJantzenKudlekZetzsche2008-bibtex classbibtex styledisplay:none;>pre>@ARTICLE{JantzenKudlekZetzsche2008,	AUTHOR		 {Jantzen, Matthias and Kudlek, Manfred and Zetzsche, Georg},	TITLE		 {Language Classes Defined by Concurrent Finite Automata},	JOURNAL	 {Fundamenta Informaticae},	VOLUME		 {85},	PAGES		 {267--280},	NUMBER		 {1-4},	YEAR		 {2008}}/pre>/div>/div>br/>div classheading2>Workshop contributions/div>br/>div classentry>span classtitle>Multiset Storage Automata/span>br/>with a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/kudlek_eng.html>Manfred Kudlek/a> and a hrefhttps://cgi.csc.liv.ac.uk/~patrick/>Patrick Totzke/a>br/>Proceedings of a hrefhttp://www2.informatik.hu-berlin.de/ki/CSP2008/index.html titleWorkshop on Concurrency, Specification and Programming>CS&P 2008/a>br/>span classlinklist idKudlekTotzkeZetzsche2008-linklist styledisplay:none;>[ span classjsbutton>a idKudlekTotzkeZetzsche2008-bibtex-show  hrefjavascript:toggle(KudlekTotzkeZetzsche2008-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idKudlekTotzkeZetzsche2008-bibtex-hide hrefjavascript:toggle(KudlekTotzkeZetzsche2008-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idKudlekTotzkeZetzsche2008-abstract-show  hrefjavascript:toggle(KudlekTotzkeZetzsche2008-abstract)>Show abstract/a>/span>span classjsbutton>a idKudlekTotzkeZetzsche2008-abstract-hide hrefjavascript:toggle(KudlekTotzkeZetzsche2008-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(KudlekTotzkeZetzsche2008-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/KudlekTotzkeZetzsche2008.bib>BibTeX/a> ]br/>/span>/noscript>div classabstract idKudlekTotzkeZetzsche2008-abstract>span classabstractheading>Abstract/span>br/>		Two kinds of multiset automata with a storage attached, varying		only in their ability of testing the storage for emptiness, are		introduced, as well as normal forms.  Their accepting power and		relation to other multiset languages classes is investigated.	/div>script typetext/javascript>document.getElementById(KudlekTotzkeZetzsche2008-abstract).style.displaynone;/script>div idKudlekTotzkeZetzsche2008-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{KudlekTotzkeZetzsche2008,	AUTHOR		 {Kudlek, Manfred and Totzke, Patrick and Zetzsche, Georg},	TITLE		 {Multiset Storage Automata},	BOOKTITLE	 {Proc. of the Workshop on Concurrency, Specification and Programming (CS{\&}P 2008)},	EDITOR		 {Burkhard, H.-D. and Czaja, Ludwik and Lindemann, G. and Skowron, A.},	VOLUME		 {2},	PAGES		 {265--277},	YEAR		 {2008}}/pre>/div>/div>br/>div classentry>span classtitle>Properties of Multiset Language Classes Defined by Multiset Storage Automata/span>br/>with a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/kudlek_eng.html>Manfred Kudlek/a> and a hrefhttps://cgi.csc.liv.ac.uk/~patrick/>Patrick Totzke/a>br/>Proceedings of a hrefhttp://www2.informatik.hu-berlin.de/ki/CSP2008/index.html titleWorkshop on Concurrency, Specification and Programming>CS&P 2008/a>br/>span classlinklist idKudlekTotzkeZetzsche2008a-linklist styledisplay:none;>[ span classjsbutton>a idKudlekTotzkeZetzsche2008a-bibtex-show  hrefjavascript:toggle(KudlekTotzkeZetzsche2008a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idKudlekTotzkeZetzsche2008a-bibtex-hide hrefjavascript:toggle(KudlekTotzkeZetzsche2008a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idKudlekTotzkeZetzsche2008a-abstract-show  hrefjavascript:toggle(KudlekTotzkeZetzsche2008a-abstract)>Show abstract/a>/span>span classjsbutton>a idKudlekTotzkeZetzsche2008a-abstract-hide hrefjavascript:toggle(KudlekTotzkeZetzsche2008a-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(KudlekTotzkeZetzsche2008a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/KudlekTotzkeZetzsche2008a.bib>BibTeX/a> ]br/>/span>/noscript>div classabstract idKudlekTotzkeZetzsche2008a-abstract>span classabstractheading>Abstract/span>br/>		The previously introduced multiset language classes defined by		multiset storage automata are being explored with respect to their		closure properties and alternative characterizations.	/div>script typetext/javascript>document.getElementById(KudlekTotzkeZetzsche2008a-abstract).style.displaynone;/script>div idKudlekTotzkeZetzsche2008a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{KudlekTotzkeZetzsche2008a,	AUTHOR		 {Kudlek, Manfred and Totzke, Patrick and Zetzsche, Georg},	TITLE		 {Properties of Multiset Language Classes Defined by Multiset Storage Automata},	BOOKTITLE	 {Proc. of the Workshop on Concurrency, Specification and Programming (CS{\&}P 2008)},	EDITOR		 {Burkhard, H.-D. and Czaja, Ludwik and Lindemann, G. and Skowron, A.},	VOLUME		 {2},	PAGES		 {278--288},	YEAR		 {2008}}/pre>/div>/div>br/>div classentry>span classtitle>Concurrent finite automata and related language classes (an overview)/span>br/>with a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/kudlek_eng.html>Manfred Kudlek/a>br/>Proceedings of AFLAS 2008br/>span classlinklist idKudlekZetzsche2010-linklist styledisplay:none;>[ span classjsbutton>a idKudlekZetzsche2010-bibtex-show  hrefjavascript:toggle(KudlekZetzsche2010-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idKudlekZetzsche2010-bibtex-hide hrefjavascript:toggle(KudlekZetzsche2010-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | a hrefhttp://dx.doi.org/10.1142/9789814317610_0008 title10.1142/9789814317610_0008>DOI/a> ]br/>/span>script typetext/javascript>document.getElementById(KudlekZetzsche2010-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/KudlekZetzsche2010.bib>BibTeX/a> | a hrefhttp://dx.doi.org/10.1142/9789814317610_0008 title10.1142/9789814317610_0008>DOI/a> ]br/>/span>/noscript>div idKudlekZetzsche2010-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{KudlekZetzsche2010,	AUTHOR		 {Kudlek, Manfred and Zetzsche, Georg},	TITLE		 {Concurrent finite automata and related language classes (an overview)},	BOOKTITLE	 {Proc. of the Workshop Automata, Formal Languages and Algebraic Systems (AFLAS 2008)},	YEAR		 {2010},	EDITOR		 {Ito, Masami and Kobayashi, Yuji and Kunitaka, Shoji},	PUBLISHER	 {World Scientific},	ADDRESS	 {New Jersey},	PAGES		 {103--113},	DOI		 {10.1142/9789814317610_0008}}/pre>/div>/div>br/>div classentry>span classtitle>On Concurrent Finite Automata/span>br/>with a hrefhttp://bertiemuller.wordpress.com/>Berndt Farwer/a>, a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/jantzen_eng.html>Matthias Jantzen/a>, a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/kudlek_eng.html>Manfred Kudlek/a>, and a hrefhttp://www.dipf.de/de/mitarbeiter/roelke>Heiko Rölke/a>br/>Proceedings of a hrefhttp://www.mimuw.edu.pl/~csp/1024/index.htm titleWorkshop on Concurrency, Specification and Programming>CS&P 2007/a>br/>span classlinklist idFaJaKuRoZe2007-linklist styledisplay:none;>[ span classjsbutton>a idFaJaKuRoZe2007-bibtex-show  hrefjavascript:toggle(FaJaKuRoZe2007-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idFaJaKuRoZe2007-bibtex-hide hrefjavascript:toggle(FaJaKuRoZe2007-bibtex) styledisplay:none;>Hide BibTeX/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(FaJaKuRoZe2007-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/FaJaKuRoZe2007.bib>BibTeX/a> ]br/>/span>/noscript>div idFaJaKuRoZe2007-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{FaJaKuRoZe2007,	AUTHOR		 {Farwer, Berndt and Jantzen, Matthias and Kudlek, Manfred and R{\o}lke, Heiko and Zetzsche, Georg},	TITLE		 {On Concurrent Finite Automata},	BOOKTITLE	 {Proc. of the Workshop on Concurrency, Specification and Programming (CS{\&}P 2007)},	EDITOR		 {Czaja, Ludwik},	VOLUME		 {1},	PAGES		 {180--190},	YEAR		 {2007}}/pre>/div>/div>br/>div classentry>span classtitle>On Languages Accepted by Concurrent Finite Automata/span>br/>with a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/jantzen_eng.html>Matthias Jantzen/a> and a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/kudlek_eng.html>Manfred Kudlek/a>br/>Proceedings of a hrefhttp://www.mimuw.edu.pl/~csp/1024/index.htm titleWorkshop on Concurrency, Specification and Programming>CS&P 2007/a>br/>span classlinklist idJantzenKudlekZetzsche2007a-linklist styledisplay:none;>[ span classjsbutton>a idJantzenKudlekZetzsche2007a-bibtex-show  hrefjavascript:toggle(JantzenKudlekZetzsche2007a-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idJantzenKudlekZetzsche2007a-bibtex-hide hrefjavascript:toggle(JantzenKudlekZetzsche2007a-bibtex) styledisplay:none;>Hide BibTeX/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(JantzenKudlekZetzsche2007a-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/JantzenKudlekZetzsche2007a.bib>BibTeX/a> ]br/>/span>/noscript>div idJantzenKudlekZetzsche2007a-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{JantzenKudlekZetzsche2007a,	AUTHOR		 {Jantzen, Matthias and Kudlek, Manfred and Zetzsche, Georg},	TITLE		 {On Languages Accepted by Concurrent Finite Automata},	BOOKTITLE	 {Proc. of the Workshop on Concurrency, Specification and Programming (CS{\&}P 2007)},	EDITOR		 {Czaja, Ludwik},	VOLUME		 {2},	PAGES		 {321--332},	YEAR		 {2007}}/pre>/div>/div>br/>div classentry>span classtitle>Finite Automata Controlled by Petri Nets/span>br/>with a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/jantzen_eng.html>Matthias Jantzen/a> and a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/kudlek_eng.html>Manfred Kudlek/a>br/>Proceedings of a hrefhttp://www.uni-koblenz.de/~ag-pn/html/awpn2007/ title14th Workshop Algorithmen und Werkzeuge für Petrinetze>AWPN 2007/a>br/>span classlinklist idJantzenKudlekZetzsche2007-linklist styledisplay:none;>[ span classjsbutton>a idJantzenKudlekZetzsche2007-bibtex-show  hrefjavascript:toggle(JantzenKudlekZetzsche2007-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idJantzenKudlekZetzsche2007-bibtex-hide hrefjavascript:toggle(JantzenKudlekZetzsche2007-bibtex) styledisplay:none;>Hide BibTeX/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(JantzenKudlekZetzsche2007-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/JantzenKudlekZetzsche2007.bib>BibTeX/a> ]br/>/span>/noscript>div idJantzenKudlekZetzsche2007-bibtex classbibtex styledisplay:none;>pre>@INPROCEEDINGS{JantzenKudlekZetzsche2007,	AUTHOR		 {Jantzen, Matthias and Kudlek, Manfred and Zetzsche, Georg},	TITLE		 {Finite Automata Controlled by {Petri} Nets},	BOOKTITLE	 {Proc. of the 14th Workshop Algorithmen und Werkzeuge f{\u}r Petrinetze (AWPN 2007)},	EDITOR		 {Philippi, Stephan and Pinl, Alexander},	PAGES		 {57--62},	PUBLISHER	 {Universit{\a}t Koblenz-Landau},	YEAR		 {2007},	NOTE		 {Technical Report Nr. 25/2007}}/pre>/div>/div>br/>div idtheses>div classheading2>Theses/div>br/>div classentry>span classtitle>On Erasing Productions in Grammars with Regulated Rewriting/span>br/>Diplomarbeit (Masters thesis), Universität Hamburg, 2010br/>span classlinklist idZetzsche2010b-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2010b-bibtex-show  hrefjavascript:toggle(Zetzsche2010b-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2010b-bibtex-hide hrefjavascript:toggle(Zetzsche2010b-bibtex) styledisplay:none;>Hide BibTeX/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2010b-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2010b.bib>BibTeX/a> ]br/>/span>/noscript>div idZetzsche2010b-bibtex classbibtex styledisplay:none;>pre>@MASTERSTHESIS{Zetzsche2010b,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {On Erasing Productions in Grammars with Regulated Rewriting},	TYPE		 {Diplomarbeit (Masters thesis)},	INSTITUTION	 {Universit{\a}t Hamburg},	YEAR		 {2010}}/pre>/div>/div>br/>div classentry>span classtitle>Monoids as Storage Mechanisms/span>br/>PhD thesis, Technische Universität Kaiserslautern, 2016br/>span classaward>EATCS Distinguished Dissertation Award/span>br/>span classlinklist idZetzsche2016c-linklist styledisplay:none;>[ span classjsbutton>a idZetzsche2016c-bibtex-show  hrefjavascript:toggle(Zetzsche2016c-bibtex)>Show BibTeX/a>/span>span classjsbutton>a idZetzsche2016c-bibtex-hide hrefjavascript:toggle(Zetzsche2016c-bibtex) styledisplay:none;>Hide BibTeX/a>/span> | span classjsbutton>a idZetzsche2016c-abstract-show  hrefjavascript:toggle(Zetzsche2016c-abstract)>Show abstract/a>/span>span classjsbutton>a idZetzsche2016c-abstract-hide hrefjavascript:toggle(Zetzsche2016c-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:hbz:386-kluedo-44003 title>Official PDF/A/a> | a hrefdoc/Zetzsche2016c.pdf titleVersion >PDF (color links)/a> ]br/>/span>script typetext/javascript>document.getElementById(Zetzsche2016c-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Zetzsche2016c.bib>BibTeX/a> | a hrefhttp://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:hbz:386-kluedo-44003 title>Official PDF/A/a> | a hrefdoc/Zetzsche2016c.pdf titleVersion >PDF (color links)/a> ]br/>/span>/noscript>div classabstract idZetzsche2016c-abstract>span classabstractheading>Abstract/span>br/>		Automata theory has given rise to a variety of automata models that consist of		a finite-state control and an infinite-state storage mechanism.  The aim of		this work is to provide insights into how the structure of the storage		mechanism influences the expressiveness and the analyzability of the resulting		model.  To this end, it presents generalizations of results about individual		storage mechanisms to larger classes. These		generalizations characterize those storage mechanisms for which the given		result remains true and for which it fails.		br/>		In order to speak of classes of storage mechanisms, we need an overarching		framework that accommodates each of the concrete storage mechanisms we wish to		address.  Such a framework is provided by the model of valence automata,		in which the storage mechanism is represented by a monoid.		Since the monoid serves as a parameter to specifying the storage mechanism, our		aim translates into the question: For which monoids does the given		(automata-theoretic) result hold?		br/>		As a first result, we present an algebraic characterization of those monoids		over which valence automata accept only regular languages. In addition,		it turns out that for each monoid, this is the case if and only if		valence grammars, an analogous grammar model, can generate only		context-free languages.		br/>		Furthermore, we are concerned with closure properties: We study which monoids		result in a Boolean closed language class.		For every language class that is closed under rational transductions (in		particular, those induced by valence automata), we show: If the class is Boolean		closed and contains any non-regular language, then it already includes the		whole arithmetical hierarchy.		br/>		This work also introduces the class of graph monoids, which are defined		by finite graphs.  By choosing appropriate graphs, one can realize a number of		prominent storage mechanisms, but also combinations and variants thereof.		Examples are pushdowns, counters, and Turing tapes.  We can therefore relate		the structure of the graphs to computational properties of the resulting		storage mechanisms.		br/>		In the case of graph monoids, we study (i) the		decidability of the emptiness problem, (ii) which storage mechanisms		guarantee semilinear Parikh images, (iii) when silent transitions		(i.e. those that read no input) can be avoided, and (iv) which storage		mechanisms permit the computation of downward closures.	/div>script typetext/javascript>document.getElementById(Zetzsche2016c-abstract).style.displaynone;/script>div idZetzsche2016c-bibtex classbibtex styledisplay:none;>pre>@PHDTHESIS{Zetzsche2016c,	AUTHOR		 {Zetzsche, Georg},	TITLE		 {Monoids as Storage Mechanisms},	TYPE		 {PhD thesis},	INSTITUTION	 {Technische Universit{\a}t Kaiserslautern},	YEAR		 {2016}}/pre>/div>/div>br/>/div>/div>div idreviews>div classheading1>Servicespan classbacktotop>  a href#top>back to top/a> /span>/div>div classentry>I am on the program committee of  a hrefhttps://community.dur.ac.uk/cie.2019/>CiE 2019/a>, a hrefhttp://math.utu.fi/dlt/>DLT 2019/a>, and a hrefhttps://stacs2020.sciencesconf.org/>STACS 2020/a>.p>I have reviewed submissions for a hrefhttps://dl.acm.org/journal/jacm  titleJournal of the ACM>Journal of the ACM/a>, a hrefhttp://link.springer.com/journal/453  titleAlgorithmica>Algorithmica/a>, a hrefhttp://acmtecs.acm.org/  titleACM Transactions on Embedded Computing Systems>ACM TECS/a>, a hrefhttp://www.worldscientific.com/worldscinet/ijfcs  titleInternational Journal of Foundations of Computer Science>IJFCS/a>, a hrefhttp://www.worldscientific.com/worldscinet/ijac  titleInternational Journal of Algebra and Computation>IJAC/a>, a hrefhttp://www.dmtcs.org/dmtcs-ojs/index.php/dmtcs  titleDiscrete Mathematics and Theoretical Computer Science>DMTCS/a>, a hrefhttp://www.journals.elsevier.com/journal-of-computer-and-system-sciences  titleJournal of Computer and System Sciences>JCSS/a>, a hrefhttp://www.journals.elsevier.com/theoretical-computer-science/  titleTheoretical Computer Science>TCS/a>, a hrefhttps://link.springer.com/journal/236  titleActa Informatica>Acta Informatica/a>, a hrefhttp://www.journals.elsevier.com/information-and-computation/  titleInformation and Computation>Inform. Comput./a>, a hrefhttps://www.kybernetika.cz/  titleKybernetika>Kybernetika/a>, a hrefhttps://lmcs.episciences.org/  titleLogical Methods in Computer Science>LMCS/a>, a hrefhttp://acsd.lsi.upc.edu/ title13th International Conference on Application of Concurrency to System Design>ACSD 2013/a>, a hrefhttp://dlt2013.sciencesconf.org/ title17th International Conference on Developments in Language Theory>DLT 2013/a>, a hrefhttp://www.icalp2013.lu.lv/ title40th International Colloquium on Automata, Languages and Programming>ICALP 2013/a>, a hrefhttp://petrinets2014.cnam.fr/acsd.php title14th International Conference on Application of Concurrency to System Design>ACSD 2014/a>, a hrefhttp://www.inf.u-szeged.hu/afl2014/ title14th International Conference on Automata and Formal Languages>AFL 2014/a>, a hrefhttp://www.fsttcs.org/archives/2014/ title34th Annual Conference on Foundations of Software Technology and Theoretical Computer Science>FSTTCS 2014/a>, a hrefhttps://cs.uwaterloo.ca/~shallit/DC2015/ title17th International Workshop on Descriptional Complexity of Formal Systems>DCFS 2015/a>, a hrefhttp://logic.las.tu-berlin.de/csl2015/ title24th EACSL Annual Conference on Computer Science Logic>CSL 2015/a>, a hrefhttp://www.fsttcs.org/ title35th Annual Conference on Foundations of Software Technology and Theoretical Computer Science>FSTTCS 2015/a>, a hrefhttp://conf.researchr.org/home/POPL-2016 titleAnnual Symposium on Principles of Programming Languages>POPL 2016/a>, a hrefhttp://grammars.grlmc.com/lata2016/ title10th International Conference on	Language and Automata Theory and Applications>LATA 2016/a>, a hrefhttp://www.etaps.org/index.php/2016/tacas title22nd International Conference on Tools and Algorithms for the Construction and Analysis of Systems>TACAS 2016/a>, a hrefhttp://www.easyconferences.eu/icalp2016/ title43rd International Colloquium on Automata, Languages and Programming>ICALP 2016/a>, a hrefhttp://mfcs.ki.agh.edu.pl/ title41st International Symposium on Mathematical Foundations of Computer Science>MFCS 2016/a>, a hrefhttps://stacs2017.thi.uni-hannover.de/ title34th International Symposium on Theoretical Aspects of Computer Science>STACS 2017/a>, a hrefhttp://www.etaps.org/index.php/2017/fossacs title20th International Conference on Foundations of Software Science and Computation Structures>FoSSaCS 2017/a>, a hrefhttp://math.utu.fi/cie2017/ titleComputability in Europe 2017>CIE 2017/a>, a hrefhttp://icalp17.mimuw.edu.pl/ title44th International Colloquium on Automata, Languages, and Programming>ICALP 2017/a>, a hrefhttp://ciaa17.univ-mlv.fr/ title22nd International Conference Implementation and Application of Automata>CIAA 2017/a>, a hrefhttp://gandalf2017.istc.cnr.it/ titleEighth International Symposium on Games, Automata, Logics, and Formal Verification>GandALF 2017/a>, a hrefhttp://mfcs2017.cs.aau.dk/ title42nd International Symposium on Mathematical Foundations of Computer Science>MFCS 2017/a>, a hrefhttps://www.fsttcs.org// title37th Foundations of Software Technology and Theoretical Computer Science>FSTTCS 2017/a>, a hrefhttps://stacs2018.sciencesconf.org/ title35th International Symposium on Theoretical Aspects of Computer Science>STACS 2018/a>, a hrefhttp://cie2018.uni-kiel.de/ titleComputability in Europe 2018>CIE 2018/a>, a hrefhttps://dlt2018.uec.ac.jp/ title22nd International Conference on Developments in Language Theory>DLT 2018/a>, a hrefhttp://iuuk.mff.cuni.cz/~icalp2018/ title45th International Colloquium on Automata, Languages, and Programming>ICALP 2018/a>, a hrefhttp://mfcs2018.csc.liv.ac.uk/ title43rd International Symposium on Mathematical Foundations of Computer Science>MFCS 2018/a>, a hrefhttp://lcs.ios.ac.cn/concur2018/ title29th International Conference on Concurrency Theory>CONCUR 2018/a>, a hrefhttps://www.fsttcs.org/archives/2018/ title38th Foundations of Software Technology and Theoretical Computer Science>FSTTCS 2018/a>, a hrefhttps://beda.dcs.fmph.uniba.sk/sofsem2019/ title45th International Conference on Current Trends in Theory and Practice of Computer Science>SOFSEM 2018/a>, a hrefhttps://lata2019.irdta.eu/ title13th International Conference on	Language and Automata Theory and Applications>LATA 2019/a>, a hrefhttps://lics.siglog.org/lics19/index.php titleThirty-Fourth Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2019/a>, a hrefhttps://icalp2019.upatras.gr/ title46th International Colloquium on Automata, Languages, and Programming>ICALP 2019/a>, a hrefhttp://www.fsttcs.org.in/2019/ title39th IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science>FSTTCS 2019/a>, a hrefhttps://www.issac-conference.org/2020/ titleInternational Symposium on Symbolic and Algebraic Computation>ISSAC 2020/a>, a hrefhttps://ramics19.lis-lab.fr/ title19th International Conference onRelational and Algebraic Methods in Computer Science>RAMiCS 2021/a>, a hrefhttps://www.conferences.uni-hamburg.de/event/272/page/153-home title40th International Symposium on Theoretical Aspects of Computer Science>STACS 2023/a>, and a hrefhttps://stacs2024.limos.fr/ title41st International Symposium on Theoretical Aspects of Computer Science>STACS 2024/a>./p>/div>/div>div idteaching>div classheading1>Teachingspan classbacktotop>  a href#top>back to top/a> /span>/div>div classheading3>Supervised theses/div>div classentry>ol>li>Martin Köhler (Bachelor thesis, 2014)/li>li>Phoebe Buckheister (Bachelor thesis, 2013)/li>/ol>/div>div classheading3>Lectures/div>div classentry>ul>li>span classcoursetitle>Concurrency Theory/span>, Winter term 2023/2024, at RPTU Kaiserslautern/li>li>span classcoursetitle>Concurrency Theory/span>, Winter term 2022/2023, at Technische Universität Kaiserslautern/li>li>span classcoursetitle>Concurrency Theory/span>, Winter term 2020/2021, at Technische Universität Kaiserslautern/li>li>span classcoursetitle>Concurrency Theory/span>, Summer term 2015, at Technische Universität Kaiserslautern/li>/ul>/div>div classheading3>Organization of exercise courses/div>div classentry>ul>li>span classcoursetitle>Logik/span>, Summer term 2014, at Technische Universität Kaiserslautern/li>li>span classcoursetitle>Logik/span>, Summer term 2013, at Technische Universität Kaiserslautern/li>li>span classcoursetitle>Logik/span>, Summer term 2012, at Technische Universität Kaiserslautern/li>li>span classcoursetitle>Applied Automata Theory/span>, Summer term 2011, at Technische Universität Kaiserslautern/li>/ul>/div>div classheading3>Tutoring/div>div classentry>ul>li>span classcoursetitle>Formale Grundlagen der Informatik I/span>, Summer term 2009, at Universität Hamburg/li>li>span classcoursetitle>Algorithmen und Datenstrukturen/span>, Winter term 2008/2009, at Universität Hamburg/li>li>span classcoursetitle>Formale Grundlagen der Informatik I/span>, Summer term 2008, at Universität Hamburg/li>li>span classcoursetitle>Formale Grundlagen der Informatik II/span>, Winter term 2007/2008, at Universität Hamburg/li>li>span classcoursetitle>Formale Grundlagen der Informatik I/span>, Summer term 2007, at Universität Hamburg/li>/ul>/div>/div>div idtalks>div classheading1>Talksspan classbacktotop>  a href#top>back to top/a> /span>/div>div classheading2>Invited talks/div>br/>div classentry>Given at Jewels of Automata Theory 2024 in Bordeaux, Francebr/>/div>br/>div classentry>Given at ANR Delta Project Meeting in Marseille, Francebr/>/div>br/>div classentry>span classtitle>Recent Advances on Reachability Problems in Valence Systems/span>br/>Given at a hrefhttps://rp2021.csc.liv.ac.uk/ title15th International Conference on Reachability Problems>RP 2021/a> in Liverpool, UKbr/>/div>br/>div classentry>span classtitle>Subword Based Abstractions of Formal Languages/span>br/>Given at a hrefhttp://www.zs.informatik.uni-kiel.de/de/theorietag-2016 titleTheorietag Automaten und formale Sprachen 2016>Theorietag Automaten und formale Sprachen 2016/a> in Tannenfelde, Germanybr/>span classlinklist idtheorietag2016-subword-linklist styledisplay:none;>[ span classjsbutton>a idtheorietag2016-subword-abstract-show  hrefjavascript:toggle(theorietag2016-subword-abstract)>Show abstract/a>/span>span classjsbutton>a idtheorietag2016-subword-abstract-hide hrefjavascript:toggle(theorietag2016-subword-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(theorietag2016-subword-linklist).style.displayinline;/script>div classabstract idtheorietag2016-subword-abstract>span classabstractheading>Abstract/span>br/>		A successful idea in the area of verification is to		consider finite-state abstractions of infinite-state		systems.  A prominent example is the fact that many		language classes satisfy a Parikhs theorem, i.e. for		each language, there exists a finite automaton that		accepts the same language up to the order of letters.		Hence, provided that the abstraction preserves		pertinent properties, this allows us to work with		finite-state systems, which are much easier to handle.		br/>		While Parikh-style abstractions have been studied very		intensely over the last decades, recent years have		seen an increasing interest in abstractions based on		the subword ordering. Examples include the set of (non		necessarily contiguous) subwords of members of a		language (the downward closure), or their superwords		(the upward closure).  Whereas it is well-known that		these closures are regular for any language, it is		often not obvious how to compute them.  Another type		of subword based abstractions are piecewise testable		separators.  Here, a separators acts as an abstraction		of a pair of languages.		br/>		This talk will present approaches to computing		closures, deciding separability by piecewise testable		languages, and a (perhaps surprising) connection		between these problems. If time permits, complexity		issues will be discussed as well.	/div>script typetext/javascript>document.getElementById(theorietag2016-subword-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Knapsack in Graph Groups, HNN-Extensions and Amalgamated Products/span>br/>(joint work with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>)br/>Given at a hrefhttp://www.macs.hw.ac.uk/~lc45/Conferences/2016/Diablerets.html titleEquations and formal languages in algebra>Equations and formal languages in algebra/a> in Les Diablerets, Switzerlandbr/>span classlinklist idlesdiablerets2016-linklist styledisplay:none;>[ span classjsbutton>a idlesdiablerets2016-abstract-show  hrefjavascript:toggle(lesdiablerets2016-abstract)>Show abstract/a>/span>span classjsbutton>a idlesdiablerets2016-abstract-hide hrefjavascript:toggle(lesdiablerets2016-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/LesDiablerets2016-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(lesdiablerets2016-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/LesDiablerets2016-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idlesdiablerets2016-abstract>span classabstractheading>Abstract/span>br/>		It is shown that the knapsack problem, which was introduced by Myasnikov et al.		for arbitrary finitely generated groups, can be solved in NP for graph		groups. This result even holds if the group elements are represented in a		compressed form by SLPs, which generalizes the classical NP-completeness		result of the integer knapsack problem. We also prove general transfer results:		NP-membership of the knapsack problem is passed on to finite		extensions, HNN-extensions over finite associated subgroups, and amalgamated		products with finite identified subgroups.	/div>script typetext/javascript>document.getElementById(lesdiablerets2016-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Recent Results on Erasing in Regulated Rewriting/span>br/>Given at a hrefhttp://theo.cs.uni-magdeburg.de/theorietag2011/ titleTheorietag Automaten und formale Sprachen 2011>Theorietag Automaten und formale Sprachen 2011/a> in Allrode, Germanybr/>span classlinklist idtheorietag2011-erasing-linklist styledisplay:none;>[ span classjsbutton>a idtheorietag2011-erasing-abstract-show  hrefjavascript:toggle(theorietag2011-erasing-abstract)>Show abstract/a>/span>span classjsbutton>a idtheorietag2011-erasing-abstract-hide hrefjavascript:toggle(theorietag2011-erasing-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://theo.cs.uni-magdeburg.de/theorietag2011/text/tagungsband-tt2011.pdf title>Online Proceedings/a> ]br/>/span>script typetext/javascript>document.getElementById(theorietag2011-erasing-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefhttp://theo.cs.uni-magdeburg.de/theorietag2011/text/tagungsband-tt2011.pdf title>Online Proceedings/a> ]br/>/span>/noscript>div classabstract idtheorietag2011-erasing-abstract>span classabstractheading>Abstract/span>br/>		For each grammar model with regulated rewriting, it is an important question		whether erasing productions add to its expressivity. In some cases, however,		this has been a longstanding open problem.		In recent years,		several results have been obtained that clarified the generative capacity of erasing		productions in some grammar models with classical types of regulated rewriting.		The aim of this talk is to give an overview of these results.	/div>script typetext/javascript>document.getElementById(theorietag2011-erasing-abstract).style.displaynone;/script>/div>br/>div classheading2>Other talks/div>br/>div classentry>span classtitle>The complexity of bidirected reachability in valence systems/span>br/>(joint work with a hrefhttps://people.mpi-sws.org/~mganardi/>Moses Ganardi/a> and a hrefhttps://people.mpi-sws.org/~rupak/>Rupak Majumdar/a>)br/>Given at a hrefhttps://lics.siglog.org/lics22/index.php titleThirty-Seventh Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2022/a> in Haifa, Israelbr/>span classlinklist idlics2022-linklist styledisplay:none;>[ span classjsbutton>a idlics2022-abstract-show  hrefjavascript:toggle(lics2022-abstract)>Show abstract/a>/span>span classjsbutton>a idlics2022-abstract-hide hrefjavascript:toggle(lics2022-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(lics2022-linklist).style.displayinline;/script>div classabstract idlics2022-abstract>span classabstractheading>Abstract/span>br/>		Reachability problems in infinite-state systems are often subject to extremely		high complexity. 		This motivates the investigation of efficient overapproximations, where we add transitions to		obtain a system in which reachability can be decided more easily. We consider		bidirected infinite-state systems, where for every transition there is a		transition with opposite effect.  We study bidirected reachability in the		framework of valence systems, an abstract model featuring finitely many control		states and an infinite-state storage that is specified by a finite graph.		By picking suitable graphs, valence systems can uniformly model counters as in vector addition systems,		pushdowns, integer counters, and combinations thereof.				We provide a comprehensive complexity landscape for bidirected reachability and show that		the complexity drops substantially (often to polynomial		time) from that of general reachability, for almost every storage mechanism		where reachability is known to be decidable.	/div>script typetext/javascript>document.getElementById(lics2022-abstract).style.displaynone;/script>/div>br/>div classentry>Given at a hrefhttps://www.dagstuhl.de/21452>Dagstuhl Seminar on Unambiguity in Automata Theory/a> in Schloss Dagstuhl, Germanybr/>/div>br/>div classentry>span classtitle>Context-bounded verification of liveness properties for multithreaded shared-memory programs/span>br/>Given at Seminar Méthodes Formelles at LaBRI in Bordeaux, Francebr/>/div>br/>div classentry>span classtitle>Rational Subsets of Baumslag-Solitar Groups/span>br/>Given at Seminar on Semigroups, Automata and Languages at Centro de Matemática, Universidade do Porto in Porto, Portugalbr/>/div>br/>div classentry>span classtitle>Rational Subsets of Baumslag-Solitar Groups/span>br/>Given at Göttingen-Kassel Theory (Online) Seminarbr/>/div>br/>div classentry>Given at a hrefhttps://www.dagstuhl.de/20483>Dagstuhl Seminar on Modern Aspects of Complexity Theory in Automata Theory/a> in Schloss Dagstuhl, Germanybr/>/div>br/>div classentry>span classtitle>Extensions of Omega-Regular Languages/span>br/>Given at a hrefhttp://highlights-conference.org/ titleHighlights of Logic, Games and Automata>Highlights 2020/a>br/>/div>br/>div classentry>span classtitle>Rational Subsets of Baumslag-Solitar Groups/span>br/>Given at Seminar Automates et applications at IRIF in Paris, Francebr/>/div>br/>div classentry>span classtitle>Extensions of Omega-Regular Languages/span>br/>Given at Seminar Automates et applications at IRIF in Paris, Francebr/>/div>br/>div classentry>span classtitle>Rational subsets of Baumslag-Solitar groups/span>br/>(joint work with a hrefhttps://michael.cadilhac.name/>Michaël Cadilhac/a> and a hrefhttps://warwick.ac.uk/fac/sci/dcs/people/dmitry_chistikov>Dmitry Chistikov/a>)br/>Given at a hrefhttps://icalp2020.saarland-informatics-campus.de/ title47th International Colloquium on Automata, Languages, and Programming>ICALP 2020/a>br/>/div>br/>div classentry>span classtitle>Coverability Is Undecidable in One-Dimensional Pushdown Vector Addition Systems with Resets/span>br/>(joint work with a hrefhttps://www.irif.fr/en/users/schmitz/index/>Sylvain Schmitz/a>)br/>Given at a hrefhttps://sites.uclouvain.be/rp2019/ title13th International Conference on Reachability Problems>RP 2019/a> in Brussels, Belgiumbr/>span classlinklist idrp2019-linklist styledisplay:none;>[ span classjsbutton>a idrp2019-abstract-show  hrefjavascript:toggle(rp2019-abstract)>Show abstract/a>/span>span classjsbutton>a idrp2019-abstract-hide hrefjavascript:toggle(rp2019-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(rp2019-linklist).style.displayinline;/script>div classabstract idrp2019-abstract>span classabstractheading>Abstract/span>br/>    We consider the model of pushdown vector addition systems with    resets. These consist of vector addition systems that have access    to a pushdown stack and have instructions to reset counters. For    this model, we study the coverability problem. In the absence of    resets, this problem is known to be decidable for one-dimensional    pushdown vector addition systems, but decidability is open for    general pushdown vector addition systems. Moreover, coverability    is known to be decidable for reset vector addition systems without    a pushdown stack. We show in this note that the problem is    undecidable for one-dimensional pushdown vector addition systems    with resets.  /div>script typetext/javascript>document.getElementById(rp2019-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Presburger arithmetic with stars, rational subsets of graph groups, and nested zero tests/span>br/>Given at a hrefhttp://highlights-conference.org/ titleHighlights of Logic, Games and Automata>Highlights 2019/a> in Warsaw, Polandbr/>/div>br/>div classentry>span classtitle>Regular subsets of wreath products/span>br/>Given at a hrefhttps://www.dagstuhl.de/en/program/calendar/semhp/?semnr19131>Dagstuhl Seminar on Algorithmic Problems in Group Theory/a> in Schloss Dagstuhl, Germanybr/>/div>br/>div classentry>Given at a hrefhttps://www.cmi.ac.in/~sri/CAALM2019/ titleComplexity, Algorithms, Automata and Logic Meet>CAALM 2021/a> in Chennai, Indiabr/>/div>br/>div classentry>span classtitle>Separability by piecewise testable languages and downward closures beyond subwords/span>br/>Given at a hrefhttps://lics.siglog.org/lics18/index.php titleThirty-Third Annual ACM/IEEE Symposium on Logic in Computer Science>LICS 2018/a> in Oxford, United Kingdombr/>span classlinklist idlics2018-linklist styledisplay:none;>[ span classjsbutton>a idlics2018-abstract-show  hrefjavascript:toggle(lics2018-abstract)>Show abstract/a>/span>span classjsbutton>a idlics2018-abstract-hide hrefjavascript:toggle(lics2018-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(lics2018-linklist).style.displayinline;/script>div classabstract idlics2018-abstract>span classabstractheading>Abstract/span>br/>  We introduce a flexible class of well-quasi-orderings (WQOs) on  words that generalizes the ordering of (not necessarily contiguous)  subwords.  Each such WQO induces a class of piecewise testable languages (PTLs)  as Boolean combinations of upward closed sets. In this way, a range  of regular language classes arises as PTLs. Moreover, each of the  WQOs guarantees regularity of all downward closed sets.  br/>  We consider two problems. First, we study which (perhaps  non-regular) language classes allow to decide whether two given  languages are separable by a PTL with respect to a given  WQO. Second, we want to effectively compute downward closures with  respect to these WQOs.  br/>  Our first main result is that for each of the WQOs, under mild  assumptions, both problems reduce to the simultaneous unboundedness  problem (SUP) and are thus solvable for many powerful system  models. In the second main result, we apply the framework to show  decidability of separability of regular languages by  $\mathcal{B}\Sigma_1, \mathsf{mod}$, a fragment of  first-order logic with modular predicates.  /div>script typetext/javascript>document.getElementById(lics2018-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Storage mechanisms and finite-state abstractions for software verification/span>br/>Given at MPI-SWS Colloquium in Kaiserslautern, Germanybr/>/div>br/>div classentry>span classtitle>Storage mechanisms and finite-state abstractions for software verification/span>br/>Given at Kolloquium Technische Universität Kaiserslautern in Germanybr/>/div>br/>div classentry>span classtitle>Parameterized WQOs, downward closures, and separability problems/span>br/>Given at Workshop on Separability Problems in Warsaw, Polandbr/>span classlinklist idseparability2017-linklist styledisplay:none;>[ span classjsbutton>a idseparability2017-abstract-show  hrefjavascript:toggle(separability2017-abstract)>Show abstract/a>/span>span classjsbutton>a idseparability2017-abstract-hide hrefjavascript:toggle(separability2017-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(separability2017-linklist).style.displayinline;/script>div classabstract idseparability2017-abstract>span classabstractheading>Abstract/span>br/>		We discuss a flexible class of well-quasi-orderings on words		that generalizes the ordering of (not necessarily contiguous)		subwords. Each of these orderings is specified by a finite		automaton or a counter automaton and, like the subword ordering,		guarantees regularity of all downward (or upward) closures.				We then consider two problems. First, we study for which language		classes one can effectively compute downward closures with		respect to these orderings.  Second, we are interested in which		language classes permit a decision procedure to decide whether		two given languages are separable by a PTL with respect to such		an ordering. Here, a PTL is a finite Boolean combination of		upward closed sets.				The main result is that, under mild assumptions on closure		properties, these two problems are solvable for the same language		classes. Moreover, solvability is equivalent to that of a		particular unboundedness problem that has recently been shown to		be decidable for many powerful language classes. 	/div>script typetext/javascript>document.getElementById(separability2017-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>First-order logic over the subword ordering/span>br/>(joint work with a hrefhttp://www.lsv.ens-cachan.fr/~halfon/>Simon Halfon/a> and a hrefhttp://www.lsv.ens-cachan.fr/~phs/>Philippe Schnoebelen/a>)br/>Given at Verification Seminar at Oxford University, United Kingdombr/>span classlinklist idoxford-verif-seminar-2017-linklist styledisplay:none;>[ span classjsbutton>a idoxford-verif-seminar-2017-abstract-show  hrefjavascript:toggle(oxford-verif-seminar-2017-abstract)>Show abstract/a>/span>span classjsbutton>a idoxford-verif-seminar-2017-abstract-hide hrefjavascript:toggle(oxford-verif-seminar-2017-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(oxford-verif-seminar-2017-linklist).style.displayinline;/script>div classabstract idoxford-verif-seminar-2017-abstract>span classabstractheading>Abstract/span>br/>    This talk reports on results concerning first-order logic over    the subword ordering on finite words. It has been known since    2006 that the whole first-order logic over this structure is    undecidable, whereas the Sigma_1 fragment is NP-complete.    One might therefore expect that introducing each word as a    constant would leave the Sigma_1 fragment decidable.  However,    it was shown recently that in the presence of these constants,    the \Sigma_1 theory becomes undecidable (already over two    letters).    Regarding the decidability border, we will consider fragments    where all but a certain number of variables are alternation    bounded, meaning that the variable must always be quantified over    languages with a bounded number of letter alternations.  Here,    the second result is that when at most two variables are not    alternation bounded, the \Sigma_1 fragment is decidable, and that    it becomes undecidable when three variables are not alternation    bounded.  Concerning higher quantifier alternation depths, the    \Sigma_2 fragment is undecidable already for one variable without    alternation bound and that when all variables are alternation    bounded, the entire first-order theory is decidable.    If time permits, complexity aspects will be treated as well.    This is joint work with Simon Halfon and Philippe Schnoebelen (to be    presented at LICS 2017).  /div>script typetext/javascript>document.getElementById(oxford-verif-seminar-2017-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Monoids as Storage Mechanisms/span>br/>Given at Kasseler Informatik-Kolloquium, Universität Kassel in Germanybr/>span classlinklist idkassel-kolloquium-2017-linklist styledisplay:none;>[ span classjsbutton>a idkassel-kolloquium-2017-abstract-show  hrefjavascript:toggle(kassel-kolloquium-2017-abstract)>Show abstract/a>/span>span classjsbutton>a idkassel-kolloquium-2017-abstract-hide hrefjavascript:toggle(kassel-kolloquium-2017-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(kassel-kolloquium-2017-linklist).style.displayinline;/script>div classabstract idkassel-kolloquium-2017-abstract>span classabstractheading>Abstract/span>br/>    The investigation of models extending finite automata by some    storage mechanism is a central theme in theoretical computer    science. Choosing an appropriate storage mechanism can yield a    model that is expressive enough to capture a given behavioral    aspect while admitting desired means of analysis.    It is therefore a central concern to understand which storage    mechanisms have which properties regarding expressiveness and    (algorithmic) analysis.  This talk presents a line of research    that aims for general insights in this direction. In other words:    How does the structure of the storage mechanism influence    expressiveness and analysis of the resulting model?    In order to study this question, one needs a model in which the    storage mechanism appears as a parameter. Such a model is    available in valence automata, where the storage mechanism is    given by a (typically infinite) monoid. Choosing a suitable    monoid then yields models such as Turing machines, pushdown    automata, vector addition systems, or combinations thereof.    This talk surveys a selection of results that characterize    storage mechanisms with certain desirable properties, such as    decidability of reachability, semilinearity of Parikh images, and    decidability of logics.   /div>script typetext/javascript>document.getElementById(kassel-kolloquium-2017-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>The Complexity of Knapsack in Graph Groups/span>br/>(joint work with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>)br/>Given at a hrefhttps://stacs2017.thi.uni-hannover.de/ title34th International Symposium on Theoretical Aspects of Computer Science>STACS 2017/a> in Hannover, Germanybr/>span classlinklist idstacs2017-linklist styledisplay:none;>[ span classjsbutton>a idstacs2017-abstract-show  hrefjavascript:toggle(stacs2017-abstract)>Show abstract/a>/span>span classjsbutton>a idstacs2017-abstract-hide hrefjavascript:toggle(stacs2017-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(stacs2017-linklist).style.displayinline;/script>div classabstract idstacs2017-abstract>span classabstractheading>Abstract/span>br/>		Myasnikov et al. have introduced the knapsack problem for arbitrary finitely		generated groups.  In previous work, the authors proved that for each graph		group, the knapsack problem can be solved in NP. Here, we determine the		exact complexity of the problem for every graph group. While the problem is		TC0-complete for complete graphs, it is LogCFL-complete for each		(non-complete) transitive forest. For every remaining graph, the problem is		NP-complete.	/div>script typetext/javascript>document.getElementById(stacs2017-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>First-order logic with reachability for infinite-state systems/span>br/>(joint work with a hrefhttp://emanueledosualdo.com/>Emanuele DOsualdo/a> and a hrefhttp://www.tcs.cs.tu-bs.de/group/meyer/home.html>Roland Meyer/a>)br/>Given at Seminar Modélisation et vérification at IRIF in Paris, Francebr/>span classlinklist idirif-verif-seminar-2016-linklist styledisplay:none;>[ span classjsbutton>a idirif-verif-seminar-2016-abstract-show  hrefjavascript:toggle(irif-verif-seminar-2016-abstract)>Show abstract/a>/span>span classjsbutton>a idirif-verif-seminar-2016-abstract-hide hrefjavascript:toggle(irif-verif-seminar-2016-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(irif-verif-seminar-2016-linklist).style.displayinline;/script>div classabstract idirif-verif-seminar-2016-abstract>span classabstractheading>Abstract/span>br/>		First-order logic with the reachability predicate (FOR)		is an important means of specification in system analysis.		Its decidability status is known for some individual		types of infinite-state systems such as pushdown (decidable)		and vector addition systems (undecidable).		br/>			This work aims at a general understanding of which types of		systems admit decidability.  As a unifying model, we employ		valence systems over graph monoids, which feature a		finite-state control and are parameterized by a monoid to		represent their storage mechanism.  As special cases, this		includes pushdown systems, various types of counter systems		(such as vector addition systems) and combinations thereof.		Our main result is a characterization of those		graph monoids where FOR is decidable for the resulting		transition systems. 	/div>script typetext/javascript>document.getElementById(irif-verif-seminar-2016-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Subword Based Abstractions of Formal Languages/span>br/>Given at Seminar Méthodes Formelles at LaBRI in Bordeaux, Francebr/>span classlinklist idlabri-seminar-2016-linklist styledisplay:none;>[ span classjsbutton>a idlabri-seminar-2016-abstract-show  hrefjavascript:toggle(labri-seminar-2016-abstract)>Show abstract/a>/span>span classjsbutton>a idlabri-seminar-2016-abstract-hide hrefjavascript:toggle(labri-seminar-2016-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(labri-seminar-2016-linklist).style.displayinline;/script>div classabstract idlabri-seminar-2016-abstract>span classabstractheading>Abstract/span>br/>		A successful idea in the area of verification is to		consider finite-state abstractions of infinite-state		systems.  A prominent example is the fact that many		language classes satisfy a Parikhs theorem, i.e. for		each language, there exists a finite automaton that		accepts the same language up to the order of letters.		Hence, provided that the abstraction preserves		pertinent properties, this allows us to work with		finite-state systems, which are much easier to handle.		br/>		While Parikh-style abstractions have been studied very		intensely over the last decades, recent years have		seen an increasing interest in abstractions based on		the subword ordering. Examples include the set of (non		necessarily contiguous) subwords of members of a		language (the downward closure), or their superwords		(the upward closure).  Whereas it is well-known that		these closures are regular for any language, it is		often not obvious how to compute them.  Another type		of subword based abstractions are piecewise testable		separators.  Here, a separators acts as an abstraction		of a pair of languages.		br/>		This talk will present approaches to computing		closures, deciding separability by piecewise testable		languages, and a (perhaps surprising) connection		between these problems. If time permits, complexity		issues will be discussed as well.	/div>script typetext/javascript>document.getElementById(labri-seminar-2016-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Subword Based Abstractions of Formal Languages/span>br/>Given at Seminar Automates et applications at IRIF in Paris, Francebr/>span classlinklist idirif-automata-2016-linklist styledisplay:none;>[ span classjsbutton>a idirif-automata-2016-abstract-show  hrefjavascript:toggle(irif-automata-2016-abstract)>Show abstract/a>/span>span classjsbutton>a idirif-automata-2016-abstract-hide hrefjavascript:toggle(irif-automata-2016-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(irif-automata-2016-linklist).style.displayinline;/script>div classabstract idirif-automata-2016-abstract>span classabstractheading>Abstract/span>br/>		A successful idea in the area of verification is to		consider finite-state abstractions of infinite-state		systems.  A prominent example is the fact that many		language classes satisfy a Parikhs theorem, i.e. for		each language, there exists a finite automaton that		accepts the same language up to the order of letters.		Hence, provided that the abstraction preserves		pertinent properties, this allows us to work with		finite-state systems, which are much easier to handle.		br/>		While Parikh-style abstractions have been studied very		intensely over the last decades, recent years have		seen an increasing interest in abstractions based on		the subword ordering. Examples include the set of (non		necessarily contiguous) subwords of members of a		language (the downward closure), or their superwords		(the upward closure).  Whereas it is well-known that		these closures are regular for any language, it is		often not obvious how to compute them.  Another type		of subword based abstractions are piecewise testable		separators.  Here, a separators acts as an abstraction		of a pair of languages.		br/>		This talk will present approaches to computing		closures, deciding separability by piecewise testable		languages, and a (perhaps surprising) connection		between these problems. If time permits, complexity		issues will be discussed as well.	/div>script typetext/javascript>document.getElementById(irif-automata-2016-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>First-order logic with reachability for valence automata over graph monoids/span>br/>(joint work with a hrefhttp://emanueledosualdo.com/>Emanuele DOsualdo/a> and a hrefhttp://www.tcs.cs.tu-bs.de/group/meyer/home.html>Roland Meyer/a>)br/>Given at a hrefhttp://www.zs.informatik.uni-kiel.de/de/theorietag-2016 titleJahrestagung Logik in der Informatik 2016>Jahrestagung Logik in der Informatik 2016/a> in Tannenfelde, Germanybr/>span classlinklist idtheorietag2016-for-linklist styledisplay:none;>[ span classjsbutton>a idtheorietag2016-for-abstract-show  hrefjavascript:toggle(theorietag2016-for-abstract)>Show abstract/a>/span>span classjsbutton>a idtheorietag2016-for-abstract-hide hrefjavascript:toggle(theorietag2016-for-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(theorietag2016-for-linklist).style.displayinline;/script>div classabstract idtheorietag2016-for-abstract>span classabstractheading>Abstract/span>br/>		First-order logic with the reachability predicate (FOR)		is an important means of specification in system analysis.		Its decidability status is known for some individual		types of infinite-state systems such as pushdown (decidable)		and vector addition systems (undecidable).		br/>			This work aims at a general understanding of which types of		systems admit decidability.  As a unifying model, we employ		valence systems over graph monoids, which feature a		finite-state control and are parameterized by a monoid to		represent their storage mechanism.  As special cases, this		includes pushdown systems, various types of counter systems		(such as vector addition systems) and combinations thereof.		Our main result is a characterization of those		graph monoids where FOR is decidable for the resulting		transition systems. 	/div>script typetext/javascript>document.getElementById(theorietag2016-for-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Monoids as Storage Mechanisms/span>br/>Given at Theory Seminar at the National University of Singaporebr/>span classlinklist idnus-seminar-2016-09-01-linklist styledisplay:none;>[ span classjsbutton>a idnus-seminar-2016-09-01-abstract-show  hrefjavascript:toggle(nus-seminar-2016-09-01-abstract)>Show abstract/a>/span>span classjsbutton>a idnus-seminar-2016-09-01-abstract-hide hrefjavascript:toggle(nus-seminar-2016-09-01-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(nus-seminar-2016-09-01-linklist).style.displayinline;/script>div classabstract idnus-seminar-2016-09-01-abstract>span classabstractheading>Abstract/span>br/>		The investigation of models extending finite automata by some		storage mechanism is a central theme in theoretical computer		science. Choosing an appropriate storage mechanism can yield a		model that is expressive enough to capture a given behavioral		aspect while admitting desired means of analysis.		br/>		It is therefore a central concern to understand which storage		mechanisms have which properties regarding expressiveness and		(algorithmic) analysis.  This talk presents a line of research		that aims for general insights in this direction. In other words:		How does the structure of the storage mechanism influence		expressiveness and analysis of the resulting model?		br/>		In order to study this question, one needs a model in which the		storage mechanism appears as a parameter. Such a model is		available in valence automata, where the storage mechanism is		given by a (typically infinite) monoid. Choosing a suitable		monoid then yields models such as Turing machines, pushdown		automata, vector addition systems, or combinations thereof.		br/>		This talk surveys a selection of results that characterize		storage mechanisms with certain desirable properties, such as		decidability of reachability, semilinearity of Parikh images, and		decidability of logics.	/div>script typetext/javascript>document.getElementById(nus-seminar-2016-09-01-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Monoids as Storage Mechanisms/span>br/>Given at Communicating, Distributed and Parameterized Systems in Singaporebr/>span classlinklist idcdps2016-linklist styledisplay:none;>[ span classjsbutton>a idcdps2016-abstract-show  hrefjavascript:toggle(cdps2016-abstract)>Show abstract/a>/span>span classjsbutton>a idcdps2016-abstract-hide hrefjavascript:toggle(cdps2016-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(cdps2016-linklist).style.displayinline;/script>div classabstract idcdps2016-abstract>span classabstractheading>Abstract/span>br/>		The investigation of models extending finite automata by some		storage mechanism is a central theme in theoretical computer		science. Choosing an appropriate storage mechanism can yield a		model that is expressive enough to capture a given behavioral		aspect while admitting desired means of analysis.		br/>		It is therefore a central concern to understand which storage		mechanisms have which properties regarding expressiveness and		(algorithmic) analysis.  This talk presents a line of research		that aims for general insights in this direction. In other		words: How does the structure of the storage mechanism		influence expressiveness and analysis of the resulting model?		br/>		In order to study this question, one needs a model in which the		storage mechanism appears as a parameter. Such a model is		available in valence automata, where the storage mechanism is		given by a (typically infinite) monoid. Choosing a suitable		monoid then yields models such as Turing machines, pushdown		automata, vector addition systems, or combinations thereof.		br/>		This talk surveys a selection of results that characterize		storage mechanisms with certain desirable properties, such as		decidability of reachability, semilinearity of Parikh images,		and decidability of logics. 	/div>script typetext/javascript>document.getElementById(cdps2016-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>The Complexity of Downward Closure Comparisons/span>br/>Given at a hrefhttp://www.easyconferences.eu/icalp2016/ title43rd International Colloquium on Automata, Languages and Programming>ICALP 2016/a> in Rome, Italybr/>span classlinklist idicalp2016-linklist styledisplay:none;>[ span classjsbutton>a idicalp2016-abstract-show  hrefjavascript:toggle(icalp2016-abstract)>Show abstract/a>/span>span classjsbutton>a idicalp2016-abstract-hide hrefjavascript:toggle(icalp2016-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(icalp2016-linklist).style.displayinline;/script>div classabstract idicalp2016-abstract>span classabstractheading>Abstract/span>br/>		The downward closure of a language is the set of all (not necessarily		contiguous) subwords of its members. It is well-known that the downward		closure of every language is regular. Moreover, recent results show		that downward closures are computable for quite powerful system models.		br/>		One advantage of abstracting a language by its downward closure is that then,		equivalence and inclusion become decidable. In this work, we study the		complexity of these two problems. More precisely, we consider the following		decision problems: Given languages $K$ and $L$ from classes $\C$ and $\D$,		respectively, does the downward closure of $K$ include (equal) that of $L$?		br/>		These problems are investigated for finite automata, one-counter automata,		context-free grammars, and reversal-bounded counter automata. For each		combination, we prove a completeness result either for fixed or for arbitrary		alphabets.  Moreover, for Petri net languages, we show that both problems are		Ackermann-hard and for higher-order pushdown automata of order $k$, we prove		hardness for complements of nondeterministic $k$-fold exponential time.	/div>script typetext/javascript>document.getElementById(icalp2016-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Boolean closed full trios and rational Kripke frames/span>br/>(joint work with a hrefhttp://eiche.theoinf.tu-ilmenau.de/kuske/>Dietrich Kuske/a> and a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>)br/>Given at Seminar of the INFINI group at LSV in May 2016 in Cachan, Francebr/>span classlinklist idgdt-infini-05-2016-linklist styledisplay:none;>[ span classjsbutton>a idgdt-infini-05-2016-abstract-show  hrefjavascript:toggle(gdt-infini-05-2016-abstract)>Show abstract/a>/span>span classjsbutton>a idgdt-infini-05-2016-abstract-hide hrefjavascript:toggle(gdt-infini-05-2016-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/Seminar-INFINI-05-2016-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(gdt-infini-05-2016-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Seminar-INFINI-05-2016-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idgdt-infini-05-2016-abstract>span classabstractheading>Abstract/span>br/>		It is a well-known phenomenon that languages classes induced		by infinite-state systems usually lack decidability and		closure properties that make regular languages pleasant to		analyze. Most notably, nondeterministic infinite-state		systems typically fail to be closed under Boolean		operations.  In visibly pushdown automata, one has closure		under Boolean operations, but at the expense of restricting		the employed input alphabets, meaning they are not closed		under rational transductions.		br/>		This raises the question of whether there is some type of		infinite-state system that enjoys closure under Boolean		operations and rational transductions (and permits		decidability of, say, the emptiness problem).  This talk		demonstrates that this is not the case. It is shown that		every language class that contains any non-regular language		and is closed under Boolean operations and rational		transductions already contains the whole arithmetic		hierarchy (which significantly extends the recursively		enumerable languages).	/div>script typetext/javascript>document.getElementById(gdt-infini-05-2016-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>The complexity of downward closure comparisons/span>br/>Given at a hrefhttp://shonan.nii.ac.jp/seminar/078/ titleNII Shonan Meeting on Higher-Order Model Checking>NII Shonan Meeting on Higher-Order Model Checking/a> in Shonan, Japanbr/>span classlinklist idshonan2016-linklist styledisplay:none;>[ span classjsbutton>a idshonan2016-abstract-show  hrefjavascript:toggle(shonan2016-abstract)>Show abstract/a>/span>span classjsbutton>a idshonan2016-abstract-hide hrefjavascript:toggle(shonan2016-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/Shonan2016-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(shonan2016-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Shonan2016-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idshonan2016-abstract>span classabstractheading>Abstract/span>br/>		The downward closure of a language is the set of all (not		necessarily contiguous) subwords of its members. It is		well-known that the downward closure of every language is		regular.  One advantage of abstracting a language by its		downward closure is that then, equivalence and inclusion		become decidable.		br/>		It has recently been shown by Hague, Kochems, and Ong that		downward closures are computable for higher-order pushdown		automata. However, the current method yields no upper bound		on the complexity of such a computation. This talk will		present recent results on complexity issues surrounding		downward closures.  Aside from general algorithms and		possible approaches to obtain upper bounds in the case of		HOPA, we will discuss a lower bound result for the		abovementioned equivalence and inclusion problem for HOPA.	/div>script typetext/javascript>document.getElementById(shonan2016-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Knapsack in Graph Groups, HNN-Extensions and Amalgamated Products/span>br/>(joint work with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>)br/>Given at a hrefhttp://www.univ-orleans.fr/lifo/events/STACS2016/ title33rd International Symposium on Theoretical Aspects of Computer Science>STACS 2016/a> in Orléans, Francebr/>span classlinklist idstacs2016-linklist styledisplay:none;>[ span classjsbutton>a idstacs2016-abstract-show  hrefjavascript:toggle(stacs2016-abstract)>Show abstract/a>/span>span classjsbutton>a idstacs2016-abstract-hide hrefjavascript:toggle(stacs2016-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/STACS2016-LohreyZetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(stacs2016-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/STACS2016-LohreyZetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idstacs2016-abstract>span classabstractheading>Abstract/span>br/>		It is shown that the knapsack problem, which was introduced by Myasnikov et al.		for arbitrary finitely generated groups, can be solved in NP for graph		groups. This result even holds if the group elements are represented in a		compressed form by SLPs, which generalizes the classical NP-completeness		result of the integer knapsack problem. We also prove general transfer results:		NP-membership of the knapsack problem is passed on to finite		extensions, HNN-extensions over finite associated subgroups, and amalgamated		products with finite identified subgroups.	/div>script typetext/javascript>document.getElementById(stacs2016-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Monoids as Storage Mechanisms/span>br/>Given at Seminar of the INFINI group at LSV in December 2015 in Cachan, Francebr/>span classlinklist idgdt-infini-12-2015-linklist styledisplay:none;>[ span classjsbutton>a idgdt-infini-12-2015-abstract-show  hrefjavascript:toggle(gdt-infini-12-2015-abstract)>Show abstract/a>/span>span classjsbutton>a idgdt-infini-12-2015-abstract-hide hrefjavascript:toggle(gdt-infini-12-2015-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/Seminar-INFINI-12-2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(gdt-infini-12-2015-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Seminar-INFINI-12-2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idgdt-infini-12-2015-abstract>span classabstractheading>Abstract/span>br/>		The investigation of models extending finite automata by some storage mechanism		is a central theme in theoretical computer science. Choosing an appropriate		storage mechanism can yield a model that is expressive enough to capture a		given behavioral aspect while admitting desired means of analysis.		br/>		It is therefore a central concern to understand which storage mechanisms have		which properties regarding expressiveness and (algorithmic) analysis.  This		talk presents a line of research that aims for general insights in this		direction. In other words: How does the structure of the storage mechanism		influences expressiveness and analysis of the resulting model?		br/>		In order to study this question, one needs a model in which the storage		mechanism appears as a parameter. Such a model is available in valence		automata, where the storage mechanism is given by a (typically infinite)		monoid. Choosing a suitable monoid then yields models such as Turing machines,		pushdown automata, vector addition systems, or combinations thereof.		br/>		This talk surveys a selection of results that characterize storage mechanisms		with certain desirable properties, such as deciability of reachability,		semilinearity of Parikh images, and avoidability of epsilon-transitions.	/div>script typetext/javascript>document.getElementById(gdt-infini-12-2015-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>An Approach to Computing Downward Cosures/span>br/>Given at a hrefhttps://www.uni-trier.de/index.php?id55089 titleTheorietag Automaten und formale Sprachen 2015>Theorietag Automaten und formale Sprachen 2015/a> in Speyer, Germanybr/>span classlinklist idtheorietag2015-linklist styledisplay:none;>[ span classjsbutton>a idtheorietag2015-abstract-show  hrefjavascript:toggle(theorietag2015-abstract)>Show abstract/a>/span>span classjsbutton>a idtheorietag2015-abstract-hide hrefjavascript:toggle(theorietag2015-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/Theorietag2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(theorietag2015-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Theorietag2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idtheorietag2015-abstract>span classabstractheading>Abstract/span>br/>		The downward closure of a word language is the set of all (not necessarily		contiguous) subwords of its members. It is known that the downward closure of		every language is regular. However, algorithms for computing a finite automaton		for the downward closure of a given language are known only for few language		classes.  This work presents a simple general approach to this problem.  It is		used to prove that downward closures are computable for (i)~every language		class with effectively semilinear Parikh images that is closed under rational		transductions, (ii)~matrix languages, and (iii)~indexed languages		(equivalently, languages accepted by higher-order pushdown automata of		order~2).	/div>script typetext/javascript>document.getElementById(theorietag2015-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>The Emptiness Problem for Valence Automata or: Another Decidable Extension of Petri Nets/span>br/>Given at a hrefhttp://rp2015.mimuw.edu.pl/ title9th International Workshop on Reachability Problems>RP 2015/a> in Warsaw, Polandbr/>span classlinklist idrp2015-linklist styledisplay:none;>[ span classjsbutton>a idrp2015-abstract-show  hrefjavascript:toggle(rp2015-abstract)>Show abstract/a>/span>span classjsbutton>a idrp2015-abstract-hide hrefjavascript:toggle(rp2015-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/RP2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(rp2015-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/RP2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idrp2015-abstract>span classabstractheading>Abstract/span>br/>	This work studies which storage mechanisms in automata permit	decidability of the reachability problem. The question is formalized	using valence automata, an abstract model that generalizes automata with	storage. For each of a variety of storage mechanisms, one can choose a	(typically infinite) monoid $M$ such that valence automata over $M$ are	equivalent to (one-way) automata with this type of storage.	br/>	In fact, many interesting storage mechanisms can be realized by monoids defined	by finite graphs, called graph monoids.  Hence, we study for which graph	monoids the emptiness problem for valence automata is decidable. A particular	model realized by graph monoids is that of Petri nets with a pushdown stack.	For these, decidability is a long-standing open question and we do not answer	it here.	br/>	However, if one excludes subgraphs corresponding to this model, a	characterization can be achieved. This characterization yields a new extension	of Petri nets with a decidable reachability problem.  Moreover, we provide a	description of those storage mechanisms for which decidability remains open.	This leads to a natural model that generalizes both pushdown Petri nets and	priority multicounter machines.	/div>script typetext/javascript>document.getElementById(rp2015-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>An Approach to Computing Downward Closures/span>br/>Given at a hrefhttp://www.kurims.kyoto-u.ac.jp/icalp2015/ title42nd International Colloquium on Automata, Languages and Programming>ICALP 2015/a> in Kyoto, Japanbr/>span classlinklist idicalp2015-linklist styledisplay:none;>[ span classjsbutton>a idicalp2015-abstract-show  hrefjavascript:toggle(icalp2015-abstract)>Show abstract/a>/span>span classjsbutton>a idicalp2015-abstract-hide hrefjavascript:toggle(icalp2015-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/ICALP2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(icalp2015-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/ICALP2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idicalp2015-abstract>span classabstractheading>Abstract/span>br/>                The downward closure of a word language is the set                of all (not necessarily contiguous) subwords of its                members. It is well-known that the downward closure of                any language is regular. While the downward closure                appears to be a powerful abstraction, algorithms for                computing a finite automaton for the downward closure                of a given language have been established only for few                language classes.		br/>                This work presents a simple general method for computing                downward closures. For language classes that are closed                under rational transductions, it is shown that the                computation of downward closures can be reduced to                checking a certain unboundedness property.		br/>                This result is used to prove that downward closures                are computable for (i) every language class with                effectively semilinear Parikh images that are closed                under rational transductions, (ii) matrix languages,                and (iii) indexed languages (equivalently, languages                accepted by higher-order pushdown automata of order~2).	/div>script typetext/javascript>document.getElementById(icalp2015-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Downward Closures of Indexed Languages/span>br/>Given at a hrefhttp://hopa.cs.rhul.ac.uk/ titleWorkshop on Higher-Order Program Analysis>HOPA 2015/a> in Kyoto, Japanbr/>span classlinklist idhopa2015-linklist styledisplay:none;>[ a hrefdoc/HOPA2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(hopa2015-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/HOPA2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>/div>br/>div classentry>span classtitle>Computing downward closures for stacked counter automata/span>br/>Given at a hrefhttp://www14.in.tum.de/STACS2015/ title32nd International Symposium on Theoretical Aspects of Computer Science>STACS 2015/a> in Munich, Germanybr/>span classlinklist idstacs2015-linklist styledisplay:none;>[ span classjsbutton>a idstacs2015-abstract-show  hrefjavascript:toggle(stacs2015-abstract)>Show abstract/a>/span>span classjsbutton>a idstacs2015-abstract-hide hrefjavascript:toggle(stacs2015-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/STACS2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(stacs2015-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/STACS2015-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idstacs2015-abstract>span classabstractheading>Abstract/span>br/>		The downward closure of a language $L$ of words is the set of all (not		necessarily contiguous) subwords of members of $L$. It is well known that the		downward closure of any language is regular. Although the downward		closure seems to be a promising abstraction, there are only few language		classes for which an automaton for the downward closure is known to be		computable.		br/>		It is shown here that for stacked counter automata, the downward closure is		computable.  Stacked counter automata are finite automata with a storage		mechanism obtained by \emph{adding blind counters} and \emph{building stacks}.		Hence, they generalize pushdown and blind counter automata.		br/>		The class of languages accepted by these automata are precisely those in the		hierarchy obtained from the context-free languages by alternating two closure		operators: imposing semilinear constraints and taking the algebraic extension.		The main tool for computing downward closures is the new concept of Parikh		annotations.  As a second application of Parikh annotations, it is shown that		the hierarchy above is strict at every level.	/div>script typetext/javascript>document.getElementById(stacs2015-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Effectively regular downward closures/span>br/>Given at LSV Seminar at ENS Cachan in Cachan, Francebr/>span classlinklist idlsv-seminar-2014-linklist styledisplay:none;>[ span classjsbutton>a idlsv-seminar-2014-abstract-show  hrefjavascript:toggle(lsv-seminar-2014-abstract)>Show abstract/a>/span>span classjsbutton>a idlsv-seminar-2014-abstract-hide hrefjavascript:toggle(lsv-seminar-2014-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/LSV-Seminar-2014-10-28-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(lsv-seminar-2014-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/LSV-Seminar-2014-10-28-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idlsv-seminar-2014-abstract>span classabstractheading>Abstract/span>br/>        The downward closure of a language is the set of all (not        necessarily contiguous) subwords of its members. It is a        well-known consequence of Higmans Lemma that the downward        closure of every language is regular.	br/>        Aside from encoding interesting counting properties, the        downward closure constitutes a promising abstraction: If L is        the set of action sequences of a system, then the downward        closure of L is precisely what is observed through a lossy        channel, i.e. when actions can go unnoticed arbitrarily. Hence,        if the downward closure is available as a regular language,        the equivalence and even inclusion of system behaviors can be        decided with respect to such observations.	br/>        However, there are only few classes of languages for which it is        known how to compute the downward closure of a given language as        a finite automaton. This talk presents new approaches to this        problem.	/div>script typetext/javascript>document.getElementById(lsv-seminar-2014-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Expressiveness and analysis of valence automata over graph monoids/span>br/>Given at a hrefhttp://wwwagak.cs.uni-kl.de/News/format-workshop-2014.html>FORMAT Workshop 07/2014/a> in Kaiserslautern, Germanybr/>span classlinklist idformat-07-2014-linklist styledisplay:none;>[ a hrefdoc/FORMAT-07-2014-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(format-07-2014-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/FORMAT-07-2014-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>/div>br/>div classentry>span classtitle>Of stacks (of stacks (...) with blind counters) with blind counters/span>br/>Given at a hrefhttp://www.informatik.uni-bremen.de/~goeller/AISS14/ titleAlgorithmics on Infinite State Systems>AISS 2014/a> in Vienna, Austriabr/>span classlinklist idaiss2014-linklist styledisplay:none;>[ span classjsbutton>a idaiss2014-abstract-show  hrefjavascript:toggle(aiss2014-abstract)>Show abstract/a>/span>span classjsbutton>a idaiss2014-abstract-hide hrefjavascript:toggle(aiss2014-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/AISS2014-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(aiss2014-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/AISS2014-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idaiss2014-abstract>span classabstractheading>Abstract/span>br/>		Recent work on automata with abstract storage revealed a class of		storage mechanisms that proves quite expressive and amenable to various		kinds of algorithmic analysis. The storage mechanisms in this class are		obtained by \emph{building stacks} and \emph{adding blind counters}.		br/>		The former is to construct a new mechanism that stores a stack whose		entries are configurations of an old mechanism. One can then manipulate		the topmost entry, pop it if empty, or start a new one on top. Adding a		blind counter to an old mechanism yields a new mechanism in which the		old one and a blind counter can be used simultaneously. We call the		resulting model \emph{stacked counter automaton}.		br/>		This talk presents results on expressivity, Parikh images, membership		problems, and the computability of downward closures.	/div>script typetext/javascript>document.getElementById(aiss2014-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>On Boolean closed full trios and rational Kripke frames/span>br/>(joint work with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>)br/>Given at a hrefhttp://stacs2014.sciencesconf.org/ title31st International Symposium on Theoretical Aspects of Computer Science>STACS 2014/a> in Lyon, Francebr/>span classlinklist idstacs2014-linklist styledisplay:none;>[ span classjsbutton>a idstacs2014-abstract-show  hrefjavascript:toggle(stacs2014-abstract)>Show abstract/a>/span>span classjsbutton>a idstacs2014-abstract-hide hrefjavascript:toggle(stacs2014-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/STACS2014-LohreyZetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(stacs2014-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/STACS2014-LohreyZetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idstacs2014-abstract>span classabstractheading>Abstract/span>br/>		A Boolean closed full trio is a class of languages that is closed under the		Boolean operations (union, intersection, and complementation) and rational		transductions. It is well-known that the regular languages constitute such a		Boolean closed full trio. It is shown here that every such language class that		contains any non-regular language already includes the whole arithmetical		hierarchy (and even the one relative to this language).		br/>		A consequence of this result is that aside from the regular languages, no full		trio generated by one language is closed under complementation.		br/>		Our construction also shows that there is a fixed rational Kripke frame such		that assigning an arbitrary non-regular language to some variable allows the		definition of any language from the arithmetical hierarchy in the		corresponding Kripke structure using multimodal logic.	/div>script typetext/javascript>document.getElementById(stacs2014-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>On Boolean closed full trios and rational Kripke frames/span>br/>(joint work with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>)br/>Given at Seminar Automata and Logic at Technische Universität Ilmenau in Ilmenau, Germanybr/>span classlinklist idseminar-ilmenau-2013-11-linklist styledisplay:none;>[ span classjsbutton>a idseminar-ilmenau-2013-11-abstract-show  hrefjavascript:toggle(seminar-ilmenau-2013-11-abstract)>Show abstract/a>/span>span classjsbutton>a idseminar-ilmenau-2013-11-abstract-hide hrefjavascript:toggle(seminar-ilmenau-2013-11-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(seminar-ilmenau-2013-11-linklist).style.displayinline;/script>div classabstract idseminar-ilmenau-2013-11-abstract>span classabstractheading>Abstract/span>br/>		A Boolean closed full trio is a class of languages that is closed under Boolean		operations (union, intersection, and complement) and rational transductions. It		is well-known that the regular languages constitute such a Boolean closed full		trio. It is shown here that every such language class that contains any		non-regular language already includes the whole arithmetical hierarchy		(and even the one relative to this language).		br/>		Our construction also shows that there is a fixed rational Kripke frame such		that assigning an arbitrary non-regular language to some variable allows the		interpretation of any language from the arithmetical hierarchy in the		corresponding Kripke structure.		br/>		Another consequence of our result is that no full trio generated by one		language is closed under complementation, unless it coincides with the regular		languages. 	/div>script typetext/javascript>document.getElementById(seminar-ilmenau-2013-11-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>On Boolean closed full trios and rational Kripke frames/span>br/>(joint work with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a>)br/>Given at a hrefhttp://eiche.theoinf.tu-ilmenau.de/kuske/Theorietag2013/ titleTheorietag Automaten und formale Sprachen 2013>Theorietag Automaten und formale Sprachen 2013/a> in Ilmenau, Germanybr/>span classlinklist idtheorietag2013-trios-linklist styledisplay:none;>[ span classjsbutton>a idtheorietag2013-trios-abstract-show  hrefjavascript:toggle(theorietag2013-trios-abstract)>Show abstract/a>/span>span classjsbutton>a idtheorietag2013-trios-abstract-hide hrefjavascript:toggle(theorietag2013-trios-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/Theorietag2013-LohreyZetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(theorietag2013-trios-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Theorietag2013-LohreyZetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idtheorietag2013-trios-abstract>span classabstractheading>Abstract/span>br/>		A Boolean closed full trio is a class of languages that is closed under Boolean		operations (union, intersection, and complement) and rational transductions. It		is well-known that the regular languages constitute such a Boolean closed full		trio. We present a result stating that every such language class that		contains any non-regular language already contains the whole arithmetical		hierarchy.		br/>		Our construction also shows that there is a fixed rational Kripke frame such		that assigning an arbitrary non-regular language to some variable allows the		interpretation of any language from the arithmetical hierarchy in the		corresponding Kripke structure.	/div>script typetext/javascript>document.getElementById(theorietag2013-trios-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Recent advances on valence automata as a generalization of automata with storage/span>br/>(joint work with Phoebe Buckheister)br/>Given at a hrefhttp://eiche.theoinf.tu-ilmenau.de/kuske/Theorietag2013/ titleTheorietag Automaten und formale Sprachen 2013>Theorietag Automaten und formale Sprachen 2013/a> in Ilmenau, Germanybr/>span classlinklist idtheorietag2013-valence-linklist styledisplay:none;>[ span classjsbutton>a idtheorietag2013-valence-abstract-show  hrefjavascript:toggle(theorietag2013-valence-abstract)>Show abstract/a>/span>span classjsbutton>a idtheorietag2013-valence-abstract-hide hrefjavascript:toggle(theorietag2013-valence-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/Theorietag2013-BuckheisterZetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(theorietag2013-valence-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/Theorietag2013-BuckheisterZetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idtheorietag2013-valence-abstract>span classabstractheading>Abstract/span>br/>                A valence automaton over a monoid $M$ is a finite automaton                in which each edge carries an input word and an element of                $M$. A word is then accepted if there is a run that spells                the word such that the product of the monoid elements is the                identity.                br/>                By choosing suitable monoids $M$, one can obtain various                kinds of automata with storage as special valence automata.                Examples include pushdown automata, blind multicounter                automata, and partially blind multicounter automata.                Therefore, valence automata offer a framework to generalize                results on such automata with storage.                br/>                This talk will present recent advances in this direction.  The addressed                questions include: For which monoids do we have a Parikhs Theorem (as for                pushdown automata)? For which monoids can we avoid silent transitions?        /div>script typetext/javascript>document.getElementById(theorietag2013-valence-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Semilinearity and Context-Freeness of Languages Accepted by Valence Automata/span>br/>(joint work with Phoebe Buckheister)br/>Given at a hrefhttp://ist.ac.at/mfcs13/ title38th International Symposium on Mathematical Foundations of Computer Science>MFCS 2013/a> in Klosterneuburg, Austriabr/>span classlinklist idmfcs2013-semilinearity-linklist styledisplay:none;>[ span classjsbutton>a idmfcs2013-semilinearity-abstract-show  hrefjavascript:toggle(mfcs2013-semilinearity-abstract)>Show abstract/a>/span>span classjsbutton>a idmfcs2013-semilinearity-abstract-hide hrefjavascript:toggle(mfcs2013-semilinearity-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/MFCS2013-BuckheisterZetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(mfcs2013-semilinearity-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/MFCS2013-BuckheisterZetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idmfcs2013-semilinearity-abstract>span classabstractheading>Abstract/span>br/>		Valence automata are a generalization of various models of automata with		storage.  Here, each edge carries, in addition to an input word, an element of		a monoid. A computation is considered valid if multiplying the monoid elements		on the visited edges yields the identity element. By choosing suitable		monoids, a variety of automata models can be obtained as special valence		automata.		This work is concerned with the accepting power of valence automata.		Specifically, we ask for which monoids valence automata can accept only		context-free languages or only languages with semilinear Parikh image,		respectively.		First, we present a characterization of those graph products (of monoids) for		which valence automata accept only context-free languages. Second, we provide a		necessary and sufficient condition for a graph product of copies of the		bicyclic monoid and the integers to yield only languages with semilinear Parikh		image when used as a storage mechanism in valence automata. Third, we show that		all languages accepted by valence automata over torsion groups have a		semilinear Parikh image.	/div>script typetext/javascript>document.getElementById(mfcs2013-semilinearity-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Rational Subsets and Submonoids of Wreath Products/span>br/>(joint work with a hrefhttp://www.eti.uni-siegen.de/ti/mitarbeiter/lohrey/>Markus Lohrey/a> and a hrefhttp://www.sci.ccny.cuny.edu/~benjamin/>Benjamin Steinberg/a>)br/>Given at a hrefhttp://www.icalp2013.lu.lv/ title40th International Colloquium on Automata, Languages and Programming>ICALP 2013/a> in Riga, Latviabr/>span classlinklist idicalp2013-rational-linklist styledisplay:none;>[ span classjsbutton>a idicalp2013-rational-abstract-show  hrefjavascript:toggle(icalp2013-rational-abstract)>Show abstract/a>/span>span classjsbutton>a idicalp2013-rational-abstract-hide hrefjavascript:toggle(icalp2013-rational-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/ICALP2013-LohreySteinbergZetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(icalp2013-rational-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/ICALP2013-LohreySteinbergZetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idicalp2013-rational-abstract>span classabstractheading>Abstract/span>br/>		It is shown that membership in rational subsets of wreath		products $H \wr V$ with $H$ a finite group and $V$ a virtually		free group is decidable. On the other hand, it is shown that		there exists a fixed finitely generated submonoid in the wreath		product $\mathbb{Z}\wr\mathbb{Z}$ with an undecidable		membership problem.	/div>script typetext/javascript>document.getElementById(icalp2013-rational-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Silent Transitions in Automata with Storage/span>br/>Given at a hrefhttp://www.icalp2013.lu.lv/ title40th International Colloquium on Automata, Languages and Programming>ICALP 2013/a> in Riga, Latviabr/>span classlinklist idicalp2013-silent-linklist styledisplay:none;>[ span classjsbutton>a idicalp2013-silent-abstract-show  hrefjavascript:toggle(icalp2013-silent-abstract)>Show abstract/a>/span>span classjsbutton>a idicalp2013-silent-abstract-hide hrefjavascript:toggle(icalp2013-silent-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/ICALP2013-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(icalp2013-silent-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/ICALP2013-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idicalp2013-silent-abstract>span classabstractheading>Abstract/span>br/>		We consider the computational power of silent transitions in one-way automata		with storage.  Specifically, we ask which storage mechanisms admit a		transformation of a given automaton into one that accepts the same language		and reads at least one input symbol in each step.		br/>		We study this question using the model of valence automata.  Here, a finite		automaton is equipped with a storage mechanism that is given by a monoid.		br/>		This work presents generalizations of known results on silent transitions.		For two classes of monoids, it provides characterizations of those monoids that		allow the removal of silent transitions.  Both classes are defined by		graph products of copies of the bicyclic monoid and the group of integers.  The		first class contains pushdown storages as well as the blind counters while the		second class contains the blind and the partially blind counters.	/div>script typetext/javascript>document.getElementById(icalp2013-silent-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Valence automata as a generalization of automata with storage/span>br/>Given at a hrefhttp://www.fmi.uni-stuttgart.de/alfa13/ titleWorkshop on Automata, Logic, Formal languages, and Algebra>ALFA13/a> in Riga, Latviabr/>span classlinklist idalfa2013-linklist styledisplay:none;>[ span classjsbutton>a idalfa2013-abstract-show  hrefjavascript:toggle(alfa2013-abstract)>Show abstract/a>/span>span classjsbutton>a idalfa2013-abstract-hide hrefjavascript:toggle(alfa2013-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/ALFA2013-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(alfa2013-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/ALFA2013-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract idalfa2013-abstract>span classabstractheading>Abstract/span>br/>		 A valence automaton over a monoid M is a finite automaton in		 which each edge carries an input word and an element of M. A		 word is then accepted if there is a run that spells the word		 such that the product of the monoid elements is the identity.		 By choosing appropriate monoids M, one can obtain various		 kinds of automata with storage as special valence automata.		 Examples include pushdown automata, blind multicounter		 automata, and partially blind multicounter automata.		 Therefore, valence automata offer a framework to generalize		 results on such automata with storage. This talk will present		 recent advances in this direction. The addressed questions		 include: For which monoids can we accept non-regular		 languages? For which monoids can we determinize automata? For		 which monoids do we have a Parikhs Theorem (as for pushdown		 automata)? 	/div>script typetext/javascript>document.getElementById(alfa2013-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Valence automata as a generalization of automata with storage/span>br/>Given at a hrefhttp://www.isp.uni-luebeck.de/dcon13>D-CON 2013/a> in Lübeck, Germanybr/>span classlinklist iddcon-2013-linklist styledisplay:none;>[ span classjsbutton>a iddcon-2013-abstract-show  hrefjavascript:toggle(dcon-2013-abstract)>Show abstract/a>/span>span classjsbutton>a iddcon-2013-abstract-hide hrefjavascript:toggle(dcon-2013-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefdoc/DCON2013-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>script typetext/javascript>document.getElementById(dcon-2013-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefdoc/DCON2013-Zetzsche.pdf titleVersion >Slides/a> ]br/>/span>/noscript>div classabstract iddcon-2013-abstract>span classabstractheading>Abstract/span>br/>		A valence automaton over a monoid $M$ is a finite automaton in		which each edge carries an input word and an element of $M$. A		word is then accepted if there is a run that spells the word		such that the product of the monoid elements is the identity.		By choosing appropriate monoids $M$, one can obtain various		kinds of automata with storage as special valence automata.		Examples include pushdown automata, blind multicounter		automata, and partially blind multicounter automata. Therefore,		valence automata offer a framework to generalize results on		such automata with storage. This talk will present recent		results on valence automata. The addressed questions include:		For which monoids can we accept non-regular languages? For		which monoids can we determinize automata? For which monoids		can we avoid silent edges (i.e., those which read no input		symbol)?	/div>script typetext/javascript>document.getElementById(dcon-2013-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Valence automata as a generalization of automata with storage/span>br/>Given at Algebra and Cryptography Seminar at CUNY Graduate Center in New York City, USAbr/>span classlinklist idseminar-algebra-cryptography-2012-09-linklist styledisplay:none;>[ span classjsbutton>a idseminar-algebra-cryptography-2012-09-abstract-show  hrefjavascript:toggle(seminar-algebra-cryptography-2012-09-abstract)>Show abstract/a>/span>span classjsbutton>a idseminar-algebra-cryptography-2012-09-abstract-hide hrefjavascript:toggle(seminar-algebra-cryptography-2012-09-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(seminar-algebra-cryptography-2012-09-linklist).style.displayinline;/script>div classabstract idseminar-algebra-cryptography-2012-09-abstract>span classabstractheading>Abstract/span>br/>		A valence automaton over a monoid M is a finite automaton in which		each edge carries an input word and an element of M. A word is then		accepted if there is a run that spells the word such that the product of		the monoid elements is the identity.		br/>			By choosing appropriate monoids M, one can obtain various kinds of		automata with storage as special valence automata. Examples include		pushdown automata, blind multicounter automata, and partially blind		multicounter automata.  Therefore, valence automata offer a framework to		generalize results on such automata with storage.		br/>			This talk will present recent results on valence automata. The addressed		questions include: For which monoids can we accept non-regular		languages? For which monoids can we determinize automata?  For which		monoids can we avoid silent edges (i.e., those which read no input		symbol)?	/div>script typetext/javascript>document.getElementById(seminar-algebra-cryptography-2012-09-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Silent Transitions in Valence Automata/span>br/>Given at Seminar Algebraic and Logical Foundations of Computer Science at Universität Leipzig in Germanybr/>span classlinklist idseminar-leipzig-linklist styledisplay:none;>[ span classjsbutton>a idseminar-leipzig-abstract-show  hrefjavascript:toggle(seminar-leipzig-abstract)>Show abstract/a>/span>span classjsbutton>a idseminar-leipzig-abstract-hide hrefjavascript:toggle(seminar-leipzig-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(seminar-leipzig-linklist).style.displayinline;/script>div classabstract idseminar-leipzig-abstract>span classabstractheading>Abstract/span>br/>		We consider the problem of eliminating silent transitions		from one-way automata with storage.  It is known that in		pushdown automata and in blind multicounter automata (where		the counter values can become negative and are only		zero-tested in the end), silent transitions can be avoided.		On the other hand, in the case of partially blind		multicounter automata (where the counter values are always		non-negative and are only zero-tested in the end), silent		transitions are necessary to accept all languages.  In order		to study the expressive power of silent transitions in		greater generality, we use the model of valence automata.		Here, a finite automaton is equipped with a storage		mechanism that is given by a monoid. Since many models of		automata with storage (including all of the above) arise as		special valence automata, our question is: for which monoids		can silent transitions be avoided?  This work presents		generalizations of the results above. For two classes of		monoids, it provides characerizations of those monoids that		allow the removal of silent transitions.  Both classes are		defined by graph products of copies of the bicyclic monoid		and the group of integers.	/div>script typetext/javascript>document.getElementById(seminar-leipzig-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Monoid Control for Grammars, Automata, and Transducers/span>br/>Given at a hrefhttp://theo.cs.uni-magdeburg.de/theorietag2011/ titleTheorietag Automaten und formale Sprachen 2011>Theorietag Automaten und formale Sprachen 2011/a> in Allrode, Germanybr/>span classlinklist idtheorietag2011-monoidcontrol-linklist styledisplay:none;>[ span classjsbutton>a idtheorietag2011-monoidcontrol-abstract-show  hrefjavascript:toggle(theorietag2011-monoidcontrol-abstract)>Show abstract/a>/span>span classjsbutton>a idtheorietag2011-monoidcontrol-abstract-hide hrefjavascript:toggle(theorietag2011-monoidcontrol-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://theo.cs.uni-magdeburg.de/theorietag2011/text/tagungsband-tt2011.pdf title>Online Proceedings/a> ]br/>/span>script typetext/javascript>document.getElementById(theorietag2011-monoidcontrol-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefhttp://theo.cs.uni-magdeburg.de/theorietag2011/text/tagungsband-tt2011.pdf title>Online Proceedings/a> ]br/>/span>/noscript>div classabstract idtheorietag2011-monoidcontrol-abstract>span classabstractheading>Abstract/span>br/>		During recent decades, classical models in language theory have been extended		by control mechanisms defined by monoids.  We study which monoids cause the		extensions of context-free grammars, finite automata, or finite state		transducers to exceed the capacity of the original model.  Furthermore, we		investigate when, in the extended automata model, the nondeterministic variant		differs from the deterministic one in capacity.  We show that all these		conditions are in fact equivalent and present an algebraic characterization. In		particular, the open question of whether every language generated by a valence		grammar over a finite monoid is context-free is provided with a positive		answer.	/div>script typetext/javascript>document.getElementById(theorietag2011-monoidcontrol-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>A Sufficient Condition for Erasing Productions to Be Avoidable/span>br/>Given at a hrefhttp://dlt2011.disco.unimib.it/ title15th International Conference on Developments in Language Theory>DLT 2011/a> in Milano, Italybr/>span classlinklist iddlt2011-sufficient-linklist styledisplay:none;>[ span classjsbutton>a iddlt2011-sufficient-abstract-show  hrefjavascript:toggle(dlt2011-sufficient-abstract)>Show abstract/a>/span>span classjsbutton>a iddlt2011-sufficient-abstract-hide hrefjavascript:toggle(dlt2011-sufficient-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(dlt2011-sufficient-linklist).style.displayinline;/script>div classabstract iddlt2011-sufficient-abstract>span classabstractheading>Abstract/span>br/>		In each grammar model, it is an important question whether erasing productions		are necessary to generate all languages.  Using the concept of grammars with		control languages by Salomaa, which offers a uniform treatment of a variety of		grammar models, we present a condition on the class of control languages that		guarantees that erasing productions are avoidable in the resulting grammar		model. On the one hand, this generalizes the previous result that in Petri net		controlled grammars, erasing productions can be eliminated. On the other hand,		it allows us to infer that the same is true for vector grammars.	/div>script typetext/javascript>document.getElementById(dlt2011-sufficient-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>On the Capabilities of Grammars, Automata, and Transducers Controlled by Monoids/span>br/>Given at a hrefhttp://icalp11.inf.ethz.ch/ title38th International Colloquium on Automata, Languages and Programming>ICALP 2011/a> in Zürich, Switzerlandbr/>span classlinklist idicalp2011-capabilities-linklist styledisplay:none;>[ span classjsbutton>a idicalp2011-capabilities-abstract-show  hrefjavascript:toggle(icalp2011-capabilities-abstract)>Show abstract/a>/span>span classjsbutton>a idicalp2011-capabilities-abstract-hide hrefjavascript:toggle(icalp2011-capabilities-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(icalp2011-capabilities-linklist).style.displayinline;/script>div classabstract idicalp2011-capabilities-abstract>span classabstractheading>Abstract/span>br/>		During recent decades, classical models in language theory have been extended		by control mechanisms defined by monoids.  We study which monoids cause the		extensions of context-free grammars, finite automata, or finite state		transducers to exceed the capacity of the original model.  Furthermore, we		investigate when, in the extended automata model, the nondeterministic variant		differs from the deterministic one in capacity.  We show that all these		conditions are in fact equivalent and present an algebraic characterization. In		particular, the open question of whether every language generated by a valence		grammar over a finite monoid is context-free is provided with a positive		answer.	/div>script typetext/javascript>document.getElementById(icalp2011-capabilities-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>On Erasing Productions in Random Context Grammars/span>br/>Given at a hrefhttp://icalp10.inria.fr/ title37th International Colloquium on Automata, Languages and Programming>ICALP 2010/a> in Bordeaux, Francebr/>span classlinklist idicalp2010-erasing-linklist styledisplay:none;>[ span classjsbutton>a idicalp2010-erasing-abstract-show  hrefjavascript:toggle(icalp2010-erasing-abstract)>Show abstract/a>/span>span classjsbutton>a idicalp2010-erasing-abstract-hide hrefjavascript:toggle(icalp2010-erasing-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(icalp2010-erasing-linklist).style.displayinline;/script>div classabstract idicalp2010-erasing-abstract>span classabstractheading>Abstract/span>br/>		Three open questions in the theory of regulated		rewriting are addressed.  The first is whether every		permitting random context grammar has a non-erasing		equivalent.  The second asks whether the same is true		for matrix grammars without appearance checking.  The		third concerns whether permitting random context		grammars have the same generative capacity as matrix		grammars without appearance checking.				The main result is a positive answer to the first		question. For the other two, conjectures are		presented. It is then deduced from the main result		that at least one of the two holds.	/div>script typetext/javascript>document.getElementById(icalp2010-erasing-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Erasing in Petri Net Languages and Matrix Grammars/span>br/>Given at a hrefhttp://www-dlt2009.informatik.uni-stuttgart.de/ title13th International Conference on Developments in Language Theory>DLT 2009/a> in Stuttgart, Germanybr/>span classlinklist iddlt2009-erasing-linklist styledisplay:none;>[ span classjsbutton>a iddlt2009-erasing-abstract-show  hrefjavascript:toggle(dlt2009-erasing-abstract)>Show abstract/a>/span>span classjsbutton>a iddlt2009-erasing-abstract-hide hrefjavascript:toggle(dlt2009-erasing-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(dlt2009-erasing-linklist).style.displayinline;/script>div classabstract iddlt2009-erasing-abstract>span classabstractheading>Abstract/span>br/>		It is shown that applying linear erasing to a Petri net		language yields a language generated by a non-erasing		matrix grammar.  The proof uses Petri net controlled		grammars. These are context-free grammars, where the		application of productions has to comply with a firing		sequence in a Petri net. Petri net controlled grammars are		equivalent to arbitrary matrix grammars (without		appearance checking), but a certain restriction on them		(linear Petri net controlled grammars) leads to the class		of languages generated by non-erasing matrix grammars.				It is also shown that in Petri net controlled grammars		(with final markings and arbitrary labeling), erasing		rules can be eliminated, which yields a reformulation of		the problem of whether erasing rules in matrix grammars		can be eliminated.	/div>script typetext/javascript>document.getElementById(dlt2009-erasing-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Labeled Step Sequences in Petri Nets/span>br/>(joint work with a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/jantzen_eng.html>Matthias Jantzen/a>)br/>Given at a hrefhttp://ictt.xidian.edu.cn/atpn2008/Pages/ATPN_main.jsp titleInternational Conference on Applications and Theory of Petri nets>PETRI NETS 2008/a> in Xian, Chinabr/>span classlinklist idpetrinets2008-labeled-linklist styledisplay:none;>[ span classjsbutton>a idpetrinets2008-labeled-abstract-show  hrefjavascript:toggle(petrinets2008-labeled-abstract)>Show abstract/a>/span>span classjsbutton>a idpetrinets2008-labeled-abstract-hide hrefjavascript:toggle(petrinets2008-labeled-abstract) styledisplay:none;>Hide abstract/a>/span> ]br/>/span>script typetext/javascript>document.getElementById(petrinets2008-labeled-linklist).style.displayinline;/script>div classabstract idpetrinets2008-labeled-abstract>span classabstractheading>Abstract/span>br/>		We compare various modes of firing transitions in Petri nets		and define classes of languages defined this way.  We define		languages through steps, i. e. sets of transitions, maximal		steps, multi-steps, and maximal multi-steps of transitions		in Petri nets, but in a different manner than those defined		in Burk 81a,Burk 83, by considering labeled transitions.		We will show that we obtain a hierarchy of families of		languages defined by multiple use of transition in firing		transitions in a single multistep.  Except for the maximal		multi-steps all classes can be simulated by sequential		firing of transitions.	/div>script typetext/javascript>document.getElementById(petrinets2008-labeled-abstract).style.displaynone;/script>/div>br/>div classentry>span classtitle>Concurrent Finite Automata/span>br/>(joint work with a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/jantzen_eng.html>Matthias Jantzen/a> and a hrefhttp://www.informatik.uni-hamburg.de/TGI/mitarbeiter/profs/kudlek_eng.html>Manfred Kudlek/a>)br/>Given at a hrefhttp://www.informatik.uni-leipzig.de/theo/theorietag07.html titleTheorietag Automaten und formale Sprachen 2007>Theorietag Automaten und formale Sprachen 2007/a> in Leipzig, Germanybr/>span classlinklist idtheorietag2007-cfa-linklist styledisplay:none;>[ span classjsbutton>a idtheorietag2007-cfa-abstract-show  hrefjavascript:toggle(theorietag2007-cfa-abstract)>Show abstract/a>/span>span classjsbutton>a idtheorietag2007-cfa-abstract-hide hrefjavascript:toggle(theorietag2007-cfa-abstract) styledisplay:none;>Hide abstract/a>/span> | a hrefhttp://www.informatik.uni-leipzig.de/theo/theo07/proceedings.pdf title>Online Proceedings/a> ]br/>/span>script typetext/javascript>document.getElementById(theorietag2007-cfa-linklist).style.displayinline;/script>noscript>span classlinklist>[ a hrefhttp://www.informatik.uni-leipzig.de/theo/theo07/proceedings.pdf title>Online Proceedings/a> ]br/>/span>/noscript>div classabstract idtheorietag2007-cfa-abstract>span classabstractheading>Abstract/span>br/>		We present a generalization of finite automata using Petri nets		as control.  Acceptance is defined by final markings of the		Petri net. The class of languages obtained by $\lambda$-free		concurrent finite automata contains both the class of regular		sets and the class of Petri net languages defined by final		marking.	/div>script typetext/javascript>document.getElementById(theorietag2007-cfa-abstract).style.displaynone;/script>/div>br/>/div>br/>br/>br/>br/>br/>br/>/body>/html>

View on OTX | View on ThreatMiner

Data with thanks to AlienVault OTX, VirusTotal, Malwr and others. [Sitemap]

Domain > zetzsche.xyz

Is this malicious?

DNS Resolutions

Port 80