Generalizing input-driven languages: theoretical and practical benefits

TL;DR

This paper explores the theoretical and practical advantages of generalizing input-driven languages, focusing on operator precedence languages, which combine the algebraic and logical properties of regular languages with enhanced parsing capabilities.

Contribution

It demonstrates that operator precedence languages extend the properties of regular languages, enabling more effective parallel parsing and maintaining desirable algebraic and logical features.

Findings

Operator precedence languages enable more effective parsing parallelization.

They exhibit algebraic and logic properties similar to regular languages.

These languages offer practical benefits for automatic verification and real-time recognition.

Abstract

Regular languages (RL) are the simplest family in Chomsky's hierarchy. Thanks to their simplicity they enjoy various nice algebraic and logic properties that have been successfully exploited in many application fields. Practically all of their related problems are decidable, so that they support automatic verification algorithms. Also, they can be recognized in real-time. Context-free languages (CFL) are another major family well-suited to formalize programming, natural, and many other classes of languages; their increased generative power w.r.t. RL, however, causes the loss of several closure properties and of the decidability of important problems; furthermore they need complex parsing algorithms. Thus, various subclasses thereof have been defined with different goals, spanning from efficient, deterministic parsing to closure properties, logic characterization and automatic verification techniques. Among CFL subclasses, so-called structured ones, i.e., those where the typical tree-structure is visible in the sentences, exhibit many of the algebraic and logic properties of RL, whereas deterministic CFL have been thoroughly exploited in compiler construction and other application fields. After surveying and comparing the main properties of those various language families, we go back to operator precedence languages (OPL), an old family through which R. Floyd pioneered deterministic parsing, and we show that they offer unexpected properties in two fields so far investigated in totally independent ways: they enable parsing parallelization in a more effective way than traditional sequential parsers, and exhibit the same algebraic and logic properties so far obtained only for less expressive language families.

Equations

$${\mathcal{A}}_p=(Q^{\prime }\times Q^{\prime \prime },\Sigma ,{\delta }_p,I^{\prime }\times I^{\prime \prime },F^{\prime }\times F^{\prime \prime }),$$

$$\phi :=a(\mathbf{x})\mid \mathbf{x}\in \mathbf{X}\mid \mathrm{succ}(\mathbf{x},\mathbf{y})\mid \neg \phi \mid \phi \vee \phi \mid \exists \mathbf{x}(\phi )\mid \exists \mathbf{X}(\phi ).$$

$$L(\phi )=\{w\in {\Sigma }^{+}\mid w\models \phi \}.$$

$$\phi :=\mathbf{X}\subseteq {\mathbf{W}}_a\mid \mathbf{X}\subseteq \mathbf{Y}\mid \mathrm{Succ}(\mathbf{X},\mathbf{Y})\mid \neg \phi \mid \phi \vee \phi \mid \exists \mathbf{X}(\phi ).$$

$$\begin{array}[]{cc}\leavevmode\hbox to98.31pt{\vbox to42.77pt{\pgfpicture\makeatletter\hbox{\hskip 27.33575pt\lower-8.15312pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } \par{{}}{{}}\hbox{\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }{{}{{{}}}{{}}{}{}{}{}{}{}{}{}{}{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }{}\pgfsys@moveto{7.45313pt}{0.0pt}\pgfsys@curveto{7.45313pt}{4.11629pt}{4.11629pt}{7.45313pt}{0.0pt}{7.45313pt}\pgfsys@curveto{-4.11629pt}{7.45313pt}{-7.45313pt}{4.11629pt}{-7.45313pt}{0.0pt}\pgfsys@curveto{-7.45313pt}{-4.11629pt}{-4.11629pt}{-7.45313pt}{0.0pt}{-7.45313pt}\pgfsys@curveto{4.11629pt}{-7.45313pt}{7.45313pt}{-4.11629pt}{7.45313pt}{0.0pt}\pgfsys@closepath\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@stroke\pgfsys@invoke{ } \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{0.5}{0.0}{0.0}{0.5}{-3.95248pt}{-1.22423pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{{\huge$q_{0}$}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}}\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}}{}{{}{}{{}}{}}{{{}}{{}}}{}{{}}{}{{}}{{}} {{{{{}}{}{}{}{}{{}}}}}{}{}{}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@setdash{}{0.0pt}\pgfsys@invoke{ }{}{}{}{}{{}}\pgfsys@moveto{-20.46974pt}{0.0pt}\pgfsys@lineto{-9.55309pt}{0.0pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-9.55309pt}{0.0pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{{}{}}}{{}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-24.00275pt}{0.0pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} {{{{}}}}{{}}{{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }{{}{{{}}}{{}}{}{}{}{}{}{}{}{}{}{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@setlinewidth{1.4pt}\pgfsys@invoke{ }{}\pgfsys@moveto{60.09073pt}{0.0pt}\pgfsys@curveto{60.09073pt}{4.11629pt}{56.75389pt}{7.45313pt}{52.6376pt}{7.45313pt}\pgfsys@curveto{48.52132pt}{7.45313pt}{45.18448pt}{4.11629pt}{45.18448pt}{0.0pt}\pgfsys@curveto{45.18448pt}{-4.11629pt}{48.52132pt}{-7.45313pt}{52.6376pt}{-7.45313pt}\pgfsys@curveto{56.75389pt}{-7.45313pt}{60.09073pt}{-4.11629pt}{60.09073pt}{0.0pt}\pgfsys@closepath\pgfsys@moveto{52.6376pt}{0.0pt}\pgfsys@stroke\pgfsys@invoke{ }\pgfsys@beginscope\pgfsys@invoke{ }{\pgfsys@setlinewidth{0.6pt}\pgfsys@invoke{ }\definecolor[named]{pgfstrokecolor}{rgb}{1,1,1}\pgfsys@color@gray@stroke{1}\pgfsys@invoke{ }\pgfsys@moveto{60.09073pt}{0.0pt}\pgfsys@curveto{60.09073pt}{4.11629pt}{56.75389pt}{7.45313pt}{52.6376pt}{7.45313pt}\pgfsys@curveto{48.52132pt}{7.45313pt}{45.18448pt}{4.11629pt}{45.18448pt}{0.0pt}\pgfsys@curveto{45.18448pt}{-4.11629pt}{48.52132pt}{-7.45313pt}{52.6376pt}{-7.45313pt}\pgfsys@curveto{56.75389pt}{-7.45313pt}{60.09073pt}{-4.11629pt}{60.09073pt}{0.0pt}\pgfsys@closepath\pgfsys@moveto{52.6376pt}{0.0pt}\pgfsys@stroke\pgfsys@invoke{ }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{0.5}{0.0}{0.0}{0.5}{48.68512pt}{-1.22423pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{{\huge$q_{1}$}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \par{{}}{}{{}}{}{{}}{}\hbox{\hbox{\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}}{} {{}{}{{}}{}}{{}{}{{}}{}}{{}{}}{{}} {{}{}{{}}{}}{{{}}{{}}}{{}}{{}{}{{}}{}}{{{}}{{}}}{{}}{}{{}}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{{{{{{}}{}{}{}{}{{}}}}}{}{}{}{}}{}{}{}{}{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@setdash{}{0.0pt}\pgfsys@invoke{ }{}{}{}{}{{}}\pgfsys@moveto{-1.9549pt}{7.29576pt}\pgfsys@curveto{-5.63695pt}{21.0374pt}{5.63695pt}{21.0374pt}{2.73134pt}{10.19351pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{-0.25882}{-0.96593}{0.96593}{-0.25882}{2.73134pt}{10.19351pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-15.00002pt}{23.63496pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{$(\circ,0,\circ)$}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}}\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}}{}{{}} {{{{{}}{}{}{}{}{{}}}}}{}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{}{}{}{}{{{}{}}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@setdash{}{0.0pt}\pgfsys@invoke{ }{}{}{}{}{{}}\pgfsys@moveto{7.55313pt}{0.0pt}\pgfsys@lineto{42.93452pt}{0.0pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{42.93452pt}{0.0pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{11.24379pt}{6.033pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{$(\circ,1,\circ)$}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}}\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}}{} {{}{}{{}}{}}{{}{}{{}}{}}{{}{}}{{}} {{}{}{{}}{}}{{{}}{{}}}{{}}{{}{}{{}}{}}{{{}}{{}}}{{}}{}{{}}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{{{{{{}}{}{}{}{}{{}}}}}{}{}{}{}}{}{}{}{}{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@setdash{}{0.0pt}\pgfsys@invoke{ }{}{}{}{}{{}}\pgfsys@moveto{50.64389pt}{7.44064pt}\pgfsys@curveto{46.96184pt}{21.18228pt}{58.31337pt}{21.18228pt}{55.40776pt}{10.3384pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{-0.25882}{-0.96593}{0.96593}{-0.25882}{55.40776pt}{10.3384pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{37.63756pt}{23.77986pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{$(\circ,0,\circ)$}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}&\leavevmode\hbox to98.43pt{\vbox to43.01pt{\pgfpicture\makeatletter\hbox{\hskip 27.46136pt\lower-8.27873pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } \par{{}}{{}}\hbox{\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }{{}{{{}}}{{}}{}{}{}{}{}{}{}{}{}{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }{}\pgfsys@moveto{7.57874pt}{0.0pt}\pgfsys@curveto{7.57874pt}{4.18567pt}{4.18567pt}{7.57874pt}{0.0pt}{7.57874pt}\pgfsys@curveto{-4.18567pt}{7.57874pt}{-7.57874pt}{4.18567pt}{-7.57874pt}{0.0pt}\pgfsys@curveto{-7.57874pt}{-4.18567pt}{-4.18567pt}{-7.57874pt}{0.0pt}{-7.57874pt}\pgfsys@curveto{4.18567pt}{-7.57874pt}{7.57874pt}{-4.18567pt}{7.57874pt}{0.0pt}\pgfsys@closepath\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@stroke\pgfsys@invoke{ } \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{0.5}{0.0}{0.0}{0.5}{-3.29916pt}{-2.03078pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{{\huge$q^{\prime}_{0}$}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}}\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}}{}{{}{}{{}}{}}{{{}}{{}}}{}{{}}{}{{}}{{}} {{{{{}}{}{}{}{}{{}}}}}{}{}{}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@setdash{}{0.0pt}\pgfsys@invoke{ }{}{}{}{}{{}}\pgfsys@moveto{-20.59535pt}{0.0pt}\pgfsys@lineto{-9.6787pt}{0.0pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-9.6787pt}{0.0pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{{}{}}}{{}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-24.12836pt}{0.0pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} {{{{}}}}{{}}{{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }{{}{{{}}}{{}}{}{}{}{}{}{}{}{}{}{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@setlinewidth{1.4pt}\pgfsys@invoke{ }{}\pgfsys@moveto{60.21634pt}{0.0pt}\pgfsys@curveto{60.21634pt}{4.18567pt}{56.82327pt}{7.57874pt}{52.6376pt}{7.57874pt}\pgfsys@curveto{48.45193pt}{7.57874pt}{45.05887pt}{4.18567pt}{45.05887pt}{0.0pt}\pgfsys@curveto{45.05887pt}{-4.18567pt}{48.45193pt}{-7.57874pt}{52.6376pt}{-7.57874pt}\pgfsys@curveto{56.82327pt}{-7.57874pt}{60.21634pt}{-4.18567pt}{60.21634pt}{0.0pt}\pgfsys@closepath\pgfsys@moveto{52.6376pt}{0.0pt}\pgfsys@stroke\pgfsys@invoke{ }\pgfsys@beginscope\pgfsys@invoke{ }{\pgfsys@setlinewidth{0.6pt}\pgfsys@invoke{ }\definecolor[named]{pgfstrokecolor}{rgb}{1,1,1}\pgfsys@color@gray@stroke{1}\pgfsys@invoke{ }\pgfsys@moveto{60.21634pt}{0.0pt}\pgfsys@curveto{60.21634pt}{4.18567pt}{56.82327pt}{7.57874pt}{52.6376pt}{7.57874pt}\pgfsys@curveto{48.45193pt}{7.57874pt}{45.05887pt}{4.18567pt}{45.05887pt}{0.0pt}\pgfsys@curveto{45.05887pt}{-4.18567pt}{48.45193pt}{-7.57874pt}{52.6376pt}{-7.57874pt}\pgfsys@curveto{56.82327pt}{-7.57874pt}{60.21634pt}{-4.18567pt}{60.21634pt}{0.0pt}\pgfsys@closepath\pgfsys@moveto{52.6376pt}{0.0pt}\pgfsys@stroke\pgfsys@invoke{ }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{0.5}{0.0}{0.0}{0.5}{49.33844pt}{-2.03078pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{{\huge$q^{\prime}_{1}$}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \par{{}}{}{{}}{}{{}}{}\hbox{\hbox{\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}}{} {{}{}{{}}{}}{{}{}{{}}{}}{{}{}}{{}} {{}{}{{}}{}}{{{}}{{}}}{{}}{{}{}{{}}{}}{{{}}{{}}}{{}}{}{{}}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{{{{{{}}{}{}{}{}{{}}}}}{}{}{}{}}{}{}{}{}{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@setdash{}{0.0pt}\pgfsys@invoke{ }{}{}{}{}{{}}\pgfsys@moveto{-1.9874pt}{7.4171pt}\pgfsys@curveto{-5.66945pt}{21.15874pt}{5.66946pt}{21.15874pt}{2.76385pt}{10.31485pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{-0.25882}{-0.96593}{0.96593}{-0.25882}{2.76385pt}{10.31485pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-15.0pt}{23.7563pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{$(\circ,\circ,0)$}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}}\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}}{}{{}} {{{{{}}{}{}{}{}{{}}}}}{}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{}{}{}{}{{{}{}}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@setdash{}{0.0pt}\pgfsys@invoke{ }{}{}{}{}{{}}\pgfsys@moveto{7.67874pt}{0.0pt}\pgfsys@lineto{42.80891pt}{0.0pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{42.80891pt}{0.0pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{11.24379pt}{6.033pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{$(\circ,\circ,1)$}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}}\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}}{} {{}{}{{}}{}}{{}{}{{}}{}}{{}{}}{{}} {{}{}{{}}{}}{{{}}{{}}}{{}}{{}{}{{}}{}}{{{}}{{}}}{{}}{}{{}}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{{{{{{}}{}{}{}{}{{}}}}}{}{}{}{}}{}{}{}{}{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@setdash{}{0.0pt}\pgfsys@invoke{ }{}{}{}{}{{}}\pgfsys@moveto{50.61137pt}{7.56198pt}\pgfsys@curveto{46.92932pt}{21.30362pt}{58.34589pt}{21.30362pt}{55.44028pt}{10.45973pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{-0.25882}{-0.96593}{0.96593}{-0.25882}{55.44028pt}{10.45973pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{37.63757pt}{23.9012pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{$(\circ,\circ,0)$}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}\end{array}$$

$$\begin{array}[]{lcl}S\to 1\mid 2\mid\ldots 0\mid 1A\mid 2A\mid\ldots 0A\\ A\to+S\mid*S\end{array}$$

$$\begin{array}[]{ll}GAE_{1}:&S\to E\mid T\mid F\\ &E\to E+T\mid T*F\mid e\\ &T\to T*F\mid e\\ &F\to e\\ \end{array}$$

$$\begin{array}[]{ll}GAE_{2}:&S\to E\mid T\mid F\\ &E\to E*T\mid T+F\mid e\\ &T\to T+F\mid e\\ &F\to e\\ \end{array}$$

$$\begin{array}[]{ll}GAE_{amb}:&S\to S*S\mid S+S\mid e\\ \end{array}$$

$$\begin{array}[]{ll}G_{amb}:&S\to A_{1}\mid A_{2}\\ &A_{1}\to aaA_{1}bb\mid aabb\\ &A_{2}\to aA_{3}b\\ &A_{3}\to aA_{2}b\mid ab\\ \end{array}$$

$$\exists M,\bm{z}\left(\begin{array}[]{l}\not\exists\bm{x}(\operatorname{succ}(\bm{z},\bm{x}))\land M(0,z)\land\\ \forall\bm{x},\bm{y}(M(\bm{x},\bm{y})\Rightarrow a(\bm{x})\land b(\bm{y}))\land\\ \exists\bm{y}\forall\bm{x}\left(\begin{array}[]{l}(0\leq\bm{x}<\bm{y}\Rightarrow a(\bm{x}))\land\\ (\bm{x}\geq\bm{y}\geq\bm{z}\Rightarrow b(\bm{x}))\end{array}\right)\land\\ \left(\begin{array}[]{c}\forall\bm{x},\bm{y}\left(M(\bm{x},\bm{y})\Rightarrow\begin{array}[]{c}(\bm{x}>0\Rightarrow M(\bm{x}-1,\bm{y}+1))\land\\ (\bm{x}<\bm{y}-2\Rightarrow M(\bm{x}+1,\bm{y}-1)))\\ \end{array}\right)\\ \lor\\ \forall\bm{x},\bm{y}\left(M(\bm{x},\bm{y})\Rightarrow\begin{array}[]{c}(\bm{x}>1\Rightarrow M(\bm{x}-2,\bm{y}+2)\land\\ \neg M(\bm{x}-1,\bm{y}+1))\land\\ (\bm{x}<\bm{y}-4\Rightarrow M(\bm{x}+2,\bm{y}-2)\land\\ \neg M(\bm{x}+1,\bm{y}-1))\end{array}\right)\end{array}\right)\end{array}\right)$$

$$\begin{array}[]{ll}GAE_{[]}:&S\to[E]\mid[T]\mid[F]\\ &E\to[E+T]\mid[T*F]\mid[e]\\ &T\to[T*F]\mid[e]\\ &F\to[e]\\ \end{array}$$

$$\begin{array}[]{l}\forall\bm{x},\bm{y}\left(M(\bm{x},\bm{y})\Rightarrow\bigvee_{A\in\Gamma}\bm{x}\in\bm{C}_{A}\land\bm{y}\in\bm{R}_{A}\right)\land\\ \forall\bm{x}\bigwedge_{A\in\Gamma}\left(\begin{array}[]{c}\bm{x}\in\bm{C}_{A}\Rightarrow\neg\bigvee_{B\neq A}\bm{x}\in\bm{C}_{B}\\ \land\\ \bm{x}\in\bm{R}_{A}\Rightarrow\neg\bigvee_{B\neq A}\bm{x}\in\bm{R}_{B}\end{array}\right).\end{array}$$

$$\forall\bm{x},\bm{y}\bigwedge_{0\leq i\leq m}\bigwedge_{A\in\Gamma}\bigwedge_{a\in\Sigma}\left(\begin{array}[]{c}\bm{x}\in\bm{X}_{i}\land\operatorname{succ}(\bm{x},\bm{y})\land\\ a(\bm{y})\land\delta_{c}(i,a)=(j,A)\\ \Rightarrow\\ \bm{y}\in\bm{C}_{A}\land\bm{y}\in\bm{X}_{j}\end{array}\right)$$

$$\forall\bm{x},\bm{y},\bm{z}\bigwedge_{0\leq i\leq m}\bigwedge_{A\in\Gamma}\bigwedge_{a\in\Sigma}\left(\begin{array}[]{c}\bm{y}\in\bm{X}_{i}\land\operatorname{succ}(\bm{y},\bm{z})\land\\ M(\bm{x},\bm{z})\land\bm{z}\in\bm{R}_{A}\land a(\bm{z})\\ \Rightarrow\\ \bm{z}\in\bm{X}_{j}\land j=\delta_{r}(i,a,A)\end{array}\right).$$

$$\begin{array}[]{l}\exists\bm{z}(\not\exists\bm{x}(\operatorname{succ}(\bm{x},\bm{z}))\land\bm{z}\in\bm{X}_{0})\,\land\\ \exists\bm{y}(\not\exists\bm{x}(\operatorname{succ}(\bm{y},\bm{x}))\land\bm{y}\in\bm{X}_{3})\,\land\\ \forall\bm{x},\bm{y}\left(\bm{x}\in\bm{X}_{0}\land\operatorname{succ}(\bm{x},\bm{y})\land a(\bm{y})\Rightarrow\bm{y}\in\bm{C}_{B}\land\bm{y}\in\bm{X}_{1}\right)\land\\ \forall\bm{x},\bm{y}\left(\bm{x}\in\bm{X}_{1}\land\operatorname{succ}(\bm{x},\bm{y})\land a(\bm{y})\Rightarrow\bm{y}\in\bm{C}_{A}\land\bm{y}\in\bm{X}_{1}\right)\land\\ \forall\bm{x},\bm{y},\bm{z}\left(\bm{y}\in\bm{X}_{1}\land\operatorname{succ}(\bm{y},\bm{z})\land M(\bm{x},\bm{z})\land\bm{z}\in\bm{R}_{A}\land b(\bm{z})\Rightarrow\bm{z}\in\bm{X}_{2}\right)\land\\ \forall\bm{x},\bm{y},\bm{z}\left(\bm{y}\in\bm{X}_{2}\land\operatorname{succ}(\bm{y},\bm{z})\land M(\bm{x},\bm{z})\land\bm{z}\in\bm{R}_{A}\land b(\bm{z})\Rightarrow\bm{z}\in\bm{X}_{2}\right)\land\\ \forall\bm{x},\bm{y},\bm{z}\left(\bm{y}\in\bm{X}_{2}\land\operatorname{succ}(\bm{y},\bm{z})\land M(\bm{x},\bm{z})\land\bm{z}\in\bm{R}_{B}\land b(\bm{z})\Rightarrow\bm{z}\in\bm{X}_{3}\right)\land\\ \forall\bm{x},\bm{y},\bm{z}\left(\bm{y}\in\bm{X}_{1}\land\operatorname{succ}(\bm{y},\bm{z})\land M(\bm{x},\bm{z})\land\bm{z}\in\bm{R}_{B}\land b(\bm{z})\Rightarrow\bm{z}\in\bm{X}_{3}\right).\end{array}$$

$$S{\#}^k\stackrel{\ast }{\Rightarrow }xA\alpha {\#}^k$$

$$\begin{array}[]{ll}GAE_{LL}:&S\to E\#\\ &E\to TE^{\prime}\\ &E^{\prime}\to+E\mid\varepsilon\\ &T\to FT^{\prime}\\ &T^{\prime}\to*T\mid\varepsilon\\ &F\to e.\\ \end{array}$$

$${\mathcal{L}}_G(A)$$

$${\mathcal{R}}_G(A)$$

$$\begin{array}[]{l}S\to E\mid T\mid F\\ E\to E+T\ \mid\ E+F\ \mid\ T+T\mid F+F\ \mid\ F+T\ \mid\ T+F\\ T\to T*F\ \mid F*F\\ F\to e\end{array}$$

$$\#⋖e⋗+⋖e⋗\ast ⋖e⋗\#.$$

$$\begin{array}[]{ll}GAE_{P}:&S\to E\mid T\mid F\\ &E\to E+T\mid T*F\mid e\mid\ \llparenthesis E\rrparenthesis\\ &T\to T*F\mid e\mid\ \llparenthesis E\rrparenthesis\\ &F\to e\mid\ \llparenthesis E\rrparenthesis\\ \end{array}$$

$${\delta }_{\text{shift}}\subseteq Q\times \Sigma \times Q,{\delta }_{\text{push}}\subseteq Q\times \Sigma \times Q,{\delta }_{\text{pop}}\subseteq Q\times Q\times Q.$$

$${\delta }_{\text{shift}}:Q\times \Sigma \to Q,{\delta }_{\text{push}}:Q\times \Sigma \to Q,{\delta }_{\text{pop}}:Q\times Q\to Q.$$

$$L(\mathcal{A})=\left\{x\mid ⟨x\#,q_I,Z_0⟩\stackrel{\ast }{\mid \text{joinrel}\text{relbar}\text{joinrel}\text{relbar}}⟨\#,q_F,Z_0⟩,q_I\in I,q_F\in F\right\}.$$

$$\begin{array}[]{|r|c|r|}\hline\cr\text{input}&\text{state}&\text{stack}\\ \hline\cr e+e*\llparenthesis e+e\rrparenthesis\#&q_{0}&Z_{0}\\ \hline\cr+e*\llparenthesis e+e\rrparenthesis\#&q_{1}&[e,\ q_{0}]Z_{0}\\ \hline\cr+e*\llparenthesis e+e\rrparenthesis\#&q_{1}&Z_{0}\\ \hline\cr e*\llparenthesis e+e\rrparenthesis\#&q_{0}&[+,\ q_{1}]Z_{0}\\ \hline\cr*\llparenthesis e+e\rrparenthesis\#&q_{1}&[e,\ q_{0}][+,\ q_{1}]Z_{0}\\ \hline\cr*\llparenthesis e+e\rrparenthesis\#&q_{1}&[+,\ q_{1}]Z_{0}\\ \hline\cr\llparenthesis e+e\rrparenthesis\#&q_{0}&[*,\ q_{1}][+,\ q_{1}]Z_{0}\\ \hline\cr e+e\rrparenthesis\#&q_{2}&[\llparenthesis,\ q_{0}][*,\ q_{1}][+,\ q_{1}]Z_{0}\\ \hline\cr+e\rrparenthesis\#&q_{3}&[e,\ q_{2}][\llparenthesis,\ q_{0}][*,\ q_{1}][+,\ q_{1}]Z_{0}\\ \hline\cr+e\rrparenthesis\#&q_{3}&[\llparenthesis,\ q_{0}][*,\ q_{1}][+,\ q_{1}]Z_{0}\\ \hline\cr e\rrparenthesis\#&q_{2}&[+,\ q_{3}][\llparenthesis,\ q_{0}][*,\ q_{1}][+,\ q_{1}]Z_{0}\\ \hline\cr\rrparenthesis\#&q_{3}&[e,\ q_{2}][+,\ q_{3}][\llparenthesis,\ q_{0}][*,\ q_{1}][+,\ q_{1}]Z_{0}\\ \hline\cr\rrparenthesis\#&q_{3}&[+,\ q_{3}][\llparenthesis,\ q_{0}][*,\ q_{1}][+,\ q_{1}]Z_{0}\\ \hline\cr\rrparenthesis\#&q_{3}&[\llparenthesis,\ q_{0}][*,\ q_{1}][+,\ q_{1}]Z_{0}\\ \hline\cr\#&q_{3}&[\rrparenthesis,\ q_{0}][*,\ q_{1}][+,\ q_{1}]Z_{0}\\ \hline\cr\#&q_{3}&[*,\ q_{1}][+,\ q_{1}]Z_{0}\\ \hline\cr\#&q_{3}&[+,\ q_{1}]Z_{0}\\ \hline\cr\#&q_{3}&Z_{0}\\ \hline\cr\end{array}$$

$$\begin{array}[]{|r|r|c|r|}\hline\cr\text{step}&\text{input}&\text{state}&\text{stack}\\ \hline\cr 0&e+e*\llparenthesis e+e\rrparenthesis\#&\langle{\varepsilon},{\varepsilon}\rangle&Z_{0}\\ \hline\cr 1&+e*\llparenthesis e+e\rrparenthesis\#&\langle{e},{\varepsilon}\rangle&[e,\ \langle{\varepsilon},{\varepsilon}\rangle]Z_{0}\\ \hline\cr 2&+e*\llparenthesis e+e\rrparenthesis\#&\langle{E},{\varepsilon}\rangle&Z_{0}\\ \hline\cr 3&e*\llparenthesis e+e\rrparenthesis\#&\langle{E+},{\varepsilon}\rangle&[+,\ \langle{E},{\varepsilon}\rangle]Z_{0}\\ \hline\cr 4&*\llparenthesis e+e\rrparenthesis\#&\langle{e},{\varepsilon}\rangle&[e,\ \langle{E+},{\varepsilon}\rangle][+,\ \langle{E},{\varepsilon}\rangle]Z_{0}\\ \hline\cr 5&*\llparenthesis e+e\rrparenthesis\#&\langle{T},{E+}\rangle&[+,\ \langle{E},{\varepsilon}\rangle]Z_{0}\\ \hline\cr 6&\llparenthesis e+e\rrparenthesis\#&\langle{T*},{E+}\rangle&[*,\ \langle{T},{E+}\rangle][+,\ \langle{E},{\varepsilon}\rangle]Z_{0}\\ \hline\cr\end{array}$$

$$\langle^{a_{0}}q_{0},q_{n+1}{}^{a_{n+1}}\rangle\longrightarrow a_{1}a_{2}\dots a_{n}\$$

$$\langle^{a_{0}}q_{0},q_{n+1}{}^{a_{n+1}}\rangle\longrightarrow\Lambda_{0}a_{1}\Lambda_{1}a_{2}\dots a_{n}\Lambda_{n}\$$

$$\begin{array}[]{ccc}\begin{array}[]{c|c|c|c|}&\Sigma_{c}&\Sigma_{r}&\Sigma_{i}\\ \hline\cr\Sigma_{c}&\lessdot&\dot{=}&\lessdot\\ \hline\cr\Sigma_{r}&\gtrdot&\gtrdot&\gtrdot\\ \hline\cr\Sigma_{i}&\gtrdot&\gtrdot&\gtrdot\\ \hline\cr\end{array}&&{\small\begin{array}[]{l}\text{{Legend}}\\ \text{$\Sigma_{c}$ denotes ``calls''}\\ \text{$\Sigma_{r}$ denotes ``returns''}\\ \text{$\Sigma_{i}$ denotes internal characters}\\ \end{array}}\end{array}$$

Full text

Context-free languages (CFL) are another major family well-suited to formalize programming, natural, and many other classes of languages; their increased generative power w.r.t. RL, however, causes the loss of several closure properties and of the decidability of important problems; furthermore they need complex parsing algorithms. Thus, various subclasses thereof have been defined with different goals, spanning from efficient, deterministic parsing to closure properties, logic characterization and automatic verification techniques.

Among CFL subclasses, so-called structured ones, i.e., those where the typical tree-structure is visible in the sentences, exhibit many of the algebraic and logic properties of RL, whereas deterministic CFL have been thoroughly exploited in compiler construction and other application fields.

After surveying and comparing the main properties of those various language families, we go back to operator precedence languages (OPL), an old family through which R. Floyd pioneered deterministic parsing, and we show that they offer unexpected properties in two fields so far investigated in totally independent ways: they enable parsing parallelization in a more effective way than traditional sequential parsers, and exhibit the same algebraic and logic properties so far obtained only for less expressive language families.

Keywords: regular languages, context-free languages, input-driven languages, visibly pushdown languages, operator-precedence languages, monadic second order logic, closure properties, decidability and automatic verification.

1 Introduction

Regular (RL) and context-free languages (CFL) are by far the most widely studied families of formal languages in the richest literature of the field. In Chomsky’s hierarchy, they are, respectively, in positions 2 and 3, 0 and 1 being recursively enumerable and context-sensitive languages.

Thanks to their simplicity, RL enjoy practically all positive properties that have been defined and studied for formal language families: they are closed under most algebraic operations, and most of their properties of interest (emptiness, finiteness, containment) are decidable. Thus, they found fundamental applications in many fields of computer and system science: HW circuit design and minimization, specification and design languages (equipped with powerful supporting tools), automatic verification of SW properties, etc. One of their most relevant applications is now model-checking which exploits the decidability of the containment problem and important characterizations in terms of mathematical logics [12, 23].

On the other hand, the typical linear structure of RL sentences makes them unsuitable or only partially suitable for application in fields where the data structure is more complex, e.g., is tree-like. For instance, in the field of compilation they are well-suited to drive lexical analysis but not to manage the typical nesting of programming and natural language features. The classical language family adopted for this type of modeling and analysis is the context-free one. The increased expressive power of CFL allows to formalize many syntactic aspects of programming, natural, and various other categories of languages. Suitable algorithms have been developed on their basis to parse their sentences, i.e., to build the structure of sentences as syntax-trees.

General CFL, however, lose various of the nice mathematical properties of RL: they are closed only under some of the algebraic operations, and several decision problems, typically the inclusion problem, are undecidable; thus, the automatic analysis and synthesis techniques enabled for RL are hardly generalized to CFL. Furthermore, parsing CFL may become considerably less efficient than recognizing RL: the present most efficient parsing algorithms of practical use for general CFL have an $O(n^{3})$ time complexity.

The fundamental subclass of deterministic CFL (DCFL) has been introduced, and applied to the formalization of programming language syntax, to exploit the fact that in this case parsing is in $O(n)$. DCFL, however, do not enjoy enough algebraic and logic properties to extend to this class the successful applications developed for RL: e.g., although their equivalence is decidable, containment is not; they are closed under complement but not under union, intersection, concatenation and Kleene ∗.

From this point of view, structured CFL are somewhat in between RL and CFL. Intuitively, by structured CFL we mean languages where the structure of the syntax-tree associated with a given sentence is immediately apparent in the sentence.* Parenthesis languages (PL)* introduced in a pioneering paper by McNaughton [39] are the first historical example of such languages. McNaughton showed that they enjoy closure under Boolean operations (which, together with the decidability of the emptiness problem, implies decidability of the containment problem) and their generating grammars can be minimized in a similar way as finite state automata (FSA) are minimized (in fact an equivalent formalism for parenthesis languages are tree automata [45, 13]).

Starting from PL various extensions of this family have been proposed in the literature, with the main goal of preserving most of the nice properties of RL and PL, yet increasing their generative power; among them input-driven languages (IDL) [40, 48], later renamed visibly pushdown languages (VPL) [5] have been quite successful: they are closed under all traditional language operations (and therefore enjoy the consequent decidability properties). Also, they are characterized in terms of a monadic second order (MSO) logic by means of a natural extension of the classic characterization for RL originally and independently developed by to Büchi, Elgot, and Trakhtenbrot [9, 22, 47]. For these reasons they are a natural candidate for extending model checking techniques from RL. To achieve such a goal in practice, however, MSO logic is not yet tractable due to the complexity of its decidability problems; thus, some research is going on to “pair” IDL with specification languages inspired by temporal logic as it has been done for RL [1].

On the other hand being IDL structured their parsing problem trivially scales down to the recognition problem but clearly they are not suitable to formalize languages whose structure is hidden from the surface sentences as, e.g., typical arithmetic expressions.

Rather recently, we resumed the study of an old class of languages which was interrupted a long time ago, namely operator precedence languages (OPL). OPL and their generating grammars (OPG) have been introduced by Floyd [26] to build efficient deterministic parsers; indeed they generate a large and meaningful subclass of DCFL. In the past their algebraic properties, typically closure under Boolean operations [16], have been investigated with the main goal of designing inference algorithms for their languages [17]. After that, their theoretical investigation has been abandoned because of the advent of more powerful grammars, mainly LR ones [33, 30], that generate all DCFL (although some deterministic parsers based on OPL’s simple syntax have been continuously implemented at least for suitable subsets of programming languages [29]).

The renewed interest in OPG and OPL has been ignited by two seemingly unrelated remarks: on the one hand we realized that they are a proper superclass of IDL and that all results that have been obtained for them (closures, decidability, logical characterization) extend naturally, but not trivially, to OPL; on the other hand new motivation for their investigation comes from their distinguishing property of local parsability: with this term we mean that their deterministic parsing can be started and led to completion from any position of the input string unlike what happens with general deterministic pushdown automata, which must necessarily operate strictly left-to-right from the beginning of the input. This property has a strong practical impact since it allows for exploiting modern parallel architectures to obtain a natural speed up in the processing of large tree-structured data. An automatic tool that generates parallel parsers for these grammars has already been produced and is freely available. The same local parsability property can also be exploited to incrementally analyze large structures without being compelled to reparse them from scratch after any modification thereof.

This renewed interest in OPL has also led to extend their study to $\omega$-languages, i.e., those consisting of infinite strings: in this case too the investigation produced results that perfectly parallel the extension of other families, noticeably RL and IDL, from the finite string versions to the infinite ones.

In this paper we follow the above “story” since its beginning to these days and, for the first time, we join within the study of one single language family two different application domains, namely parallel parsing on the one side, and algebraic and logic characterization finalized to automatic verification on the other side. To the best of our knowledge, OPL is the largest family that enjoys all of such properties.

The paper is structured as follows: initially we resume some background on the two main families of formal languages. Section 2 introduces RL and various formalisms widely used in the literature to specify them; special attention is given to their logic characterization which is probably less known to the wider computer science audience and is crucial for some fundamental results of this paper. Section 3 introduces CFL in a parallel way as for regular ones. Then, two sections are devoted to different subclasses of CFL that allowed to obtain important properties otherwise lacking in the larger original family: precisely, Section 4 deals with structured CFL, i.e., those languages whose tree-shaped structure is in some way immediately apparent from their sentences with no need to parse them; it shows that for such subclasses of CFL important properties of RL, otherwise lacking in the larger original family, still hold. Section 5, instead, considers the problem of efficient deterministic parsing for CFL. Finally, Section 6 “puts everything together” by showing that OPL on the one hand are significantly more expressive than traditional structured languages, but enjoy the same important properties as regular and structured CFL and, on the other hand, enable exploiting parallelism in parsing much more naturally and efficiently than for general deterministic CFL.

Since all results presented in this paper have already appeared in the literature, we based our presentation more on intuitive explanation and simple examples than on detailed technical constructions and proofs, to which appropriate references are supplied for the interested reader. However, to guarantee self-containedness, some fundamental definitions have been necessarily given in full formality. For convenience we do not add a final ’s’ to acronyms when used as plurals so that, e.g., CFL denotes indifferently a single language, the language family and all languages in the family.

2 Regular Languages

The family of regular languages (RL) is one of the most important families in computer science. In the traditional Chomsky’s hierarchy it is the least powerful language family. Its importance stems from both its simplicity and its rich set of properties.

RL is a very robust family, as it enjoys many properties and practically all of them are decidable. It is defined through several different devices, both operational and descriptive. Among them we mention Finite State Automata (FSA), which are used for various applications, not only in computer science, Regular Grammars, Regular Expressions, often used in computing for describing the lexical elements of programming languages and in many programming environments for managing program sources, and various logic classifications that support automatic verification of their properties.

2.1 Regular Grammars and Finite State Automata

Chomsky introduced his seminal hierarchy in 1956. The interested reader may refer to a manual of formal languages, such as [30, 14] for a more complete description.

Grammars are generative rewriting systems, and consist of a set of rewriting rules, also called productions. Intuitively, a production $x\to y$ means that a string $x$ can be replaced with a string $y$ in the rewriting.

Definition 1

A grammar $G$ is a tuple $(V_{N},\Sigma,P,S)$, where

• •

$V_{N}$, called nonterminal alphabet, and $\Sigma$, called terminal alphabet, are finite sets of characters such that $V_{N}\cap\Sigma=\emptyset$; $V_{N}\cup\Sigma$ is named $V$;

• •

P is a finite set of productions or rules having the form $V^{*}V_{N}V^{*}\to V^{*}$; in a production $x\to y$, $x$ is called the left-hand side (abbreviated as lhs), and $y$ the right-hand side (abbreviated as rhs);

• •

$S\in V_{N}$ is the starting character (or axiom).

The following naming conventions are adopted for letters and strings, unless otherwise specified: lowercase Latin letters at the beginning of the alphabet $a,b,\ldots$ denote terminal characters; uppercase Latin letters $A,B,\ldots$ denote nonterminal characters; lowercase Latin letters at the end of the alphabet $x,y,z\ldots$ denote terminal strings; lowercase Greek letters $\alpha,\ldots,\omega$ denote strings over $V$.

To define the language of a grammar, we need the concept of derivation. Grammars are a generative device, because with them one always starts with the axiom (usually the $S$ character), then derives new strings by applying an iterative rewriting as specified by grammar’s productions, until a string belonging to $\Sigma^{*}$ is obtained. This intuition is formalized by the following definition.

Definition 2

Consider a grammar $G=(V_{N},\Sigma,P,S)$. A string $\beta$ is derivable in one step from a string $\alpha$, denoted by $\alpha\stackrel{{\scriptstyle{}}}{{\Rightarrow}}_{G}\beta$ iff $\alpha=\alpha_{1}\alpha_{2}\alpha_{3}$, $\beta=\alpha_{1}\alpha^{\prime}_{2}\alpha_{3}$, and $\alpha_{2}\to\alpha^{\prime}_{2}\in P$.

The reflective and transitive closure of the relation $\stackrel{{\scriptstyle{}}}{{\Rightarrow}}_{G}$ is denoted by $\stackrel{{\scriptstyle{*}}}{{\Rightarrow}}_{G}$. The language L(G) generated by G is the set $\{x\in\Sigma^{*}\mid S\stackrel{{\scriptstyle{*}}}{{\Rightarrow}}_{G}x\}$.

Regular languages are defined by restricted grammars, called regular grammars (also left-(or right-)linear grammars).

Definition 3

A grammar $G=(V_{N},\Sigma,P,S)$, such that $P\subseteq\{X\to Ya\mid X\in V_{N},Y\in V_{N}\cup\{\varepsilon\},a\in\Sigma\},$ is called left-linear. Symmetrically, if its rules have the form $X\to aY$, $G$ is called right-linear.

A grammar is called regular if it is either left-linear or right-linear. A language is regular if it is generated by some regular grammar.

Example 1

Consider a right-linear grammar $G_{1}=(V_{N},$ $\Sigma,$ $P,S)$, where $V_{N}=\{S,B\}$, $\Sigma=\{a,b\}$, $P=\{S\to aS,S\to aB,S\to a,B\to bB,B\to b\}$.

For simplicity and shortness, it is customary to group together productions with the same lhs, writing all the corresponding right parts separated by $|$. In this case, $P=\{S\to aS\mid aB\mid a,B\to bB\mid b\}$. It is also customary to drop $G$ from the relation $\stackrel{{\scriptstyle{}}}{{\Rightarrow}}_{G}$, if the grammar is clear from the context.

Here is an example derivation: $S\stackrel{{\scriptstyle{}}}{{\Rightarrow}}aS\stackrel{{\scriptstyle{}}}{{\Rightarrow}}aaS\stackrel{{\scriptstyle{}}}{{\Rightarrow}}aaaB\stackrel{{\scriptstyle{}}}{{\Rightarrow}}aaabB\stackrel{{\scriptstyle{}}}{{\Rightarrow}}aaabb.$ Hence we see that $aaabb\in L(G_{1})$. By simple reasoning we obtain $L(G_{1})=\{a^{+}b^{*}\}$.

Probably the most known and used notation to define RL is that of Finite State Automata. An automaton is a simple operational device, which assumes a state from a finite set, and its behavior is based on the concept of state transition.

Definition 4

A Finite State Automaton (FSA) $\mathcal{A}$ is a tuple $(Q,\Sigma,\delta,q_{0},F)$, where

• •

$Q$ is a finite set of states;

• •

$\Sigma$ is the input alphabet;

• •

$\delta\subseteq Q\times\Sigma\times Q$ is the transition relation;

• •

$I\subseteq Q$ is the set of initial states;

• •

$F\subseteq Q$ is the set of final states.

If $I$ is a singleton and $\delta$ is a function, i.e., $\delta:Q\times\Sigma\to Q$, $\mathcal{A}$ is called deterministic (or DFSA).

Whereas grammars generate strings through derivations, automata recognize or accept them through sequences of transitions or runs. In the case of FSA their recognition is formalized as follows.

Definition 5

Let the FSA $\mathcal{A}$ be $(Q,\Sigma,\delta,I,F)$. The transition sequence of $\mathcal{A}$ starting from a state $q\in Q$, reading a string $x\in\Sigma^{*}$, and ending in a state $q^{\prime}$ is written $(q,x,q^{\prime})\in\delta^{*}$ where the relation $\delta^{*}\subseteq Q\times\Sigma^{*}\times Q$ is inductively defined as follows:

• •

$(q,\varepsilon,q)\in\delta^{*}$;

• •

$(q,y,q^{\prime})\in\delta^{*}\land(q^{\prime},a,q^{\prime\prime})\in\delta\implies(q,ya,q^{\prime\prime})\in\delta^{*}$, for $q,q^{\prime},q^{\prime\prime}\in Q$, $a\in\Sigma,y\in\Sigma^{*}$.

The language accepted by $\mathcal{A}$ is defined as: $L(\mathcal{A})=\{x\mid\exists q_{0}\in I,\exists q_{F}\in F:(q_{0},x,q_{F})\in\delta^{*}\}.$

Example 2

Figure 1 shows a classical representation of an example automaton, where $Q$ is $\{q_{0},q_{1}\}$, $q_{0}$ is marked as initial by the leftmost arrow; $F=\{q_{1}\}$ and the ball of the final state has a double line. Transitions are depicted through labeled arrows, e.g. the arrows connecting $q_{0}$ to $q_{0}$ itself and to $q_{1}$ mean that $(q_{0},a,q_{0})\in\delta$ and $(q_{0},a,q_{1})\in\delta$.

It is easy to see that $L(\mathcal{A}_{1})=\{a^{+}b^{*}\}$. E.g., $(q_{0},a,q_{0})\in\delta$ implies $(q_{0},a,q_{0})\in\delta^{*}$ and $(q_{0},a,q_{1})\in\delta$ implies $(q_{0},a,q_{1})\in\delta^{*}$; from the same transitions we have $\{(q_{0},aa,q_{0})$, $(q_{0},aa,q_{1}),$ $(q_{0},aaa,q_{0}),$ $(q_{0},aaa,q_{1})\}\subseteq\delta^{*}$; then, $(q_{1},b,q_{1})\in$ $\delta$ and $(q_{0},aaa,$ $q_{1})$ $\in$ $\delta^{*}$ imply $(q_{0},aaab,q_{1})\in\delta^{*}$; $(q_{1},b,q_{1})\in\delta$ and $(q_{0},aaab,$ $q_{1})\in\delta^{*}$ imply $(q_{0},aaabb,q_{1})\in\delta^{*}$. Hence, $aaabb\in L(\mathcal{A}_{1})$, since $q_{1}\in F$.

By comparing the grammar of Example 1 with the automaton of Example 2 it is immediate to generalize their equivalence to the whole class RL: for any regular grammar an equivalent FSA can be built and conversely.

An important result on FSA is that they are determinizable, i.e., given a generic FSA, it is always possible to define an equivalent DFSA. The main idea is to note that the power set of a finite set is still finite, so if we have a FSA with a set of states $Q$, we can define another automaton with a set of states $\mathcal{P}(Q)$ so that the original transition relation can be made a function. More formally, given an FSA $(Q,\Sigma,\delta,I,F)$, a deterministic equivalent automaton is $\mathcal{A}_{D}=(\mathcal{P}(Q),\Sigma,\delta_{D},\{I\},F_{D})$, where $\delta_{D}\left(q,a,\bigcup_{q^{\prime}\in q,\ (q^{\prime},a,q^{\prime\prime})\in\delta}q^{\prime\prime}\right)$, $q\in\mathcal{P}(Q)$, $a\in\Sigma$, and $F_{D}=\{Q^{\prime}\subseteq Q\mid Q^{\prime}\cap F\neq\emptyset\}.$

We illustrate this construction with an example.

Example 3

The automaton $\mathcal{A}_{1}=(Q,\Sigma,\delta,\{q_{0}\},F)$ of Example 2 is not deterministic. A deterministic equivalent automaton is shown in Figure 2.

RL enjoy many interesting closure properties, for instance they are closed w.r.t. all Boolean operations (union, intersection, and complement).

As far as complement is concerned, to build up the related automaton, one must start with a deterministic automaton (if not, we have just shown how to define an equivalent deterministic automaton). First, we modify the original automaton so that it reads any possible string – in this way, if the input string is not in the automaton’s language, it changes its state to an additional “error” state, if needed, so that the function $\delta$ is total. Then, we exchange the role between accepting and non-accepting states, so that a rejected string becomes part of the language, and vice versa. We illustrate this construction with our running example.

Example 4

We start with the automaton recognizing $L=a^{+}b^{*}$ of Figure 2, since it is deterministic; we also rename its states, for brevity.

Then, we introduce an error state, called $q_{e}$, and swap accepting with non-accepting roles: the resulting automaton is shown in Figure 3. It is easy to see that $L(\mathcal{A}_{3})=\neg L(\mathcal{A}_{2})=\neg L(G_{1})$.

To prove that RL are closed w.r.t. intersection, we start from two FSA $\mathcal{A}^{\prime}=(Q^{\prime},\Sigma,$ $\delta^{\prime},I^{\prime},F^{\prime})$, $\mathcal{A}^{\prime\prime}=(Q^{\prime\prime},\Sigma,$ $\delta^{\prime\prime},I^{\prime\prime},F^{\prime\prime})$, and build a “product” automaton,

[TABLE]

where $(\langle q_{1},q_{1}^{\prime}\rangle,a,\langle q_{2},q_{2}^{\prime}\rangle)\in\delta_{p}$, iff $(q_{1},a,q_{2})\in\delta^{\prime}$, and $(q_{1}^{\prime},a,q_{2}^{\prime})$ $\in$ $\delta^{\prime\prime}$.

Closure w.r.t. union follows from De Morgan’s laws.

Example 5

Let us consider the automaton of Figure 1 and apply the construction for intersection with the automaton of Figure 4. The resulting automaton is in Figure 5.

Another fundamental property of RL is that their emptiness problem, i.e. whether or not $L=\emptyset$, is decidable. This in turn is an immediate consequence of the so-called pumping lemma which, informally, states that, due to the finiteness of the state space, the behavior of any FSA must eventually be periodic. More formally, this property is stated as follows:

Lemma 1

Let $\mathcal{A}$ be a FSA; for every string $x\in L(\mathcal{A})$, with $|x|>|Q|$, there exists a factorization $x=ywz$ such that $x=yw^{n}z\in L(G)$ for every $n\geq 0$.

As a consequence of this lemma, if in a regular language there exists a sentence of any length, then there exists also a string of length $\leq|Q|$, hence the decidability of the emptiness problem and, in turn, of the containment problem (is $L(\mathcal{A}_{1})\subseteq L(\mathcal{A}_{2})$?) and of the equivalence problem, thanks to the closure w.r.t. Boolean operations. The lemma can also be exploited to show that no FSA can recognize $L=\{a^{n}b^{n}\mid n\geq 0\}$.

Other notable closures, not of major interest in this paper, are w.r.t. concatenation, $Kleene\leavevmode\nobreak\ ^{*}$, string homomorphism, and inverse string homomorphism; FSA are minimizable, i.e. given a FSA, there is an algorithm to build an equivalent automaton with the minimum possible number of states.

2.2 Logic characterization

From the very beginning of formal language and automata theory the investigation of the relations between defining a language through some kind of abstract machine and through a logic formalism has produced challenging theoretical problems and important applications in system design and verification. A well-known example of such an application is the classical Hoare’s method to prove the correctness of a Pascal-like program w.r.t. a specification stated as a pair of pre- and post-conditions expressed through a first-order theory [32].

Such a verification problem is undecidable if the involved formalisms have the computational power of Turing machines but may become decidable for less powerful formalisms as in the important case of RL. In particular, Büchi, in his seminal work [9], provided a complete characterization of regular languages in terms of a suitable logic, so that the decidability properties of this class of languages could be exploited to achieve automatic verification; later on, in fact a major breakthrough in this field has been obtained thanks to advent of model checking. The logic proposed by Büchi to characterize regular languages is a Monadic Second Order (MSO) one that is interpreted over the natural numbers representing the position of a character in the string: the string is accepted by a FSA iff it satisfies a sentence in the corresponding logic. The basic elements of the logic defined by Büchi are summarized here:

• •

First-order variables, denoted as lowercase letters at the end of the alphabet, $\bm{x}$, $\bm{y}$, …are interpreted over the natural numbers $\mathbb{N}$ (these variables are written in boldface to avoid confusion with strings);

• •

Second-order variables, denoted as uppercase letters at the end of the alphabet, written in boldface, $\bm{X}$, $\bm{Y}$, …are interpreted over the power set of natural numbers $\mathcal{P}(\mathbb{N})$;

• •

For a given input alphabet $\Sigma$, the monadic predicate $a(\cdot)$ is defined for each $a\in\Sigma$: $a(\bm{x})$ evaluates to true in a string iff the character at position $\bm{x}$ is $a$;

• •

The successor predicate is denoted by $\operatorname{succ}$, i.e. $\operatorname{succ}(\bm{x},\bm{y})$ means that $\bm{y}=\bm{x}+1$.

• •

The well-formed formulas are defined by the following syntax:

[TABLE]

• •

They are interpreted in the natural way. Furthermore the usual predefined abbreviations are introduced to denote the remaining propositional connectives, universal quantifiers, arithmetic relations ($=,\neq,<,>$), sums and subtractions between first order variables and numeric constants. E.g. $\bm{x}=\bm{y}$ is an abbreviation for $\forall\bm{X}(\bm{x}\in\bm{X}\iff\bm{y}\in\bm{X})$; $\bm{x}=\bm{z}-2$ stands for $\exists\bm{y}(\operatorname{succ}(\bm{z},\bm{y})\land\operatorname{succ}(\bm{y},\bm{x}))$

• •

A sentence is a closed formula of the MSO logic; also, the notation $w\models\varphi$ denotes that string $w$ satisfies sentence $\varphi$. For a given sentence $\varphi$, the language $L(\varphi)$ is defined as 111When specifying languages by means of logic formulas, the empty string must be excluded because formulas refer to string positions.

[TABLE]

For instance formula $\forall\bm{x},\bm{y}(a(\bm{x})\land\operatorname{succ}(\bm{x},\bm{y})\Rightarrow b(\bm{y}))$ defines the language of strings where every occurrence of character $a$ is immediately followed by an occurrence of $b$.

Büchi’s seminal result is synthesized by the following theorem.

Theorem 2.1

A language $L$ is regular iff there exists a sentence $\varphi$ in the above MSO logic such that $L=L(\varphi)$.

The proof of the theorem is constructive, i.e., it provides an algorithmic procedure that, for a given FSA builds an equivalent sentence in the logic, and conversely; next we offer an intuitive explanation of the construction, referring the reader to, e.g., [46] for a complete and detailed proof.

From FSA to MSO logic

The key idea of the construction consists in representing each state $q$ of the automaton as a second order variable $\bm{X}_{q}$, which is the set of all string’s positions where the machine is in state $q$. Without lack of generality we assume the automaton to be deterministic, and that $Q=\{0,1,\ldots,m\}$, with 0 initial, for some $m$. Then we encode the definition of the FSA recognizing $L$ as the conjunction of several clauses each one representing a part of the FSA definition:

• •

The transition $\delta(q_{i},a)=q_{j}$ is formalized by $\forall\bm{x},\bm{y}(\bm{x}\in\bm{X}_{i}\land a(\bm{x})\land\operatorname{succ}(\bm{x},\bm{y})\Rightarrow\bm{y}\in\bm{X}_{j})$.

• •

The fact that the machine starts in state [math] is represented as $\exists\bm{z}(\not\exists\bm{x}(\operatorname{succ}(\bm{x},\bm{z}))\land\bm{z}\in\bm{X}_{0})$.

• •

Being the automaton deterministic, for each pair of distinct second order variables $\bm{X}_{i}$ and $\bm{X}_{j}$ we need the subformula $\not\exists\bm{y}(\bm{y}\in\bm{X}_{i}\land\bm{y}\in\bm{X}_{j})$.

• •

Acceptance by the automanton, i.e. $\delta(q_{i},a)\in F$, is formalized by: $\exists\bm{y}(\not\exists\bm{x}(\operatorname{succ}(\bm{y},\bm{x}))\land\bm{y}\in\bm{X}_{i}\land a(\bm{y}))$.

• •

Finally the whole language $L$ is the set of strings that satisfy the global sentence $\exists\bm{X}_{0},X_{1},\ldots\bm{X}_{m}(\varphi)$, where $\varphi$ is the conjunction of all the above clauses.

At this point it is not difficult to show that the set of strings satisfying the above global formula is exactly $L$.

From MSO logic to FSA

The construction in the opposite sense has been proposed in various versions in the literature. Here we summarize its main steps along the lines of [46]. First, the MSO sentence is translated into a standard form using only second-order variables, the $\subseteq$ predicate, and variables $\bm{W}_{a}$, for each $a\in\Sigma$, denoting the set of all the positions of the word containing the character $a$. Moreover, we use $\operatorname{Succ}$, which has the same meaning of $\operatorname{succ}$, but, syntactically, has second order variable arguments that are singletons. This simpler, equivalent logic, is defined by the following syntax:

[TABLE]

As before, we also use the standard abbreviations, e.g. $\land$, $\forall$, $=$. To translate first order variables to second order variables we need to state that a (second order) variable is a singleton. Hence we introduce the abbreviation: $\operatorname{Sing}(\bm{X})$ for $\exists\bm{Y}(\bm{Y}\subseteq\bm{X}\land\bm{Y}\neq\bm{X}\land\not\exists\bm{Z}(\bm{Z}\subseteq\bm{X}\land\bm{Z}\neq\bm{Y}\land\bm{Z}\neq\bm{X}))$. Then, $\operatorname{Succ}(\bm{X},\bm{Y})$ is defined only for $\bm{X}$ and $\bm{Y}$ singletons.

The following step entails the inductive construction of the equivalent automaton. This is built by associating a single automaton to each elementary subformula and by composing them according to the structure of the global formula. This inductive approach requires to use open formulas. Hence, we are going to consider words on the alphabet $\Sigma\times\{0,1\}^{k}$, so that $\bm{X}_{1}$, $\bm{X}_{2}$, …$\bm{X}_{k}$ are the free variables used in the formula; 1 in the, say, $j$-th component means that the considered position belongs to $\bm{X}_{j}$, 0 vice versa. For instance, if $w=(a,0,1)(a,0,0)(b,1,0)$, then $w\models\bm{X}_{2}\subseteq\bm{W}_{a}$, $w\models\bm{X}_{1}\subseteq\bm{W}_{b}$, with $\bm{X}_{1}$ and $\bm{X}_{2}$ singletons.

Formula transformation

First order variables are translated in the following way: $\exists\bm{x}(\varphi(\bm{x}))$ becomes

$\exists\bm{X}(\operatorname{Sing}(\bm{X})\land\varphi^{\prime}(\bm{X}))$, where $\varphi^{\prime}$ is the translation of $\varphi$, and $\bm{X}$ is a fresh variable. 2. 2.

Subformulas having the form $a(\bm{x})$, $\operatorname{succ}(\bm{x},\bm{y})$ are translated into $\bm{X}\subseteq\bm{W}_{a}$, $\operatorname{Succ}(\bm{X},\bm{Y})$, respectively. 3. 3.

The other parts remain the same.

Inductive construction of the automaton

We assume for simplicity that $\Sigma=\{a,b\}$, and that $k=2$, i.e. two variables are used in the formula. Moreover we use the shortcut symbol $\circ$ to mean all possible values.

• •

The formula $\bm{X}_{1}\subseteq\bm{X}_{2}$ is translated into an automaton that checks that there are 1’s for the $\bm{X}_{1}$ component only in positions where there are also 1’s for the $\bm{X}_{2}$ component (Figure 6 (a)).

• •

The formula $\bm{X}_{1}\subseteq\bm{W}_{a}$ is analogous: the automaton checks that positions marked by 1 in the $\bm{X}_{1}$ component must have symbol $a$ (Figure 6 (b)).

• •

The formula $\operatorname{Succ}(\bm{X}_{1},\bm{X}_{2})$ considers two singletons, and checks that the 1 for component $\bm{X}_{1}$ is immediately followed by a 1 for component $\bm{X}_{2}$ (Figure 6 (c)).

• •

Formulas inductively built with $\neg$ and $\lor$ are covered by the closure of regular languages w.r.t. complement and union, respectively.

• •

For $\exists$, we use the closure under alphabet projection: we start with an automaton with input alphabet, say, $\Sigma\times\{0,1\}^{2}$, for the formula $\varphi(\bm{X}_{1},\bm{X}_{2})$; we need to define an automaton for the formula $\exists\bm{X}_{1}(\varphi(\bm{X}_{1},\bm{X}_{2}))$. But in this case the alphabet is $\Sigma\times\{0,1\}$, where the last component represents the only free remaining variable, i.e. $\bm{X}_{2}$.

The automaton $\mathcal{A}_{\exists}$ is built by starting from the one for $\varphi(\bm{X}_{1},\bm{X}_{2})$, and changing the transition labels from $(a,0,0)$ and $(a,1,0)$ to $(a,0)$; $(a,0,1)$ and $(a,1,1)$ to $(a,1)$, and those with $b$ analogously. The main idea is that this last automaton nondeterministically “guesses” the quantified component (i.e. $\bm{X}_{1}$) when reading its input, and the resulting word $w\in(\Sigma\times\{0,1\}^{2})^{*}$ is such that $w\models\varphi(\bm{X}_{1},\bm{X}_{2})$. Thus, $\mathcal{A}_{\exists}$ recognizes $\exists\bm{X}_{1}(\varphi(\bm{X}_{1},\bm{X}_{2}))$.

We refer the reader to the available literature for a full proof of equivalence between the logic formula and the constructed automaton. Here we illustrate the rationale of the above construction through the following example.

Example 6

Consider the language $L=\{a,b\}^{*}aa\{a,b\}^{*}$: it consists of the strings satisfying the formula:

$\varphi_{L}=\exists\bm{x}\exists\bm{y}(\operatorname{succ}(\bm{x},\bm{y})\land a(\bm{x})\land a(\bm{y}))$.

As seen before, first we translate this formula into a version using only second order variables: $\varphi^{\prime}_{L}=\exists\bm{X},\bm{Y}(\operatorname{Sing}(\bm{X})\land\operatorname{Sing}(\bm{Y})\land\operatorname{Succ}(\bm{X},\bm{Y})\land\bm{X}\subseteq\bm{W}_{a}\land\bm{Y}\subseteq\bm{W}_{a})$.

Here are the automata for $\operatorname{Sing}(\bm{X})$ and $\operatorname{Sing}(\bm{Y})$:

[TABLE]

The above automata could also be obtained by expanding the definition of $\operatorname{Sing}$ and then projecting the quantified variables. By intersecting the automata for $\operatorname{Sing}(\bm{X})$, $\operatorname{Sing}(\bm{Y})$, $\operatorname{Succ}(\bm{X},\bm{Y})$ we obtain an automaton which is identical to the one we defined for translating formula $\operatorname{Succ}(\bm{X}_{1},\bm{X}_{2})$, where here $\bm{X}$ takes the role of $\bm{X}_{1}$ and $\bm{Y}$ of $\bm{X}_{2}$. Combining it with those for $\bm{X}\subseteq W_{a}$ and $\bm{Y}\subseteq W_{a}$ produces:

q^{\prime\prime}_{0}$$q^{\prime\prime}_{1}$$q^{\prime\prime}_{2}$$(a,0,0)$$(b,0,0)$$(a,1,0)$$(a,0,1)$$(a,0,0)$$(b,0,0)

Finally, by projecting on the quantified variables $\bm{X}$ and $\bm{Y}$ we obtain the automaton for $L$.

q^{\prime\prime}_{0}$$q^{\prime\prime}_{1}$$q^{\prime\prime}_{2}$$a,b$$a$$a$$a,b

The logical characterization of a class of languages, together with the decidability of the containment problem, is the main door towards automatic verification techniques: suppose in fact to have a logic formalism $\mathfrak{L}$ recursively equivalent to an automaton family $\mathfrak{A}$; then, one can use a language $L_{\mathfrak{L}}$ in $\mathfrak{L}$ to specify the requirements of a given system and an abstract machine $\mathcal{A}$ in $\mathfrak{A}$ to implement the desired system: the correctness of the design defined by $\mathcal{A}$ w.r.t. to the requirements stated by $L_{\mathfrak{L}}$ is therefore formalized by $L(\mathcal{A})\subseteq L_{\mathfrak{L}}$, i.e., all behaviors realized by the machine are also satisfying the requirements. This is just the case with FSA and MSO logic for RL; in practice, however, the decision algorithms based on the above MSO logic have been proved of intractable complexity; thus, the great success of model-checking as the fundamental technique for automatic verification has been obtained by resorting to less powerful, typically temporal, logics which compensated the limited loss of generality by a complexity considered, and empirically verified in many practical experiments, as more tractable, despite a theoretical PSPACE-completeness [23].

3 Context-free Languages

Context-free languages (CFL), with their generating context-free grammars (CFG) and recognizing pushdown automata (PDA), are, together with RL, the most important chapter in the literature of formal languages. CFG have been introduced by Noam Chomsky in the 1950s as a formalism to capture the syntax of natural languages. Independently, essentially the same formalism has been developed to formalize the syntax of the first high level programming language, FORTRAN; in fact it is also referred to as Backus-Naur form (BNF) honoring the chief scientists of the team that developed FORTRAN and its first compiler. It is certainly no surprise that the same formalism has been exploited to describe the syntactic aspects of both natural and high level programming languages, since the latter ones have exactly the purpose to make algorithm specification not only machine executable but also similar to human description.

The distinguishing feature of both natural and programming languages is that complex sentences can be built by combining simpler ones in an a priori unlimited hierarchy: for instance a conditional sentence is the composition of a clause specifying a condition with one or two sub-sentences specifying what to do if the condition holds, and possibly what else to do if it does not hold. Such a typical nesting of sentences suggests a natural representation of their $structure$ in the form of a tree shape. The possibility of giving a sentence a tree structure which hints at its semantics is a sharp departure from the rigid linear structure of regular languages. As an example, consider a simple arithmetic expression consisting of a sequence of operands with either a $+$ or a $*$ within any pair of them, as in $2+3*2+1*4$. Sentences of this type can be easily generated by, e.g., the following regular grammar:

[TABLE]

However, if we compute the value of the above expression by following the linear structure given to it by the grammar either by associating the sum and the multiply operations to the left or to the right we would obtain, respectively, $44$ or $20$ which is not the way we learned to compute the value of the expression at school. On the contrary, we first compute the multiply operations and then the sum of the three partial results, thus obtaining $12$; this, again, suggests to associate the semantics of the sentence –in this case the value of the expression– with a syntactic structure that is more appropriately represented by a tree, as suggested in Figure 7, than by a flat sequence of symbols.

CFG are more powerful than regular ones in that not only they assign in a natural way a tree structure to their sentences but also the class of languages they generate strictly includes RL (see Section  3.2). CFG are defined as a special case of Chomsky’s general ones in the following way.

Definition 6

A grammar $G=(V_{N},\Sigma,P,S)$ is context-free iff the lhs of all its productions is a single nonterminal.

Among all derivations associated with CFG it is often useful to distinguish the leftmost and rightmost ones:

Definition 7

A CFG derivation $S\stackrel{{\scriptstyle{*}}}{{\Rightarrow}}_{G}x$ is a leftmost, denoted as $S\stackrel{{\scriptstyle{l}}}{{\Rightarrow}}_{G}x$ (resp. rightmost, denoted as $S\stackrel{{\scriptstyle{r}}}{{\Rightarrow}}_{G}x$) one iff all of its immediate derivation steps are of the form $xA\beta\stackrel{{\scriptstyle{}}}{{\Rightarrow}}_{G}x\alpha\beta$ (resp. $\beta Ax\stackrel{{\scriptstyle{}}}{{\Rightarrow}}_{G}\beta\alpha x$), with $x\in\Sigma^{*},A\in V_{N},\beta,\alpha\in V^{*}$.

In other words in a leftmost derivation, at every step the leftmost nonterminal character is the lhs of the applied rule. It is immediate to verify that for every derivation of a CFG there are an equivalent leftmost and an equivalent rightmost one, i.e., derivations that produce the same terminal string.222This property does not hold for more general classes of grammars.

Example 7

The following CF grammar $GAE_{1}$ generates the same numerical arithmetic expressions as above but assigns them the appropriate structure exemplified in Figure 7. In fact there is an obvious correspondence between grammar derivations and the trees whose root is the axiom and for every internal node, labeled by a nonterminal, its children are, in order, the rhs of a production whose lhs is the label of the father. In particular, a leftmost (resp. rightmost) derivation corresponds to a left (resp. right), top-down traversal of the tree; symmetrically a left bottom-up tree traversal produces the mirror image of a rightmost derivation. The tree that represents the derivation of a sentence $x$ by a CFG is named syntax-tree or syntactic tree of $x$. Notice that in the following, for the sake of simplicity, in arithmetic expressions we will make use of a unique terminal symbol $e$ to denote any numerical value.

[TABLE]

It is an easy exercise augmenting the above grammar to let it generate more general arithmetic expressions including more arithmetic operators, parenthesized sub-expressions, symbolic operands besides numerical ones, etc.

Consider now the following slight modification $GAE_{2}$ of $GAE_{1}$:

[TABLE]

$GAE_{1}$ and $GAE_{2}$ are equivalent in that they generate the same language; however, $GAE_{2}$ assigns to the string $2+3*2+1*4$ the tree represented in Figure 8: if we executed the operations of the string in the order suggested by the tree –first the lower ones so that their result is used as an operand for the higher ones– then we would obtain the value $60$ which is not the “right one” $12$.

Last, the grammar:

[TABLE]

is equivalent to $GAE_{2}$ and $GAE_{1}$ as well, but it can generate the same string by means of different left derivations which correspond to the traversal of the syntax-trees of Figure 7, of Figure 8, and even more. In such a case we say that the grammar is ambiguous in that it associates different syntax-trees to the same sentence.

The above examples, inspired by the intuition of arithmetic expressions, further emphasize the strong connection between the structure given to a sentence by the syntax-tree and the semantics of the sentence: as it is the case with natural languages too, an ambiguous sentence may exhibit different meanings.

The examples also show that, whereas a sentence of a regular language has a fixed –either right or left-linear structure, CFL sentences have a tree structure which in general, is not immediately “visible” by looking at the sentence, which is the frontier of its associated tree. As a consequence, in the case of CFL analyzing a sentence is often not only a matter of deciding whether it belongs to a given language, but in many cases it is also necessary to build the syntax-tree(s) associated with it: its structure often drives the evaluation of its semantics as intuitively shown in the examples of arithmetic expressions and systematically applied in all major applications of CFL, including designing their compilers. The activity of jointly accepting or rejecting a sentence and, in case of acceptance, building its associated syntax-tree(s) is usually called parsing.

3.1 Pushdown automata as parsers

It is well known that a typical data structure to build and visit trees is the stack or pushdown store. Thus, it is no surprise that the abstract machines adopted in formal language theory to analyze CFL are pushdown automata, i.e., devices supplied with a finite state control augmented with a LIFO auxiliary memory. Among the many versions of such automata proposed in the literature to parse CFL or subfamilies thereof we report here a classical one.

Definition 8

A pushdown automaton (PDA) $\mathcal{A}$ is a tuple $(\Sigma,Q,$ $\Gamma,\delta,$ $q_{0},Z_{0},F)$ where

• •

$\Sigma$ is the finite terminal alphabet;

• •

$Q$ is the finite set of states;

• •

$\Gamma$ is the finite stack alphabet;

• •

$\delta\subseteq_{F}Q\times\Gamma\times(\Sigma\cup\{\varepsilon\})\times Q\times\Gamma^{*}$ is the transition relation, where the notation $A\subseteq_{F}B$ means that $A$ is a finite subset of $B$;

• •

$I\subseteq Q$ is the set of initial states;

• •

$Z_{0}\in\Gamma$ is the initial stack symbol;

• •

$F\subseteq Q$ is the set of final or accepting states.

A PDA $\mathcal{A}$ is deterministic (DPDA) iff

• •

$I$ is a singleton;

• •

$\delta$ is a function $\delta:Q\times\Gamma\times(\Sigma\cup\{\varepsilon\})\to Q\times\Gamma^{*}$;

• •

$\forall(q,A)$ if $\delta(q,A,a)$ is defined for some $a$, then $\delta(q,A,\varepsilon)$ is not defined; in other words, for any pair $(q,A)$ the automaton may perform either an $\varepsilon$-move or a reading move but not both of them.

A configuration of a PDA is a triple $(x,q,\gamma)$ where $x$ is the string to be analyzed, $q$ is the current state of the automaton, and $\gamma$ is the content of the stack.

The transition relation between two configurations $c_{1}\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}c_{2}$ holds iff $c_{1}=(x_{1},q_{1},\gamma_{1})$, $c_{2}=(x_{2},q_{2},\gamma_{2})$ and, either:

• •

$x_{1}=ay,x_{2}=y,\gamma_{1}=A\beta,\gamma_{2}=\alpha\beta$, and $(q_{1},A,a,q_{2},\alpha)\in\delta$, or

• •

$x_{1}=x_{2},\gamma_{1}=A\beta,\gamma_{2}=\alpha\beta$, and $(q_{1},A,\varepsilon,q_{2},\alpha)\in\delta$.

A string $x$ is accepted by a PDA $\mathcal{A}$ iff $c_{0}=(x,q_{0},Z_{0})\stackrel{{\scriptstyle{*}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(\varepsilon,q_{F},\gamma)$ for some $q_{0}\in I$, $q_{F}\in F$, and $\gamma\in\Gamma^{*}$. The language accepted or recognized by $\mathcal{A}$ is the set $L(\mathcal{A})$ of all strings accepted by $\mathcal{A}$.

A transition of the second type above, i.e. where no input character is consumed because the applied transition relation is of type $(q_{1},A,\varepsilon,q_{2},\alpha)$ is called an $\varepsilon$-move.

PDA as defined above are recursively equivalent to CFG, i.e, for any given CFG $G$ a PDA $\mathcal{A}$ can effectively be built such that $L(\mathcal{A})$ = $L(G)$ and conversely. DPDA define deterministic CFL (DCFL). Example 8 illustrates informally the rationale of this correspondence by presenting a PDA equivalent to grammar $GAE_{1}$. It also provides a hint on how a PDA recognizing a CFL can be augmented as a pushdown transducer which also builds the syntax-tree of the input sentence (if accepted).

Example 8

Consider the following PDA $\mathcal{A}$:

$Q=\{q_{0},q_{1},q_{F}\}$, $\Gamma=\{E,T,F,+,*,e,Z_{0}\}$,

$\delta=\{(q_{0},Z_{0},\varepsilon,q_{1},EZ_{0}),(q_{0},Z_{0},\varepsilon,q_{1},TZ_{0}),(q_{0},Z_{0},\varepsilon,q_{1},FZ_{0})\}\cup$

$\{(q_{1},E,\varepsilon,q_{1},E+T),(q_{1},E,\varepsilon,q_{1},T*F),(q_{1},E,\varepsilon,q_{1},e)\}\cup$

$\{(q_{1},T,\varepsilon,q_{1},T*F),(q_{1},T,\varepsilon,q_{1},e)\}\cup\{(q_{1},F,\varepsilon,q_{1},e)\}\cup$

$\{(q_{1},+,+,q_{1},\varepsilon),(q_{1},*,*,q_{1},\varepsilon),(q_{1},e,e,q_{1},\varepsilon)\}\cup$

$\{(q_{1},Z_{0},\varepsilon,q_{F},\varepsilon)\}$.

$\mathcal{A}$ accepts, e.g., the input string $e+e*e$ through the following sequence of configuration transitions

$(e+e*e,q_{0},Z_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(e+e*e,q_{1},EZ_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(e+e*e,q_{1},E+TZ_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(e+e*e,q_{1},e+TZ_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(+e*e,q_{1},+TZ_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(e*e,q_{1},TZ_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(e*e,q_{1},T*FZ_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(e*e,q_{1},e*FZ_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(*e,q_{1},*FZ_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(e,q_{1},FZ_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(e,q_{1},eZ_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(\varepsilon,q_{1},Z_{0})\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}(\varepsilon,q_{F},\varepsilon)$

In fact $\mathcal{A}$ has been naturally derived from the original grammar, $GAE_{1}$ in this case, in such a way that its transitions perfectly parallel a grammar’s leftmost derivation: at any step if the top of the stack stores a nonterminal it is nondeterministically replaced by the corresponding rhs of a production of which it is the lhs, in such a way that the leftmost character of the rhs is put on top of the stack; if it is a terminal it is compared with the current input symbol and, if they match the stack is popped and the reading head advances. Notice however, that, being $\mathcal{A}$ nondeterministic, there are also several sequences of transitions beginning with the same $c_{0}$ that do not accept the input.

Strictly speaking the above automaton is not a real $parser$ for the corresponding grammar since it simply accepts all and only the strings generated thereby. However, it is quite easy to make it a complete parser by adding a few translation components: precisely, a $pushdown$ $transducer$ is a pushdown automaton provided with an output alphabet $O$ which augments the range of $\delta$ in such a way that at every transition the transducer appends to the output, initially empty, a string in $O^{*}$; the output string (strings in case of nondeterminism) produced at the end of the computation applied to the input $x$ is the translation $\tau(x)$ produced by the transducer.

For instance, it is not difficult to build a full parser for grammar $GAE_{1}$ by adding to the automaton of Example 8 an output alphabet consisting of labels that uniquely identify G’s productions: for every transition of the automaton that has been built in one-to-one correspondence with G’s production set it suffices to augment $\delta$ by adding as output component of each triple the label of the corresponding production. Assume that productions $E\to E+T\mid T*F$ are labeled $1,2$, respectively; then $\delta$ is enriched accordingly with $\{(q_{0},$ $E,$ $\varepsilon,q_{0},T+E,1),(q_{0},E,\varepsilon,q_{0},F*T,2),...\}\subseteq\delta$. Conversely, transitions that simply verify that the element on top of the stack coincides with the current input character do not output anything. Clearly, the transducer built in this way from the original grammar for any string of the language delivers an output that corresponds to a top-down, leftmost visit of the syntax-tree(s) of the input string where any internal node is the label of the production used by the grammar to expand it. Thus, we can assume (nondeterministic) transducers as general parsers for CFG; if the original grammar is ambiguous the corresponding transducer produces several translations for the same input.

3.2 A comparative analysis of CFL and RL properties

CFG and PDA are more powerful formalisms than the corresponding regular ones. Such a greater power allows for their application in larger fields such as formalizing the syntax and semantics of programming languages and many other tree-structured data. The greater power of the CFL family than the RL one abides not only in the structure of their sentences but even in sets of sentences that constitute their languages. For instance, the language $L_{1}=\{a^{n}b^{n}\mid n\geq 0\}$ is easily recognized by a PDA but no FSA can accept it due its finite memory formalized by the state space $Q$, whereas, intuitively, an unbounded memory is necessary to count the number of $a$’s to be able to compare their number with that of the following $b$’s; this claim can be easily proved formally by exploiting the fundamental pumping Lemma 1.

Not surprisingly, however, such an increased power of CFL w.r.t. RL comes at a price in terms of loss of various properties and of increased complexity of related analysis algorithms. Herewith we briefly examine which properties of RL still hold for CFL and which ones are lost.

The original pumping lemma for regular languages can be naturally extended to a more general version holding for CFL:

Lemma 2

Let $G$ be a CFG; there is a constant $k$, recursively computable as a function of $G$, such that, for every string $x\in L(G)$, with $|x|>k$, there exists a factorization $x=yw_{1}zw_{2}u$ such that $x=yw_{1}^{n}zw_{2}^{n}u\in L(G)$ for every $n\geq 0$.

A first important and natural consequence of the CF version of the pumping lemma is that the emptiness problem for CFL is still decidable; this can be easily shown in a parallel way as for regular languages. Another application of the lemma analogous to that used for RL can show that various languages, such as, e.g., $L_{2}=\{a^{n}b^{n}c^{n}\mid n\geq 0\}$ are not CF.

On the opposite side the fundamental effective equivalence between deterministic and nondeterministic FSA does not hold for PDA. A formal proof of this statement can be found in most texts on formal language theory, e.g. in [30]; here we only offer an intuitive explanation based on a simple counterexample. Consider the language $L=\{ww^{R}\mid w\in\{a,b\}^{*}\}$, where $w^{R}$ denotes the mirror image of $w$. It is quite easy to build a nondeterministic PDA that accepts $L$: initially it pushes the read symbols onto the stack up to a point when it nondeterministaclly changes state and, from that point on it compares the symbol on top of the stack with the read one: if it reaches the end of the input and empties the stack at the same time, through a series of successful comparisons, then that particular computation accepts the input string; of course there will also be many other computations that fail due to a wrong guess about the middle of the input string. It is also $intuitively$ apparent that there is no way to decide deterministically where is the middle of the input sentence unless a device other than a PDA is adopted, e.g., a Turing machine.

This substantial difference in recognition power between general PDA and DPDAs has several consequences on the properties of the class of languages they accept, resp. CFL and DCFL. Here we list the most important ones:

• •

CFL are closed w.r.t. union but not w.r.t. complement and intersection. In fact closure w.r.t. union is easily shown by building, for two languages $L_{1}$, $L_{2}$ two corresponding grammars $G_{1}$ and $G_{2}$ with disjoint nonterminal alphabets; then simply adding a new axiom $S$ and two productions $S\to S_{1}\mid S_{2}$, we obtain a grammar that generates all and only the strings in $L_{1}\cup L_{2}$.

On the other hand consider again the above language $L_{2}$, which is not a CFL: it is the intersection of $L_{3}=\{a^{n}b^{n}c^{*}\mid n\geq 0\}$ with $L_{4}=\{a^{*}b^{n}c^{n}\mid n\geq 0\}$ which are clearly both DCFL. By De Morgan’s laws, CFL are not closed w.r.t. complement as well.

• •

DCFL are closed under complement but neither under union nor under intersection. Closure under complement can be obtained by exploiting determinism and switching $F$ and $Q\setminus F$ in a similar way as done for FSA, provided that a suitable normal form of the original DPDA is built before applying the switch of the accepting states. We refer the reader to the more specialized literature, e.g., [30], for the technicalities of the necessary normal form. The previous counterexample also shows the non-closure of DCFL w.r.t. intersection and therefore w.r.t. union, again thanks to De Morgan’s laws.

• •

CFL are closed under concatenation, Kleene ∗, reversal or mirror image, homomorphism, whereas DCFL are not closed under anyone of these operations. We justify only the claim about homomorphism since the other operations are of minor interest for the purpose of this paper. Given an alphabet homomorphism $h:\Sigma_{1}\to\Sigma_{2}^{*}$ with its natural extension $h:\Sigma_{1}^{*}\to\Sigma_{2}^{*}$, it is immediate, for a grammar $G$, to build a $G^{\prime}$ such that $L(G^{\prime})=h(L(G))$: it suffices to replace every occurrence of an element $a\in\Sigma_{1}$ in $G$’s definition by $h(a)$, including the particular case $h(a)=\varepsilon$. On the other side consider the language $L=\{wcw^{R}\mid w\in\{a,b\}^{*}\}$: it is immediate to build a DPDA recognizing it thanks to the new $c$ character which marks the center of the input string, but it has already been shown that $h(L)$, with $h$ defined as $h(a)=a,h(b)=b,h(c)=\varepsilon$, cannot be recognized by any DPDA.

• •

The lack of the above closure properties for both CFL and DCFL, prevents their natural exploitation to obtain decidability of the inclusion property; in fact this problem has been proved to be undecidable in both cases [30].333As side remark, the equivalence problem is undecidable for general CFL and has been proved to be decidable for DCFL after remaining open for a fairly long time [44].

3.3 Logic characterization

The lack of the above closure properties also hampers a natural extension of the logic characterization of regular languages to CFL: in particular the classic inductive construction outlined in Section 2.2 strongly hinges on the correspondence between logical connectives and Boolean operations on sub-languages. Furthermore, the linear structure of RL allows any move of a FSA to depend only on the current state which is associated with a position $\bm{x}$ of the input string and on the input symbol located at position $\bm{x}+1$; on the contrary the typical nested structure of CFL sentences imposes that the move of the PDA may depend on information stored in the stack, which in turn may depend on information read from the input much earlier than the current move.

Despite these difficulties some interesting results concerning a logic characterization of CFL have been obtained. In particular it is worth mentioning the characterization proposed in [35]. The key idea is to enrich the syntax of the second order logic with a matching relation symbol $M$ which takes as arguments two string position symbols $\bm{x}$ and $\bm{y}$: a matching relation interpreting $M$ must satisfy the following axioms:

• •

$M(\bm{x},\bm{y})\Rightarrow\bm{x}<\bm{y}$: $\bm{y}$ always follows $\bm{x}$;

• •

$M(\bm{x},\bm{y})\Rightarrow\not\exists\bm{z}(\bm{z}\not\eq\bm{x}\land\bm{z}\not\eq\bm{y}\land(M(\bm{x},\bm{z})\lor M(\bm{z},\bm{y})\lor M(\bm{z},\bm{x})\lor M(\bm{y},\bm{z})))$: $M$ is one-to-one;

• •

$\forall\bm{x},\bm{y},\bm{z},\bm{w}((M(\bm{x},\bm{y})\land M(\bm{z},\bm{w})\land\bm{x}<\bm{z}<\bm{y})\Rightarrow\bm{x}<\bm{w}<\bm{y})$: $M$ is nested, i.e., if we represent graphically $M(\bm{x},\bm{y})$ as an edge from $\bm{x}$ to $\bm{y}$ such edges cannot cross.

The matching relation is then used to represent the tree structure(s) associated with a CF language sentence: for instance consider the (ambiguous) grammar $G_{amb}$

[TABLE]

$G_{amb}$ induces a natural matching relation between the positions of characters in its strings. For instance Figure 9 shows the two relations associated with the string $aaaabbbb$.

More generally we could state that for a grammar $G$ and a sentence $x=a_{1}a_{2}...a_{n}\in L(G)$ with $\forall k,a_{k}\in\Sigma$, $(i,j)\in M$ iff $S\stackrel{{\scriptstyle*}}{{\Rightarrow}}_{G}a_{1}a_{2}...a_{i-1}Aa_{j+1}...a_{n}\stackrel{{\scriptstyle*}}{{\Rightarrow}}_{G}a_{1}a_{2}...a_{n}$. It is immediate to verify, however, that such a definition in general does not guarantee the above axioms for the matching relation: think e.g., to the previous grammar $GAE_{1}$ which generates arithmetic expressions. For this reason [35] adopts the so-called double Greibach normal form (DGNF) which is an effective but non-trivial transformation of a generic CFG into an equivalent one where the first and last characters of any production are terminal.444To be more precise, the normal form introduced in [35] is further specialized, but for our introductory purposes it is sufficient to consider any DGNF. It is now immediate to verify that a grammar in DGNF does produce a matching relation on its strings that satisfies all of its axioms.

Thanks to the new relation and the corresponding symbol [35] defines a second order logic CF$\mathcal{L}$ that characterizes CFL: the sentences of CF$\mathcal{L}$ are first-order formulas prefixed by a single existential quantifier applied to the second order variable $M$ representing the matching relation. Thus, intuitively, a CF$\mathcal{L}$ sentence such as $\exists M(\phi)$ where $M$ occurs free in $\phi$ and $\phi$ has no free occurrences of first-order variables is satisfied iff there is a structure defined by a suitable matching relation such that the positions that satisfy the occurrences of $M$ in $\phi$ also satisfy the whole $\phi$. For instance the sentence

[TABLE]

is satisfied by all and only the strings of $L(G_{amb})$ with both the $M$ relations depicted in Figure 9.

After having defined the above logic, [35] proved its equivalence with CFL in a fairly natural way but with a few non-trivial technicalities: with an oversimplification, from a given CFG in DGNF a corresponding logic formula is built inductively in such a way that $M(\bm{x},\bm{y})$ holds between the positions of leftmost and rightmost leaves of any subtree of a grammar’s syntax-tree; conversely, from a given logic formula a tree-language, i.e., a set of trees, is built such that the frontiers of its trees are the sentences of a CFL. However, as the authors themselves admit, this result has a minor potential for practical applications due to the lack of closure under complementation. The need to resort to the DGNF puts severe constraints on the structures that can be associated with the strings, a priori excluding, e.g., linear structures typical of RL; nonetheless the introduction of the $M$ relation opened the way for further important developments as we will show in the next sections.

3.4 Parsing

PDA are the natural abstract machines to recognize CFL as well as FSA are for RL; we have also seen that augmenting PDA with a suitable output device makes them pushdown transducers (PDT) which can be used as parsers, i.e. to build the syntax-tree(s) associated with a given string of the language. Unlike the case of RL, however, DPDA are not able to recognize all CFL. Thus, if we want to recognize or parse a generic CFL, in principle we must simulate all possible computations of a nondeterministic PDA (or PDT); this approach clearly raises a critical complexity issue. For instance, consider the analysis of any string in $\Sigma^{*}$ by the PDA accepting $L=\{ww^{R}\mid w\in\{a,b\}^{*}\}$: in the worst case at each move the automaton “splits” its computation in two branches by guessing whether it reached the middle of the input sentence or not; in the first case the computation proceeds deterministically to verify that from that point on the input is the mirror image of what has been read so far, whereas the other branch of the computation proceeds still waiting for the middle of the string and splitting again and again at each step. Thus, the total number of different computations equals the length of the input string, say $n$, and each of them has in turn an $O(n)$ length; therefore, simulating the behavior of such a nondeterministic machine by means of a deterministic algorithm to check whether at least one of its possible computations accepts the input has an $O(n^{2})$ total complexity.

The above example can be generalized in the following way: on the one hand we have

Statement 1

Every CFL can be recognized in real-time, i.e. in a number of moves equal to the length of the input sentence, by a, possibly nondeterministic, PDA.

One way to prove the statement is articulated in two steps:

1. First, an original CFG generating $L$ is transformed into the *Greibach normal form (GNF)*555The previous DGNF is clearly a “symmetric variant” of the original GNF but is not due to the same author and serves different purposes.:

Definition 9

A CFG is in Greibach normal form [30] iff the rhs of all its productions belongs to $\Sigma V_{N}^{*}$.

The procedure given in [28] to transform any CF grammar into the normal form essentially is based on transforming any left recursion, i.e. a derivation such as $A\stackrel{{\scriptstyle{*}}}{{\Rightarrow}}A\alpha$ into an equivalent right one $B\stackrel{{\scriptstyle{*}}}{{\Rightarrow}}\alpha B$.

2. Starting from a grammar in GNF the procedure to build an equivalent PDA therefrom can be “optimized” by:

• •

restricting $\Gamma$ to $V_{N}$ only;

• •

when a symbol $A$ is on top of the stack, a single move reads the next input symbol, say $a$, and replaces $A$ in the stack with the string $\alpha$ of the rhs of a production $A\to a\alpha$, if any (otherwise the string is rejected).

Notice that such an automaton is real-time since there are no more $\varepsilon$-moves but, of course, it may still be nondeterministic. If the grammar in GNF is such that there are no two distinct productions of the type $A\to a\alpha$, $A\to a\beta$, then the automaton built in this way is a real-time DPDA that is able to build leftmost derivations of the grammar. In Section 5.1 we will go back to the issue of building deterministic parsers for CFL.

Statement 1, on the other hand, leaves us with the natural question: “provided that purely nondeterministic machines are not physically available and at most can be approximated by parallel machines which however cannot exhibit an unbounded parallelism, how can we come up with some deterministic parsing algorithm for general CFL and which complexity can exhibit such an algorithm?”. In general it is well-known that simulating a nondetermistic device with complexity666As usual we assume as the complexity of a nondeterministic machine the length of the shortest computation that accepts the input or of the longest one if the string is rejected. $f(n)$ by means of a deterministic algorithm may expose to the risk of even an exponential complexity $O(2^{f(n)})$. For this reason on the one hand many applications, e.g., compiler construction, have restricted their interest to the subfamily of DCFL; on the other hand intense research has been devoted to design efficient deterministic parsing algorithms for general CFL by departing from the approach of simulating PDA. The case of parsing DCFL will be examined in Section 5; parsing general CFL, instead is of minor interest in this paper, thus we simply mention the two most famous and efficient of such algorithms, namely the one due to Cocke, Kasami, and Younger, usually referred to as CKY and described, e.g., in [30], and the one by Early reported in [14]; they both have an $O(n^{3})$ time complexity.777We also mention (from [30]) that in the literature there exists a variation of the CKY algorithm due to Valiant that is completely based on matrix multiplication and therefore has the same asymptotic complexity of this basic problem, at the present state of the art $O(n^{2.37})$.

To summarize, in this section we have seen that CFL are considerably more general than RL but, on the one side they require parsing algorithms to assign a given sentence an appropriate (tree-shaped and usually not immediately visible) structure and, on the other side, they lose several closure and decidability properties typical of the simpler RL. Not surprisingly, therefore, much, largely unrelated, research has been devoted to face both such challenges; in both cases major successes have been obtained by introducing suitable subclasses of the general language family: on the one hand parsing can be accomplished for DCFL much more efficiently than for nondeterministic ones (furthermore in many cases, such as e.g, for programming languages, nondeterminism and even ambiguity are features that are better to avoid than to pursue); on the other hand various subclasses of CFL have been defined that retain some or most of the properties of RL yet increasing their generative power. In the next sections we resume, in the reverse order, the major results obtained on both sides, so far within different research areas and by means of different subfamilies of CFL. As anticipated in the introduction, however, we will see in the following sections that one of such families allows for major improvements on both sides.

4 Structured context-free languages

RL sentences have a fixed, right or left, linear structure; CFL sentences have a more general tree-structure, of which the linear one is a particular case, which normally is not immediately visible in the sentence and, in case of ambiguity, it may even happen that the same sentence has several structures. R. McNaughton, in his seminal paper [39], was probably the first one to have the intuition that, if we “embed the sentence structure in the sentence itself” in some sense making it visible from the frontier of the syntax-tree (as it happens implicitly with RL since their structure is fixed a priori), then many important properties of RL still hold for such special class of CFL.

Informally, we name such CFL structured or visible structure CFL. The first formal definition of this class given by McNaughton is that of parenthesis languages, where each subtree of the syntax-tree has a frontier embraced by a pair of parentheses; perhaps the most widely known case of such a language, at least in the field of programming languages is the case of LISP. Subsequently several other equivalent or similar definitions of structured languages, have been proposed in the literature; not surprisingly, an important role in this field is played by tree-languages and their related recognizing machines, tree-automata. Next we browse through a selection of such language families and their properties, starting from the seminal one by McNaughton.

4.1 Parenthesis grammars and languages

Definition 10

For a given terminal alphabet $\Sigma$ let $[$, $]$ be two symbols $\not\in\Sigma$. A parenthesis grammar (PG) with alphabet $\Sigma\cup\{[,]\}$ is a CFG whose productions are of the type $A\to[\alpha]$, with $\alpha\in V^{*}$.

It is immediate to build a parenthesis grammar naturally associated with any CFG: for instance the following PG is derived from the $GAE_{1}$ of Example 7:

[TABLE]

It is also immediate to realize that, whereas $GAE_{1}$ does not make immediately visible in the sentence $e+e*e$ that $e*e$ is the frontier of a subtree of the whole syntax-tree, $GAE_{[]}$ generates $[[[e]+[[e]*[e]]]]$ (but not $[[[[e]+[e]]*[e]]]$), thus making the structure of the syntax-tree immediately visible in its parenthesized frontier.

Sometimes it is convenient, when building a PG from a normal one, to omit parentheses in the rhs of $renaming$ $rules$, i.e., rules whose rhs reduces to a single nonterminal, since such rules clearly do not significantly affect the shape of the syntax-tree. In the above example such a convention would avoid the useless outermost pair of parentheses.

Given that the trees associated with sentences generated by PG are isomorphic to the sentences, the parsing problem for such languages disappears and scales down to a simpler recognition problem as it happens for RL. Thus, rather than using the full power of general PDA for such a job, tree-automata have been proposed in the literature as a recognition device equivalent to PG as well as FSA are equivalent to regular grammars. Intuitively, a tree-automaton (TA) traverses either top-down or bottom-up a labeled tree to decide whether to accept it or not, thus it is a tree-recognizer or tree-acceptor.

4.2 Tree Automata

Here we give an introductory view of the tree automata formalism: our formal definition is inspired by the traditional ones, e.g., in [45, 13] but with minor adaptations for convenience and homogeneity with the notation adopted in this paper; to avoid possible terminological confusion with other literature on tree-automata we give a different name to such automata.

Definition 11

A stencil of a terminal alphabet $\Sigma$ is a string in $(\Sigma\cup\{N\})^{*}$. A stencil or tree alphabet is a finite set of stencils. The number of occurrences of the symbol $N$ in a stencil $st$ is called the stencil’s arity and is denoted $n(st)$.

Definition 12

A top-down stencil automaton is a tuple $(Q,$ $ST_{\Sigma},$ $\Delta,I)$, where

• •

$Q$ is a finite set of states

• •

$ST_{\Sigma}$ is a finite set of stencils of $\Sigma$; $ST_{\Sigma,n}$ denotes the subset of $ST_{\Sigma}$ of the stencils with arity $n$

• •

$\Delta$ is a collection of relations $\{\delta_{n}\subseteq Q\times ST_{(\Sigma,n)}\times Q^{n}\}$

• •

$I\subseteq Q$ is the set of initial states.

A top-down stencil automaton is deterministic iff

• •

For each $n,\delta_{n}$ is a function $\delta_{n}:Q\times ST_{(\Sigma,n)}\to Q^{n}$

• •

$I$ is a singleton

Definition 13

A tree on a given pair ($ST_{\Sigma}$, $Q$) is a tree whose internal nodes are labeled by elements of $Q$, leaves are labeled by elements of $\Sigma$, and the homomorphism $h(q)=N$, with $q\in Q$ projects all strings of children of any node of the tree into an element of $ST_{\Sigma}$

A tree on a pair ($ST_{\Sigma}$, $Q$) is accepted by a top-down stencil automaton $\mathcal{A}=(Q,ST_{\Sigma},\Delta,I)$ iff

• •

the root is labeled by an element $\in I$

• •

each pair ($q_{f},\alpha)$ where $q_{f}$ is the label of a father node, $\alpha$ is the string of its children in $(\Sigma\cup Q)^{*}$ is such that $(q_{f},h(\alpha),q_{1},...,q_{n})\in\delta_{n}$, where $n$ is the arity of $h(\alpha)$ and $q_{1},...,q_{n}$ are the states ocurring in $\alpha$, in the same order.

It is immediate to state a one-to-one, effective correspondence between parenthesis grammars and top-down stencil automata; in doing so it may be convenient to preliminarily eliminate from the grammar renaming rules [30] which do not have a real meaning in terms of sentence structure; such a normal form also requires that, instead of having just one axiom with possible renaming rules with it as lhs, $S$ is a subset of $V_{N}$ and there is a one-to-one correspondence between $S$ and $I$.

Example 9

The following stencil automaton $\mathcal{A}=(Q,$ $ST_{\Sigma},$ $\Delta,I)$ recognizes the syntax-trees of the grammar $GAE_{1}$ whose structure, up to the labeling of the internal nodes, is also described by the sentences of the parenthesis grammar $GAE_{[]}$.

• •

$Q=\{E,T,F\}$

• •

$ST_{\Sigma}=\{e,N+N,N*N\}$

• •

$\Delta=\{(E,e),(T,e),(F,e),(T,N*N,T,F),(E,N*N,T,F),$ $(E,N+N,E,T)\}$

• •

$I=\{E,T,F\}$

If we compare the automata of Examples 8 and 9 we notice that both of them, resp., build and recognize the syntax-trees generated by grammar $GAE_{1}$ in top-down order; precisely, the computations of the automaton of Example 8 follow a leftmost derivation of the grammar, whereas the automaton of Example 9 simply states a partial order in the application of the $\delta$ relation going from father nodes to children. In both cases, however, it may be convenient to use automata that work in a symmetric way, i.e., resp. build or traverse the syntax-trees bottom up. Two important cases of bottom up parsers are described in Sections 5.2 and 6.2; here instead we introduce bottom-up stencil automata and compare them with the top-down ones.

Definition 14

A bottom-up stencil automaton is a tuple $(Q,$ $ST_{\Sigma},$ $\Delta,F)$, where $Q$ and $ST_{\Sigma}$ are as in Definition 12,

• •

$\Delta$ is a collection of relations $\{\delta_{n}\subseteq Q^{n}\times ST_{(\Sigma,n)}\times Q\}$

• •

$F\subseteq Q$ is the subset of $Q$’s final states.

The automaton is deterministic iff for each $n$, $\delta_{n}$ is a function $\delta_{n}:Q^{n}\times ST_{(\Sigma,n)}\to Q$.

A tree on a pair ($ST_{\Sigma}$, $Q$) is accepted by a bottom-up stencil automaton $\mathcal{A}=(Q,ST_{\Sigma},\Delta,F)$ iff

• •

each pair ($\alpha,q_{f})$ where $q_{f}$ is the label of a father node, $\alpha$ is the string of its children in $(\Sigma\cup Q)^{*}$ is such that $(q_{1},...,q_{n},h(\alpha),q_{f})\in\delta_{n}$, where $n$ is the arity of $h(\alpha)$ and $q_{1},...,q_{n}$ are the states ocurring in $\alpha$, in the same order;

• •

the root is labeled by an element $\in F$.

Structured CFL, of which parenthesis languages are a first major example, enjoy some properties that hold for RL but are lost by general CFL. In particular, we mention their closure under Boolean operations, which has several major benefits, including the decidability of the containment problem. They key milestones that allowed McNaughton to prove this closure are:

• •

The possibility to apply all operations within a* structure universe*, i.e., to a universe of syntax-trees rather than to the “flat” $\Sigma^{*}$; in the case of parenthesis languages the natural universe associated with a given set of stencils is generated by the corresponding stencil grammar, i.e. the grammar with the only nonterminal $N$ and one production for every stencil.

• •

The possibility of building a normal form of any parenthesis grammar with no repeated rhs, i.e., such that for every rhs there is only one production rewriting it. Such a construction has been defined by McNaughton by referring directly to the grammars but can be explained even more intuitively by noticing that, if we transform a bottom-up stencil automaton into a parenthesis grammar and conversely, the grammar has no repeated rhs iff the automaton is deterministic. In both cases the procedure to obtain such a normal form is a natural extension of the basic one applied to FSA and is based on defining a new set of states (resp. nonterminals) that is the power set of the original one; for instance, suppose that a grammar contains two rules $A\to[ab]$ and $B\to[ab]$; then they are “collapsed” into the unique one $AB\to[ab]$; then the procedure is iterated by replacing both $A$ and $B$ by the new nonterminal $AB$ in every rhs where they occur and so on until no new nonterminal is generated. It is then an easy exercise to prove the equivalence between the original grammar (resp. automaton) and the new one by means of a natural induction.

It is important to emphasize, however, that such a way to determinize a nondeterministic bottom-up stencil automaton does not work in the case of the top-down version of these automata: deterministic top-down tree (or stencil) automata in fact have been proven to be less powerful than their bottom-up counterpart. We refer the reader to a more specific literature, e.g. [13], for a proof of this claim; here we simply anticipate that something similar occurs for the parsing of DCFL.

On the basis of these two fundamental properties deriving effective closure w.r.t. Boolean operations within a given universe of stencils is a natural extension of the operations already outlined for RL (notice that RL are a special case of structured languages whose stencils are only linear, i.e., of the type $aN,a$ (or $Na,a$) for $a\in\Sigma$).

• •

The complement language w.r.t. the universe of syntax-trees associated with a given set of stencils is obtained by

• –

Adding a new conventional state $q_{err}$ to a deterministic bottom up stencil automaton and completing each $\delta_{n}$ with it on the whole domain $Q^{n}\times ST_{(\Sigma,n)}$ in the same way as for RL.

• –

Complementing the set of accepting states.

• •

The intersection between two languages sharing the same set of stencils is obtained by building a new set of states that is the cartesian product of the original ones and extending the $\delta$ function in the usual way.

As usual, an immediate corollary of these closure properties is the decidability of the containment problem for two languages belonging to the same universe.

We just mention another important result that is obtained as an extension of its version that holds for RL, namely, the possibility of minimizing the grammar generating a parenthesis language (resp. the automaton recognizing a tree language), w.r.t. the number of necessary nonterminals (resp. states); this type of results, however, is not in the scope of this paper; thus we refer the interested reader to the original paper by McNaughton or other subsequent literature.

On the basis of the important results obtained by McNaughton in his seminal paper, many other families of CFL have been defined in several decades of literature with the general goal of extending (at least some of the) closure and decidability properties, and logic characterizations that make RL such a “nice” class despite its limits in terms of generative power. Most of such families maintain the key property of being “structured” in some generalized sense w.r.t. parenthesis languages. In the following section we introduce so called input-driven languages, also known as visibly pushdown languages which received much attention in recent literature and exhibit a fairly complete set of properties imported from RL.

4.3 Input-driven or visibly pushdown languages

The concept of input-driven CF language has been introduced in [40] in the context of building efficient recognition algorithms for DCFL: according to [40] a DPDA is input-driven if the decision of the automaton whether to execute a push move, i.e. a move where a new symbol is stored on top of the stack, or a pop move, i.e. a move where the symbol on top of the stack is removed therefrom, or a move where the symbol on top of the stack is only updated, depends exclusively on the current input symbol rather than on the current state and the symbol on top of the stack as in the general case. Later, several equivalent definitions of the same type of pushdown automata, whether deterministic or not, have been proposed in the literature; among them, here we choose an early one proposed in [4], which better fits with the notation adopted in this paper than the later one in [5].

Definition 15

Let the input alphabet $\Sigma$ be partitioned into three disjoint alphabets, $\Sigma=\Sigma_{c}\cup\Sigma_{r}\cup\Sigma_{i}$, named, respectively, the call alphabet, return alphabet, internal alphabet. A visibly pushdown automaton (VPA) over $(\Sigma_{c},\Sigma_{r},\Sigma_{i})$ is a tuple $(Q,I,\Gamma,$ $Z_{0},$ $\delta,F)$, where

• •

$Q$ is a finite set of states;

• •

$I\subseteq Q$ is the set of initial states;

• •

$F\subseteq Q$ is the set of final or accepting states;

• •

$\Gamma$ is the finite stack alphabet;

• •

$Z_{0}\in\Gamma$ is the special bottom stack symbol;

• •

$\delta$ is the transition relation, partitioned into three disjoint subrelations:

• –

Call move: $\delta_{c}\subseteq Q\times\Sigma_{c}\times Q\times(\Gamma\setminus\{Z_{0}\})$,

• –

Return move: $\delta_{r}\subseteq Q\times\Sigma_{r}\times\Gamma\times Q$,

• –

Internal move: $\delta_{i}\subseteq Q\times\Sigma_{i}\times Q$.

A VPA is deterministic iff $I$ is a singleton, and $\delta_{c}$, $\delta_{r}$, $\delta_{i}$ are functions:

$\delta_{c}:Q\times\Sigma_{c}\to Q\times(\Gamma\setminus\{Z_{0}\})$, $\ \delta_{r}:Q\times\Sigma_{r}\times\Gamma\to Q$, $\ \delta_{i}:Q\times\Sigma_{i}\to Q$.

The automaton configuration, the transition relation between two configurations, the acceptance of an input string, and the language recognized by the automaton are then defined in the usual way: for instance if the automaton reads a symbol $a$ in $\Sigma_{c}$ while is in the state $q$ and has $C$ on top of the stack, it pushes onto the stack a new symbol $D$ and moves to state $q^{\prime}$ provided that $(q,a,q^{\prime},D)$ belongs to $\delta_{c}$; notice that in this way the special symbol $Z_{0}$ can occur only at the bottom of the stack, during the computation. A language over an alphabet $\Sigma=\Sigma_{c}\cup\Sigma_{r}\cup\Sigma_{i}$ recognized by some VPA is called a visibly pushdown language (VPL).

The following remarks help put IDL alias VPL in perspective with other families of CFL.

• •

Once PDA are defined in a standard form, with respect to the general one given in Definition 8 where their moves either push a new symbol onto the stack or remove it therefrom or leave the stack unaffected, the two definitions of IDL and VPL are equivalent. Both names for this class of languages are adequate: on the one side, the attribute input-driven emphasizes that the automaton move is determined exclusively on the basis of the current input symbol888We will see, however, that the same term can be interpreted in a more general way leading to larger classes of languages.; on the other side we can consider VPL as structured languages since the structure of their sentences is immediately visible thanks to the partitioning of $\Sigma$.

• •

VPL generalize McNaughton’s parenthesis languages:

open parentheses are a special case of $\Sigma_{c}$ and closed ones of $\Sigma_{r}$; further generality is obtained by the possibility of performing an unbounded number of internal moves, actually “purely finite state” moves between two matching call and return moves and by the fact that VPA can accept unmatched return symbols at the beginning of a sentence as well as unmatched calls at its end; a motivation for the introduction of such a generality is offered by the need of modeling systems where a computation containing a sequence of procedure calls is suddenly interrupted by a special event such as an exception or an interrupt.

• •

Being VPL essentially structured languages, their corresponding automata are just recognizers rather than real parsers.

• •

VPL are real-time languages; in fact VPA read one input symbol for each move. We have mentioned that this property can be obtained for nondeterministic PDA recognizing any CFL but not for deterministic ones.

VPL have obtained much attention since they represent a major step in the path aimed at extending many, if not all, of the important properties of RL to structured CFL. They are closed w.r.t. all major language operations, namely the Boolean ones, concatenation, Kleene ∗ and others; this also implies the decidability of the containment problem, which, together with the characterization in terms of a MSO logic, again extending the result originally stated for RL, opens the door to applications in the field of automatic verification.

A key step to achieve such important results is the possibility of effectively determinizing nondeterministic VPA. The basic idea is similar to the classic one that works for RL, i.e, to replace the uncertainty on the current state of a nondeterministic automaton with the subset of $Q$ containing all such possible states (see Example 3). Unlike the case of FSA however, when the automaton executes a return move it is necessary to “match” the current state with the one that was entered at the time of the corresponding call; to do so the key idea is to “pair” the set of states nondeterministically reached at the time of a return move with those that were entered at the time of the corresponding call; intuitively, the latter ones are memorized and propagated through the stack, whose alphabet is enriched with pairs of set states. As a result at the moment of the return it is possible to check whether some of the states memorized at the time of the call “match” with some of the states that can be currently held by the nondeterministic original automaton.

We do not go into the technical details of this construction, referring the reader to [4] for them; we just mention that, unlike the case of RL, the price to be paid in terms of size of the automaton to obtain a deterministic version from a nondetermistic one is $2^{O(s^{2})}$, where $s$ is the size of the original state set. In [5] the authors also proved that such a gap is unavoidable since there are VPL that are recognized by a nondeterminitic VPA with a state set of cardinality $s$ but are not recognized by any deterministic VPA with less than $2^{s^{2}}$ states. In Section 6.1 we will provide a similar proof of determinization for a more general class of automata.

Once a procedure to obtain a deterministic VPA from a nondeterministic one is available, closure w.r.t. Boolean operations follows quite naturally through the usual path already adopted for RL and parenthesis languages. Closure under other major language operations such as concatenation and Kleene ∗ is also obtained without major difficulties but we do not report on it since those operations are not of major interest for this paper. Rather, we wish here to go back to the issue of logical characterization.

4.3.1 The logic characterization of visibly pushdown languages

We have seen in Section 3.3 that attempts to provide a logic characterization of general CFL produced only partial results due to the lack of closure properties and to the fact that CFL do not have an a priori fixed structure; in fact the characterization offered by [35] and reported here requires an existential quantification w.r.t. relation $M$ that represents the structure of a string. Resorting to structured languages such as VPL instead allowed for a fairly natural generalization of the classical Büchi’s result for RL.

The key steps to obtain this goal are [5]:

• •

Using the same relation $M$ introduced in [35],999Renamed nesting relation and denoted as $\leadsto$ or $\nu$ in later literature. adding its symbol as a basic predicate to the MSO logic’s syntax given in Section 2.2 for RL, and extending its interpretation in the natural way. This turns out to be simpler and more effective in the case of structured languages since, being such languages a priori unambiguous (the structure of the sentence is the sentence itself), there is only one such relation among the string positions and therefore there is no need to quantify it. Furthermore the relation is obviously one-to-one with a harmless exception due to the existence of unmatched closed parentheses at the beginning of the sentence and unmatched open ones at the end: in such cases conventional relations $M(-\infty,\bm{x})$, $M(\bm{x},+\infty)$ are stated.

• •

Repeating exactly the same path used for RL both in the construction of an automaton from a logic formula and in the converse one. This only requires the managing of the new $M$ relation in both constructions; precisely:

In the construction from the MSO formula to VPA, the elementary automaton associated with the atomic formula $M(\bm{X},\bm{Y})$, where $\bm{X}$ and $\bm{Y}$ are the usual singleton second order variables for any pair of first order variables $\bm{x}$ and $\bm{y}$, is represented by the diagram of Figure 10 where, like in the same construction for RL, $\circ$ stands for any value of $\Sigma$ for which the transition can be defined according to the alphabet partitioning, so that the automaton is deterministic, the second component of the triple corresponds to $\bm{X}$, and the third to $\bm{Y}$.101010We use here the following notation for depicting VPA: a label $a/B$ stands for a push move, $a,B$ for a pop move, and $a$ alone for an internal move.

In the construction from the VPA to the MSO formula, besides variables $\bm{X}_{i}$ for encoding states, we also need variables to encode the stack. We introduce variables $\bm{C}_{A}$ and $\bm{R}_{A}$, for $A\in\Gamma$, to encode, respectively, the set of positions in which a call pushes $A$ onto the stack, and in which a return pops $A$ from the stack.

The following formula states that every pair $(\bm{x},\bm{y})$ in $M$ must belong, respectively, to exactly one $\bm{C}_{A}$ and exactly one $\bm{R}_{A}$:

[TABLE]

The following subformulas express the conditions for call and return transitions, respectively. They are added to the ones already described in Section 2.2 (without loss of generality, we assume that the original VPA is deterministic). Subformulas for internal transitions are almost identical to those for FSA.

[TABLE]

[TABLE]

Example 10

Consider the alphabet $\Sigma=(\Sigma_{c}=\{a\}$, $\Sigma_{r}=\{b\},$ $\Sigma_{i}=\emptyset)$ and the VPA depicted in Figure 11.

The MSO formula $\exists\bm{X}_{0},\bm{X}_{1},\bm{X}_{2},\bm{X}_{3},\bm{C}_{A},\bm{C}_{B},\bm{R}_{A},\bm{R}_{B}(\varphi_{\mathcal{A}}\land\varphi_{M})$ is built on the basis of such an automaton, where $\varphi_{M}$ is the conjunction of the formulas defined above, and $\varphi_{\mathcal{A}}$ is:

[TABLE]

Other studies aimed at exploiting less complex but also less powerful logics, such as first-order and temporal ones to support a more practical automatic verification of VPL [1] as it happened with great success with model-checking for RL; algorithmic model-checking, however, is not the main focus of this paper and we do not go deeper into this issue.

4.4 Other structured context-free languages

As we said, early work on parenthesis languages and tree-automata ignited many attempts to enlarge those classes of languages and to investigate their properties. Among them VPL have received much attention in the literature and in this paper, probably thanks to the completeness of the obtained results –closure properties and logic characterization. To give an idea of the vastness of this panorama and of the connected problems, and to help comparison among them, in this section we briefly mention a few more of such families with no attempt for exhaustiveness.

4.4.1 Balanced grammars

Balanced grammars (BG) have been proposed in [7] as a first approach to model mark-up languages such as XML by exploiting suitable extensions of parenthesis grammars. Basically a (BG) has a partitioned alphabet exactly in the same way as VPL; on the other hand any production of a BG has the form $A\to a\alpha b$ where $a\in\Sigma_{c}$, $b\in\Sigma_{r}$, and $\alpha$ is a regular expression111111A regular expression over a given alphabet $V$ is built on the basis of alphabet’s elements by applying union, concatenation, and Kleene ∗ symbols; it is well-known that the class of languages definable by means of regular expressions is RL. over $V_{N}\cup\Sigma_{i}$.

Since it is well-known that the use of regular expressions in the rhs of CF grammars can be replaced by a suitable expansion by using exclusively “normal” rules, we can immediately conclude that balanced languages, i.e. those generated by BG, are a proper subclass of VPL (e.g. they do not admit unmatched elements of $\Sigma_{c}$ and $\Sigma_{r}$). Furthermore they are not closed under concatenation and Kleene ∗ [7]; we are not aware of any logic characterization of these languages.

4.4.2 Height-deterministic languages

Height-deterministic languages, introduced in [41], are a more recent and fairly general way of describing CFL in terms of their structure. In a nutshell the hidden structure of a sentence is made explicit by making $\varepsilon$-moves visible, in that the original $\Sigma$ alphabet is enriched as $\Sigma\cup\{\varepsilon\}$; if the original input string in $\Sigma^{*}$ is transformed into one over $\Sigma\cup\{\varepsilon\}$ by inserting an explicit $\varepsilon$ wherever a recognizing automaton executes an $\varepsilon$-move, we obtain a linear representation of the syntax-tree of the original sentence, so that the automaton can be used as a real parser. We illustrate such an approach by means of the following example.

Example 11

Consider the language $L=L_{1}\cup L_{2}$, with $L_{1}=\{a^{n}b^{n}c^{*}\mid n\geq 0\}$, $L_{2}=\{a^{*}b^{n}c^{n}\mid n\geq 0\}$ which is well-know to be inherently ambiguous since a string such as $a^{n}b^{n}c^{n}$ can be parsed both according to $L_{1}$’s structure and according to $L_{2}$’s one. A possible nondeterministic PDA $\mathcal{A}$ recognizing $L$ could act as follows:

• •

$\mathcal{A}$ pushes all $a$’s until it reaches the first $b$; at this point it makes a nondeterministic choice:

• –

in one case it makes a “pause”, i.e., an $\varepsilon$-move and enters a new state, say $q_{1}$;

• –

in the other case it directly enters a different state, say $q_{2}$ with no “pause”;

• •

from now on its behavior is deterministic; precisely:

• –

in $q_{1}$ it checks that the number of $b$’s equals the number of $a$’s and then accepts any number of $c$’s;

• –

in $q_{2}$ it pushes the $b$’s to verify that their number equals that of the $c$’s.

Thus, the two different behaviors of $\mathcal{A}$ when analyzing a string of the type $a^{n}b^{n}c^{n}$ would result into two different strings in the extended alphabet $\Sigma\cup\{\varepsilon\}$121212This could be done explicitly by means of a nondeterministic transducer that outputs a special marker in correspondence of an $\varepsilon$-move, but we stick to the original [41] formalization where automata are used exclusively as acceptors without resorting to formalized transducers. , namely $a^{n}\varepsilon b^{n}c^{n}$ and $a^{n}b^{n}c^{n}$; it is now simple, if needed, to state a one-to-one correspondence between strings augmented with explicit $\varepsilon$ and the different syntax-trees associated with the original input: in this example, $a^{n}\varepsilon b^{n}c^{n}$ corresponds to the structure of Figure 12 (a) and $a^{n}b^{n}c^{n}$ to that of Figure 12 (b). It is also easy to build other nondeterministic PDA recognizing $L$ that “produce” different strings associated with different structures.

Once the input string structures are made visible by introducing the explicit $\varepsilon$ character, the characteristics of PDA, of their subclasses, and of the language subfamilies they recognize, are investigated by referring to the heights of their stack. Precisely:

• •

Any PDA is put into a normalized form, where

• –

the $\delta$ relation is complete, i.e., it is defined in such a way that for every input string, whether accepted or not, the automaton scans the whole string:

$\forall x\exists c(c_{0}=(x,q_{0},Z_{0})\stackrel{{\scriptstyle{*}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}c=(\varepsilon,q,\gamma))$;

• –

every element of $\delta$ is exclusively in one of the forms: $(q,A,o,q^{\prime},AB)$, or $(q,A,o,$ $q^{\prime},A)$, or $(q,A,o,q^{\prime},\varepsilon)$, where $o\in(\Sigma\cup\{\varepsilon\})$ ;

• –

for every $q\in Q$ all elements of $\delta$ having $q$ as the first component either have $o\in\Sigma$ or $o=\varepsilon$, but not both of them.

• •

For any normalized $\mathcal{A}$ and word $w\in(\Sigma\cup\{\varepsilon\})^{*}$, $\mathcal{N}(\mathcal{A},w)$ denotes the set of all stack heights reached by $\mathcal{A}$ after scanning $w$.

• •

$\mathcal{A}$ is said height-deterministic (HPDA) iff $\forall w\in(\Sigma\cup\{\varepsilon\})^{*}$, $\>|\mathcal{N}(\mathcal{A},w)|\>=1$.

• •

The family of height-deterministic PDA is named HPDA; similarly, HDPDA denotes the family of deterministic height-deterministic PDA, and HRDPDA that of deterministic, real-time (i.e., those that do not perform any $\varepsilon$-move) height-deterministic PDA. The same acronyms with a final $L$ replacing the $A$ denote the corresponding families of languages.

It is immediate to realize (Lemma 1 of [41]) that every PDA admits an equivalent normalized one. Example 11 provides an intuitive explanation that every PDA admits an equivalent HPDA (Theorem 1 of [41]); thus HPDL = CFL; also, any (normalized) DPDA is, by definition an HPDA and therefore a deterministic HPDA; thus HDPDL = DCFL. Finally, since every deterministic VPA is already in normalized form and is a real-time machine, VPL $\subset$ HRDPDL: the strict inclusion follows from the fact that $L=\{a^{n}ba^{n}\}$ cannot be recognized by a VPA since the same character $a$ should belong both to $\Sigma_{c}$ and to $\Sigma_{r}$.

Coupling the extension of the alphabet from $\Sigma$ to $\Sigma\cup\{\varepsilon\}$ with the set $\mathcal{N}(\mathcal{A},w)$ allows us to consider HPDL as a generalized kind of structured languages. As an intuitive explanation, let us go back to Example 11 and consider the two behaviors of $\mathcal{A}$ when parsing the string $aabbcc$ once it has been “split” into $aabbcc$ and $aa\varepsilon bbcc$; the stack heights $\mathcal{N}(\mathcal{A},w)$ for all their prefixes are, respectively: $(1,2,3,4,3,2)$ and $(1,2,2,1,0,0,0)$ (if we do not count the bottom of the stack $Z_{0}$). In general, it is not difficult to associate every sequence of stack lengths during the parsing of an input string (in $(\Sigma\cup\{\varepsilon\})^{*}$!) with the syntax-tree visited by the HPDA.

As a consequence, the following fundamental definition of synchronization between HPDA can be interpreted as a form of structural equivalence.

Definition 16

Two HPDA $\mathcal{A}$ and $\mathcal{B}$ are synchronized, denoted as $\mathcal{A}\sim\mathcal{B}$, iff $\forall w\in(\Sigma\cup\{\varepsilon\})^{*}$, $\mathcal{N}(\mathcal{A},w)$ = $\mathcal{N}(\mathcal{B},w)$.

It is immediate to realize that synchronization is an equivalence relation and therefore to associate an equivalence class $[\mathcal{A}]_{\sim}$ with every HPDA; we also denote as $\mathcal{A}$-HDPL the class of languages recognized by automata in $[\mathcal{A}]_{\sim}$. Then, in [41] the authors show that:

• •

For every deterministic HPDA $\mathcal{A}$ the class $\mathcal{A}$-HDPL is a Boolean algebra.131313If the automaton is not deterministic only closures under union and intersection hold.

• •

Real-time HPDA can be determinized (with a complexity of the same order as for VPA), so that the class of real-time HPDL coincides with HRDPDL.

On the other hand neither HRDPDL nor HDPDL are closed under concatenation and Kleene ∗ [15] so that the gain obtained in terms of generative power w.r.t. VPL has a price in terms of closure properties. We are not aware of logic characterizations for this class of structured languages.

Let us also mention that other classes of structured languages based on some notion of synchronization have been studied in the literature; in particular [41] compare their class with those of [25] and [11]. Finally, we acknowledge that our survey does not consider some logic characterization of tree or even graph languages which refer either to very specific families (such as, e.g. star-free tree languages [42]) and/or to an alphabet of basic elements, e.g., arcs connecting tree or graph nodes [10], which departs from the general framework of string (structured) languages.

5 Parsing context-free languages deterministically

We have seen in Section 3.4 that general CFL, having a hidden and sometimes ambiguous structure, need not only recognizing mechanisms but more complex parsing algorithms that, besides deciding whether a string belongs to the language or not, also produce the syntax-tree(s) formalizing its structure and possibly driving its semantics; parsing is the core of any compiler or interpreter. We noticed that not all CFL can be recognized –and therefore parsed– by DPDA: whereas any CFL can be recognized by a nondeterministic PDA that operates in real-time, the best deterministic algorithms to parse general CFL, such as CKY and Early’s ones have a $O(n^{3})$ complexity, which is considered not acceptable in many fields such as programming language compilation.

For this and other reasons many application fields restrict their attention to DCFL; DPDA can be easily built, with no loss of generality, in such a way that they can operate in linear time, whether as pure recognizers or as parsers and language translators: it is sufficient, for any DPDA, to effectively transform it into an equivalent loop-free one, i.e. an automaton that does not perform more than a constant number, say $k$, of $\varepsilon$-moves before reading a character from the input or popping some element from the stack (see, e.g., [30]). In such a way the whole input $x$ is analyzed in at most $h\cdot|x|$ moves, where $h$ is a function of $k$ and the maximum length of the string that the automaton can push on the stack in a single move. Notice, however, that in general it is not possible to obtain a DPDA that recognizes its language in real-time. Consider, for instance, the language $L=\{a^{m}b^{n}c^{n}d^{m}\mid m,n\geq 1\}\cup\{a^{m}b^{+}ed^{m}\mid m\geq 1\}$: intuitively, a DPDA recognizing $L$ must first push the $a$s onto the stack; then, it must also store on the stack the subsequent $b$s since it must be ready to compare their number with the following $c$s, if any; after reading the $b$s, however, if it reads the $e$ it must necessarily pop all $b$s by means of $n$ $\varepsilon$-moves before starting the comparison between the $a$s and the $d$s.

Given that, in general, it is undecidable to state whether a CFL is deterministic or not [31], the problem of automatically building a deterministic automaton, if any, from a given CFG is not trivial and deserved much research. In this section we will briefly recall two major approaches to the problem of deterministic parsing. We do not go deep into their technicalities, however, because the families of languages they can analyze are not of much interest from the point of view of algebraic and logical characterizations. It is Section 6, instead, where we introduce a class of languages that allows for highly efficient deterministic parsing and exhibits practically all desirable algebraic and logical properties.

5.1 Top-down deterministic parsing

In Section 3.4 we introduced the GNF for CFG and observed that, if in such grammars there are no two distinct productions of the type $A\to a\alpha$, $A\to a\beta$, then the automaton built therefrom is deterministic. The above particular case has been generalized leading to the definition of LL grammars, so called because they allow to build deterministic parsers that scan the input Left-to-right and produce the Leftmost derivation thereof. Intuitively, an $LL(k)$ grammar is such that, for any leftmost derivation

[TABLE]

it is possible to decide deterministically which production to apply to rewrite nonterminal $A$ by “looking ahead” at most $k$ terminal characters of the input string that follows $x$.141414 The “tail” of k # characters is a simple trick to allow for the look ahead when the reading head of the automaton is close to the end of the input. Normally, the practical application of LL parsing is restricted to the case $k=1$ to avoid memorizing and searching too large tables. In general this choice allows to cover a large portion of programming language syntax even if it is well-known that not all DCFL can be generated by LL grammars. For instance no LL grammar can generate the deterministic language $\{a^{n}b^{n}\mid n\geq 1\}\cup\{a^{n}c^{n}\mid n\geq 1\}$ since the decision on whether to join the $a$’s with the $b$’s or with the $c$’s clearly requires an unbounded look-ahead.

Example 12

The following grammar is a simple transformation of $GAE_{1}$ in LL form; notice that the original left recursion $E\stackrel{{\scriptstyle{}}}{{\Rightarrow}}E+T$ has been replaced by a right one $E\stackrel{{\scriptstyle{*}}}{{\Rightarrow}}T+E$ and similarly for nonterminal $T$.

[TABLE]

5.2 Bottom-up deterministic parsing

So far the PDA that we used to recognize or parse CFL are working in a top-down manner by trying to build leftmost derivation(s) that produce the input string starting from grammar’s axiom. We also mentioned, however, that trees can be traversed also in a bottom-up way; a typical way of doing so is visiting them in leftmost post-order, i.e. scanning their frontier left-to right and, as soon as a string of children is identified, writing them followed by their father, then proceeding recursively until the root is reached. For instance such a visit of the syntax-tree by which $GAE_{1}$ generates the string $e+e*e$ is $eE+eT*eFTES$ which is the reverse of the rightmost derivation $S\stackrel{{\scriptstyle{}}}{{\Rightarrow}}E\stackrel{{\scriptstyle{}}}{{\Rightarrow}}E+T\stackrel{{\scriptstyle{}}}{{\Rightarrow}}E+T*F\stackrel{{\scriptstyle{}}}{{\Rightarrow}}E+T*e\stackrel{{\scriptstyle{}}}{{\Rightarrow}}E+e*e\stackrel{{\scriptstyle{}}}{{\Rightarrow}}e+e*e$.

Although Definition 8 introduces PDA in such a way that they are naturally oriented towards building leftmost derivations, it is not difficult to let them work in a bottom-up fashion: the automaton starts reading the input left-to-right and pushes the read character on top of the stack (formally, since at every transition the character on top of the stack is replaced by a string, it rewrites the existing symbol and adds the read character over it); as soon as –by means of its finite memory control device– it realizes that a whole rhs is on top of the stack it replaces it by the corresponding lhs (again, to be fully consistent with Definition 8, this operation should not be formalized as a single transition but could be designed as a sort of “macro-move” consisting of several micro-steps that remove one character per step and whose last one also pushes the lhs character).151515A formal definition of PDA operating in the above way is given, e.g., in [41] and reported in Section 4.4.2 This type of operating by a PDA is called shift-reduce parsing since it consists in shifting characters from the input to the stack and reducing them from a rhs to the corresponding lhs.

Not surprisingly, the “normal” behavior of such a bottom-up parser is, once again, nondeterministic: in our example once the rhs $e$ is identified, the automaton must apply a reduction either to $F$ or to $T$ or to $E$. Even more critical is the choice that the automaton must take after having read the substring $e+e$ and having (if it did the correct reductions) $E+T$ on top of the stack: in this case the string could be the rhs of the rule $E\to E+T$, and in that case the automaton should reduce it to $E$ but the $T$ on the top could also be the beginning of another rhs, i.e., $T*F$, and in such a case the automaton should go further by shifting more characters before doing any reduction; this is just the opposite situation of what happens with VPL, where the current input symbol allows the machine to decide how to progress.

In fact, the previous type of nondeterminism, i.e., the choice whether to reduce $e$ to $E$ or $T$ or $F$, could be resolved as we did with structured languages, by eliminating repeated rhs through a classical power set construction. In this case, instead, the automaton must build by itself the unknown structure and this may imply a lack of knowledge about having reached or not a complete rhs. “Determinizing” bottom-up parsers has been an intense research activity during the 1960’s, as well as for their top-down counterpart. In Section 6 we thoroughly examine one of the earliest practical deterministic bottom-up parsers and the class of languages they can recognize, namely Floyd’s operator precedence languages. The study of these languages, however, has been abandoned after a while due to advent of a more powerful class of grammars –the LR ones, defined and investigated by Knuth [33], whose parsers proceed Left-to-right as well as the LL ones but produce (the reverse of) Rightmost derivations. LR grammars in fact, unlike LL and operator precedence ones, generate all DCFL.

6 Operator precedence languages

Operator precedence grammars (OPG) have been introduced by R. Floyd in his pioneering paper [26] with the goal of building efficient, deterministic, bottom-up parsers for programming languages. In doing so he was inspired by the hidden structure of arithmetic expressions which suggests to “give precedence” to, i.e, to execute first multiplicative operations w.r.t. the additive ones, as we illustrated through Example 7. Essentially, the goal of deterministic bottom-up parsing is to unambiguously decide when a complete rhs has been identified so that we can proceed with replacing it with the unique corresponding lhs with no risk to apply some roll-back if another possible reduction was the right one. Floyd achieved such a goal by suitably extending the notion of precedence between arithmetic operators to all grammar terminals, in such a way that a complete rhs is enclosed within a pair (yields-precedence, takes-precedence). OPG obtained a considerable success thanks to their simplicity and to the efficiency of the parsers obtained therefrom; incidentally, some independent studies also uncovered interesting algebraic properties ([16]) which have been exploited in the field of grammar inference ([17]). As we anticipated in the introduction, however, the study of these grammars has been dismissed essentially because of the advent of other classes, such as the LR ones, which can generate all DCFL; OPG instead do not have such power as we will see soon, although they are able to cover most syntactic features of normal programming languages, and parsers based on OPG are still in practical use (see, e.g., [29]).

Only recently we renewed our interest in this class of grammars and languages for two different reasons that are the object of this survey. On the one side in fact, OPL, despite being apparently not structured, since they require and have been motivated by parsing, have shown rather surprising relations with various families of structured languages; as a consequence it has been possible to extend to them all the language properties investigated in the previous sections. On the other side, OPG enable parallelizing their parsing in a natural and efficient way, unlike what happens with other parsers which are compelled to operate in a strict left-to-right fashion, thus obtaining considerable speed-up thanks to the wide availability of modern parallel HW architectures.

Therefore, after having resumed the basic definitions and properties of OPG and their languages, we show, in Section 6.1, that they considerably increase the generative power of structured languages but, unlike the whole class of DCFL, they still enjoy all algebraic and logic properties that we investigated for such smaller classes. In Section 6.2 we show how parallel parsing is much better supported by this class of grammars than by the presently used ones.

Definition 17

A grammar rule is in operator form if its rhs has no adjacent nonterminals; an operator grammar (OG) contains only such rules.

Notice that the grammars considered in Example 7 are OG. Furthermore any CF grammar can be recursively transformed into an equivalent OG one [30].

Next, we introduce the notion of precedence relations between elements of $\Sigma$: we say that $a$ is equal in precedence to $b$ iff the two characters occur consecutively, or at most with one nonterminal in between, in some rhs of the grammar; in fact, when evaluating the relations between terminal characters for OPG, nonterminals are inessential, or “transparent”. $a$ yields precedence to $b$ iff $a$ can occur at the immediate left of a subtree whose leftmost terminal character is $b$ (again whether there is a nonterminal character at the left of $b$ or not is inessential). Symmetrically, $a$ takes precedence over $b$ iff $a$ occurs as the rightmost terminal character of a subtree and $b$ is its following terminal character. These concepts are formally defined as follows.

Definition 18

For an OG $G$ and a nonterminal $A$, the left and right terminal sets are

[TABLE]

The grammar name $G$ will be omitted unless necessary to prevent confusion.

For an OG $G$, let $\alpha,\beta$ range over $(V_{N}\cup\Sigma)^{\ast}$ and $a,b\in\Sigma$. The three binary operator precedence (OP) relations are defined as follows:

• •

equal in precedence: $a\doteq b\iff$

$\exists A\to\alpha aBb\beta,B\in V_{N}\cup\{\varepsilon\}$,

• •

takes precedence: $a\gtrdot b\iff$

$\exists A\to\alpha Db\beta,D\in V_{N}\text{ and }a\in\mathcal{R}_{G}(D)$,

• •

yields precedence: $a\lessdot b\iff$

$\exists A\to\alpha aD\beta,D\in V_{N}\text{ and }b\in\mathcal{L}_{G}(D)$.

For an OG $G$, the operator precedence matrix (OPM) $M=OPM(G)$ is a $|\Sigma|\times|\Sigma|$ array that, for each ordered pair $(a,b)$, stores the set $M_{ab}$ of OP relations holding between $a$ and $b$.

For the grammar $GAE_{1}$ of Example  7 the left and right terminal sets of nonterminals $E$, $T$ and $F$ are, respectively:

$\mathcal{L}(E)=\{+,*,e\}$, $\mathcal{L}(T)=\{*,e\}$, $\mathcal{L}(F)=\{e\}$, $\mathcal{R}(E)=\{+,*,e\}$, $\mathcal{R}(T)=\{*,e\}$, and $\mathcal{R}(F)=\{e\}$.

Figure 13 displays the OPM associated with the grammar of $GAE_{1}$ of Example 7 where, for an ordered pair $(a,b)$, $a$ is one of the symbols shown in the first column of the matrix and $b$ one of those occurring in its first row. Notice that, unlike the usual arithmetic relations denoted by similar symbols, the above precedence relations do not enjoy any of the transitive, symmetric, reflexive properties.

Definition 19

An OG $G$ is an operator precedence or Floyd grammar (OPG) iff $M=OPM(G)$ is a conflict-free matrix, i.e., $\forall a,b$, $|M_{ab}|\leq 1$. An operator precedence language (OPL) is a language generated by an OPG.

An OPG is in Fischer normal form (FNF) iff it is invertible, i.e., no two rules have the same rhs, has no empty rules, i.e., rules whose rhs is $\varepsilon$, except possibly $S\to\varepsilon$, and no renaming rules, i.e, rules whose rhs is a single nonterminal, except possibly those whose lhs is $S$.

For every OPG an equivalent one in FNF can effectively be built [24, 30]. A FNF grammar (manually) derived from $GAE_{1}$ of Example 7 is $GAE_{FNF}$:

[TABLE]

We can now see how the precedence relations of an OPG can drive the deterministic parsing of its sentences: consider again the sentence $e+e*e$; add to its boundaries the conventional symbol $\#$ which implicitly yields precedence to any terminal character and to which every terminal character takes precedence, and evaluate the precedence relations between pairs of consecutive symbols; they are displayed below:

[TABLE]

The three occurrences of $e$ enclosed within the pair $(\lessdot,\gtrdot)$, are the rhs of production $F\to e$; thanks to the fact that the grammar is in FNF there is no doubt on its corresponding lhs; therefore they can be reduced to $F$. Notice that such a reduction could be applied in any order, possibly even in parallel; this feature will be exploited later in Section 6.2 but for the time being let us consider a traditional bottom-up parser proceeding rigorously left-to-right. Thus, the first reduction produces the string $F+e*e$; if we now recompute the precedence relations on the new string, due to the “transparency” of nonterminals, we obtain $\#\lessdot F+\lessdot\ e\gtrdot*\lessdot e\gtrdot\#.$

At this point the next rhs to be reduced is the second occurrence of $e$; after a third similar reduction the original string and the corresponding precedence relations, are reduced to $\#\lessdot F+\lessdot\ F*F\gtrdot\#$ where the (only) next rhs to be reduced in $F*F$.

Notice that there is no doubt on whether the first nonterminal $F$ should be part of a rhs beginning with $F$ or of another one ending with $F$, such as $\#\lessdot F+F\lessdot*\ F\gtrdot\#$. In fact, if the rhs to be reduced were just $*F$, its corresponding lhs would be a nonterminal adjacent to the $F$ at its left, thus contradicting the hypothesis of the grammar being an OG. At this point the bottom-up shift-reduce algorithm continues deterministically until the axiom is reached and a syntax-tree of the original sentence –represented by the mirror image of the rightmost derivation– is built.

This first introduction to OPG allows us to draw some early important properties thereof:

• •

In some sense OPL are input-driven even if they do not match exactly the definition of these languages: in fact, the decision of whether to apply a push operation (at the beginning of a rhs) or a shift one (while scanning a rhs) or a pop one (at the end of a rhs) depends only on terminal characters but not on a single one, as a look-ahead of one more terminal character is needed.161616As it happens in other deterministic parsers such as LL or LR ones (see Section 5).

• •

The above characteristic is also a major reason why OPL, though allowing for efficient deterministic parsing of various practical programming languages [29, 18, 26], do not cover the whole family DCFL; consider in fact the language $L=\{0a^{n}b^{n}\mid n\geq 0\}\cup\{1a^{n}b^{2n}\mid n\geq 0\}$: a DPDA can easily “remember” the first character in its state; then push all the $a$’s onto the stack and, when it reaches the $b$s decide whether to scan one or two $b$s for every $a$ depending on its memory of the first read character. On the contrary, it is clear that any grammar generating $L$ would necessarily exhibit some precedence conflict.171717The above $L$ is instead LL (see Section 5.1); on the contrary, the language $\{a^{n}b^{n}\mid n\geq 1\}\cup\{a^{n}c^{n}\mid n\geq 1\}$ is OPL but not LL; thus, OPL and LL languages are uncomparable.

• •

We like to consider OPL as structured languages in a generalized sense since, once the OPM is given, the structure of their sentences is immediately defined and univocally determinable as it happens. e.g., with VPL once the alphabet is partitioned into call, return, and internal alphabet. However, we would be reluctant to label OPL as visible since there is a major difference between parenthesis-like terminals which make the language sentence isomorphic to its syntax-tree, and precedence relations which help building the tree but are computed only during the parsing. Indeed, not all of them are immediately visible in the original sentence: e.g., in some cases such as in the above sentence $\#\lessdot F+\lessdot\ F*F\gtrdot\#$ precedence relations are not even matched so that they can be assimilated to real parentheses only when they mark a complete rhs. In summary, we would consider that OPL are structured (by the OPM) as well as PL (by explicit parentheses), VPL (by alphabet partitioning), and other families of languages; however, we would intuitively label them at most as “semi-visible” since making their structure visible requires some partial parsing, though not necessarily a complete recognition.

6.1 Algebraic and logic properties of operator precedence languages

OPL enjoy all algebraic and logic properties that have been illustrated in the previous sections for much less powerful families of structured languages.

As a first step we introduce the notion of a chain as a formal description of the intuitive concept of “semi-visible structure”. To illustrate the following definitions and properties we will continue to make use of examples inspired by arithmetic expressions but we will enrich such expressions with, possibly nested, explicit parentheses as the visible part of their structure. For instance the following grammar $GAE_{P}$ is a natural enrichment of previous $GAE_{1}$ to generate arithmetic expressions that involve parenthesized subexpressions (we use the slightly modified symbols ’$\llparenthesis$’ and ’$\rrparenthesis$’ to avoid overloading with other uses of parentheses).

[TABLE]

Definition 20 (Operator precedence alphabet)

An operator precedence (OP) alphabet is a pair $(\Sigma,M)$ where $\Sigma$ is an alphabet and $M$ is a conflict-free operator precedence matrix, i.e. a $|\Sigma\cup\{\#\}|^{2}$ array that associates at most one of the operator precedence relations: $\doteq$, $\lessdot$ or $\gtrdot$ with each ordered pair $(a,b)$. As stated above the delimiter $\#$ yields precedence to other terminals and other terminals take precedence over it (with the special case $\#\doteq\#$ for the final reduction of renaming rules.) Since such relations are stated once and forever, we do not explicitly display them in OPM figures.

If $M_{ab}=\{\circ\}$, with $\circ\in\{\lessdot,\doteq,\gtrdot\}$ ,we write $a\circ b$. For $u,v\in\Sigma^{*}$ we write $u\circ v$ if $u=xa$ and $v=by$ with $a\circ b$.

Definition 21 (Chains)

Let $(\Sigma,M)$ be a precedence alphabet.

• •

A simple chain is a word $a_{0}a_{1}a_{2}\dots$ $a_{n}a_{n+1}$, written as ${}^{a_{0}}\!\left[a_{1}a_{2}\dots a_{n}\right]\!{}^{a_{n+1}},$ such that: $a_{0},a_{n+1}\in\Sigma\cup\{\#\}$, $a_{i}\in\Sigma$ for every $i:1\leq i\leq n$, $M_{a_{0}a_{n+1}}\neq\emptyset$, and $a_{0}\lessdot a_{1}\doteq a_{2}\dots a_{n-1}\doteq a_{n}\gtrdot a_{n+1}$.

• •

A composed chain is a word $a_{0}x_{0}a_{1}x_{1}a_{2}\dots a_{n}x_{n}a_{n+1}$, with $x_{i}\in\Sigma^{*}$, where ${}^{a_{0}}[a_{1}a_{2}\dots$ $a_{n}]^{a_{n+1}}$ is a simple chain, and either $x_{i}=\varepsilon$ or ${}^{a_{i}}\!\left[x_{i}\right]\!{}^{a_{i+1}}$ is a chain (simple or composed), for every $i:0\leq i\leq n$. Such a composed chain will be written as ${}^{a_{0}}\!\left[x_{0}a_{1}x_{1}a_{2}\dots a_{n}x_{n}\right]\!{}^{a_{n+1}}$.

• •

The body of a chain ${}^{a}\!\left[x\right]\!{}^{b}$, simple or composed, is the word $x$.

Example 13

Figure 14 (a) depicts the $OPM(GAE_{P}$), whereas Figure 14 (b) represents the “semi-visible” structure induced by the operator precedence alphabet of grammar $GAE_{P}$ for the expression $\#e+e*\llparenthesis e+e\rrparenthesis\#$: ${}^{\#}\!\left[x_{0}+x_{1}\right]\!{}^{\#}$, ${}^{+}\!\left[y_{0}*y_{1}\right]\!{}^{\#}$, ${}^{*}\!\left[\llparenthesis w_{0}\rrparenthesis\right]\!{}^{\#}$, ${}^{\llparenthesis}\!\left[z_{0}+z_{1}\right]\!{}^{\rrparenthesis}$ are composed chains and ${}^{\#}\!\left[e\right]\!{}^{+}$, ${}^{+}\!\left[e\right]\!{}^{*}$, ${}^{\llparenthesis}\!\left[e\right]\!{}^{+}$, ${}^{+}\!\left[e\right]\!{}^{\rrparenthesis}$ are simple chains.

Definition 22 (Compatible word)

A word $w$ over $(\Sigma,M)$ is compatible with $M$ iff the two following conditions hold:

• •

For each pair of letters $c,d$, consecutive in $w$, $M_{cd}\neq\emptyset$;

• •

for each substring $x$ of $\#w\#$ such that $x=a_{0}x_{0}a_{1}x_{1}a_{2}\dots$ $a_{n}x_{n}a_{n+1}$, if $a_{0}\lessdot a_{1}\doteq a_{2}\dots a_{n-1}\doteq a_{n}\gtrdot a_{n+1}$ and, for every $0\leq i\leq n$, either $x_{i}=\varepsilon$ or ${}^{a_{i}}\!\left[x_{i}\right]\!{}^{a_{i+1}}$ is a chain (simple or composed), then $M_{a_{0}a_{n+1}}\neq\emptyset$.

For instance, the word $e+e*\llparenthesis e+e\rrparenthesis$ is compatible with the operator precedence alphabet of grammar $GAE_{P}$, whereas $e+e*\llparenthesis e+e\rrparenthesis\llparenthesis e+e\rrparenthesis$ is not.

Thus, given an OP alphabet, the set of possible chains over $\Sigma^{*}$ represents the universe of possible structured strings compatible with the given OPM.

6.1.1 Operator precedence automata

Despite abstract machines being the classical way to formalize recognition and parsing algorithms for any family of formal languages, and despite OPL having been invented just with the purpose of supporting deterministic parsing, their theoretical investigation has been abandoned before a family of automata completely equivalent to their generative grammars appeared in the literature. Only recently, when the numerous still unexplored benefits obtainable from this family appeared clear to us, we filled up this hole with the herewith resumed definition ([37]). The formal model presented in this paper is a “traditional” left-to-right automaton, although, as we already anticipated and will thoroughly exploit in the next Section 6.2 a distinguishing feature of OPL is that their parsing can be started in arbitrary positions with no harm nor loss of efficiency. This choice is explained by the need to extend and to compare results already reported for other language families. The original slightly more complicated version of this model was introduced in [38].

Definition 23 (Operator precedence automaton)

An operator precedence automaton (OPA) is a tuple $\mathcal{A}=(\Sigma,M,Q,I,F,\delta)$ where:

• •

$(\Sigma,M)$ is an operator precedence alphabet,

• •

$Q$ is a set of states (disjoint from $\Sigma$),

• •

$I\subseteq Q$ is the set of initial states,

• •

$F\subseteq Q$ is the set of final states,

• •

$\delta\subseteq Q\times(\Sigma\cup Q)\times Q$ is the transition relation, which is the union of three disjoint relations:

[TABLE]

An OPA is deterministic iff

• •

$I$ is a singleton

• •

All three components of $\delta$ are functions:

[TABLE]

We represent an OPA by a graph with $Q$ as the set of vertices and $\Sigma\cup Q$ as the set of edge labelings. The edges of the graph are denoted by different shapes of arrows to distinguish the three types of transitions: there is an edge from state $q$ to state $p$ labeled by $a\in\Sigma$ denoted by a dashed (respectively, normal) arrow iff $(q,a,p)\in\delta_{\text{shift}}$ (respectively, $\in\delta_{\text{push}}$) and there is an edge from state $q$ to state $p$ labeled by $r\in Q$ and denoted by a double arrow iff $(q,r,p)\in\delta_{\text{pop}}$.

To define the semantics of the automaton, we need some new notations.

We use letters $p,q,p_{i},q_{i},\dots$ to denote states in $Q$. Let $\Gamma$ be $\Sigma\times Q$ and let $\Gamma^{\prime}=\Gamma\cup\{Z_{0}\}$ be the stack alphabet; we denote symbols in $\Gamma^{\prime}$ as $[a,\ q]$ or $Z_{0}$. We set $\mathop{symbol}([a,\ q])=a$, $\mathop{symbol}(Z_{0})=\#$, and $\mathop{state}([a,\ q])=q$. Given a string $\Pi=\pi_{n}\dots\pi_{2}\pi_{1}Z_{0}$, with $\pi_{i}\in\Gamma$ , $n\geq 0$, we set $\mathop{symbol}(\Pi)=\mathop{symbol}(\pi_{n})$, including the particular case $\mathop{symbol}(Z_{0})=\#$.

As usual, a configuration of an OPA is a triple $c=\langle w,\ q,\ \Pi\rangle$, where $w\in\Sigma^{*}\#$, $q\in Q$, and $\Pi\in\Gamma^{*}Z_{0}$.

A computation or run of the automaton is a finite sequence of moves or transitions $c_{1}\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}c_{2}$; there are three kinds of moves, depending on the precedence relation between the symbol on top of the stack and the next symbol to read:

push move: if $\mathop{symbol}(\Pi)\lessdot\ a$ then $\langle ax,\ p,\ \Pi\rangle\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}\langle x,\ q,\ [a,\ p]\Pi\rangle$, with $(p,a,q)\in\delta_{\text{push}}$;

shift move: if $a\doteq b$ then $\langle bx,\ q,\ [a,\ p]\Pi\rangle\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}\langle x,\ r,\ [b,\ p]\Pi\rangle$, with $(q,b,r)\in\delta_{\text{shift}}$;

pop move: if $a\gtrdot b$ then $\langle bx,\ q,\ [a,\ p]\Pi\rangle\stackrel{{\scriptstyle{}}}{{\shortmid\joinrel\relbar\joinrel\relbar}}\langle bx,\ r,\ \Pi\rangle$, with $(q,p,r)\in\delta_{\text{pop}}$.

Observe that shift and pop moves are never performed when the stack contains only $Z_{0}$.

Push and shift moves update the current state of the automaton according to the transition relations $\delta_{\text{push}}$ and $\delta_{\text{shift}}$, respectively: push moves put a new element on top of the stack consisting of the input symbol together with the current state of the automaton, whereas shift moves update the top element of the stack by changing its input symbol only. Pop moves remove the element on top of the stack, and update the state of the automaton according to $\delta_{\text{pop}}$ on the basis of the pair of states consisting of the current state of the automaton and the state of the removed stack symbol; notice that in this moves the input symbol is used only to establish the $\gtrdot$ relation and it remains available for the following move.

The language accepted by the automaton is defined as:

[TABLE]

Example 14

The OPA depicted in Figure 15 accepts the language of arithmetic expressions generated by grammar $GAE_{P}$. The same figure also shows the syntax-tree of the sentence $e+e*\llparenthesis e+e\rrparenthesis$ and an accepting computation on this input.

Notice the similarity of the above definition of OPA with that of VPA (Definition 15) and with the normalized form for PDA given in Section 4.4.2.

Showing the equivalence between OPG and OPAs, though somewhat intuitive, requires to overtake a few non-trivial technical difficulties, mainly in the path from OPG to OPAs. Here we offer just an informal description of the rationale of the two constructions and an illustrating example; the full proof of the equivalence between OPG and OPA can be found in [37].

For convenience and with no loss of generality, let $G$ be an OPG with no empty rules, except possibly $S\to\varepsilon$, and no renaming rules, except possibly those whose lhs is $S$, an OPA $\mathcal{A}$ equivalent to $G$ is built in such a way that a successful computation thereof corresponds to building bottom-up the mirror image of a rightmost derivation of $G$: $\mathcal{A}$ performs a push transition when it reads the first terminal of a new rhs; it performs a shift transition when it reads a terminal symbol inside a rhs, i.e. a leaf with some left sibling leaf; it performs a pop transition when it completes the recognition of a rhs, then it guesses (nondeterministically, if there are several rules with the same rhs) the nonterminal at the lhs.

Each state of $\mathcal{A}$ contains two pieces of information: the first component represents the prefix of the rhs under construction, whereas the second component is used to recover the rhs previously under construction (see Figure 16) whenever all rhs’s nested below have been completed.

Without going into the details of the construction and the formal equivalence proof between $G$ and $\mathcal{A}$, we further illustrate the rationale of the construction through the following Example.

Example 15

Consider again grammar $GAE_{P}$. Figure 17 shows the first part of an accepting computation of the automaton derived therefrom. Consider, for instance, step 3 of the computation: at this point the automaton has already reduced (nondeterministically) the first $e$ to $E$ and has pushed the following $+$ onto the stack, paired with the state from which it was coming; thus, its new state is $\langle{E+},{\varepsilon}\rangle$; at step 6, instead, the state is $\langle{T*},{E+}\rangle$ because at this point the automaton has built the $T*$ part of the current rhs and remembers that the prefix of the suspended rhs is $E+$. Notice that the computation partially shown in Figure 17 is equal to that of Figure 15 up to a renaming of the states; in fact the shape of syntax-trees and consequently the sequence of push, shift and pop moves in OPL depends only on the OPM, not on the visited states.

The converse construction from OPAs to OPG is somewhat simpler; in essence, from a given OPA $\mathcal{A}=(\Sigma,M,Q,I,F,\delta)$ a grammar $G$ is built whose nonterminals are 4-tuples $(a,q,p,b)\in\Sigma\times Q\times Q\times\Sigma$, written as $\langle^{a}p,q{}^{b}\rangle$. $G$’s rules are built on the basis of $\mathcal{A}$’s chains as follows (particular cases are omitted for simplicity):

• •

for every simple chain ${}^{a_{0}}\!\left[a_{1}a_{2}\dots a_{n}\right]\!{}^{a_{n+1}}$, if there is a sequence of $\mathcal{A}$’s transitions that, while reading the body of the chain starting from $q_{0}$ leaves $\mathcal{A}$ in $q_{n+1}$, include the rule

[TABLE]

• •

for every composed chain ${}^{a_{0}}\!\left[x_{0}a_{1}x_{1}a_{2}\dots a_{n}x_{n}\right]\!{}^{a_{n+1}}$, add the rule

[TABLE]

if there is a sequence of $\mathcal{A}$’s transitions that, while reading the body of the chain starting from $q_{0}$ leaves $\mathcal{A}$ in $q_{n+1}$, and, for every $i=0,1,\dots,n$, $\Lambda_{i}=\varepsilon$ if $x_{i}=\varepsilon$, otherwise $\Lambda_{i}=\langle^{a_{i}}q_{i},q^{\prime}_{i}{}^{a_{i+1}}\rangle$ if $x_{i}\neq\varepsilon$ and there is a path leading from $q_{i}$ to $q^{\prime}_{i}$ when traversing $x_{i}$.

Since the size of $G$’s nonterminal alphabet is bounded, the above procedure eventually terminates when no new rules are added to $P$.181818The above claim can be easily proved if the OPM has no circularities in the $\doteq$ relation, since this implies an upper bound to the length of $P$’s rhs; in the (seldom) case where this hypothesis is not verified other ones can be exploited (see [37] for a more detailed analysis.)

We have seen that a fundamental issue to state the properties of most abstract machines is their determinizability: in the cases examined so far we have realized that the positive basic result holding for RL extends to the various versions of structured CFL, though at the expenses of more intricate constructions and size complexity of the deterministic versions obtained from the nondeterministic ones, but not to the general CF family. Having OPL been born just with the motivation of supporting deterministic parsing, and being they structured as well, it is not surprising to find that for any nondeterministic OPA with $s$ states an equivalent deterministic one can be built with $2^{O(s^{2})}$ states, as it happens for the analogous construction for VPL: in [37] besides giving a detailed construction for the above result, it is also noticed that the construction of an OPA from an OPG is such that, if the OPG is in FNF, then the obtained automaton is already deterministic since the grammar has no repeated rhs. As a consequence, producing a deterministic OPA from an OPG by first putting the OPG into FNF produces an automaton of an exponentially smaller size than the other way around.

6.1.2 Operator precedence vs other structured languages

A distinguishing feature of OPL is that, on the one side they have been defined to support deterministic parsing, i.e., the construction of the syntax-tree of any sentence which is not immediately visible in the sentence itself but, on the other side, they can still be considered as structured in the sense that their syntax-trees are univocally determined once an OPM is fixed, as it happens when we enclose grammar’s rhs within parentheses or we split the terminal alphabet into $\Sigma_{c}\cup\Sigma_{r}\cup\Sigma_{i}$. It is therefore natural to compare their generative power with that of other structured languages.

On this respect, the main result of this section is that OPL strictly include VPL, which in turn strictly include parenthesis languages and the languages generated by balanced grammars (discussed in Section 4.4.1).

This result was originally proved in [15]. To give an intuitive explanation of this claim consider the following remarks:

• •

Sequences $\in\Sigma_{i}^{*}$ can be assimilated to regular “sublanguages” with a linear structure; if we conventionally assign to them a left-linear structure, this can be obtained through an OPM where every character, but those in $\Sigma_{c}$, takes precedence over all elements in $\Sigma_{i}$; by stating instead that all elements of $\Sigma_{c}$ yield precedence to the elements in $\Sigma_{i}$ we obtain that after every call the OPA pushes and pops all subsequent elements of $\Sigma_{i}$, as an FSA would do without using the stack.

• •

All elements of $\Sigma_{r}$ produce a pop from the stack of the corresponding element of $\Sigma_{c}$, if any; thus we obtain the same effect by letting them take precedence over all other terminal characters.

• •

A VPA performs a push onto its stack when (and only when) it reads an element of $\Sigma_{c}$, whereas an OPA pushes the elements to which some other element yields precedence; thus, it is natural to state that whenever on top of the stack there is a call symbol, possibly after having visited a subtree whose result is stored as the state component in the top of the stack together with the terminal symbol, such a symbol yields precedence to the following call (roughly, open parentheses yield precedence to other open parentheses and closed parentheses take precedence over other closed parentheses).

• •

Once the whole subsequence embraced by two matching call and return is scanned and possibly reduced, the two terminals are faced, with the possible occurrence of an irrelevant nonterminal in between, and therefore the call must be equal in precedence to the return.

• •

Finally, the usual convention that $\#$ yields precedence to everything and everything takes precedence over $\#$ enables the managing of possible unmatched returns at the beginning of the sentence and unmatched calls at its end.

In summary, for every VPA $\mathcal{A}$ with a given partitioned alphabet $\Sigma$, an OPM such as the one displayed in Figure 18 and an OPA $\mathcal{A}^{\prime}$ defined thereon can be built such that $L(\mathcal{A}^{\prime})=L(\mathcal{A})$.

In [15] it is also shown the converse property, i.e., that whenever an OPM is such that the terminal alphabet can be partitioned into three disjoint sets $\Sigma_{c}$, $\Sigma_{r}$,$\Sigma_{i}$ such that the OPM has the shape of Figure 18, any OPL defined on such an OPM is also a VPL. Strict inclusion of VPL within OPL follows form the fact that VPL are real-time whereas OPL include also non-real-time languages (see Section 5); there are also real-time OPL191919When we say that an OPL $L$ is real-time we mean, as usual, that there is an abstract machine, in particular a DPDA, recognizing it that performs exactly $|x|$ moves for every input string $x$; this is not to say that an OPA accepting $L$ operates in real-time, since OPA’s pop moves are defined as $\varepsilon$ moves. such as

[TABLE]

that are not VPL. In fact, strings of type $b^{n}c^{n}$ impose that $b$ is a call and $c$ a return; for similar reasons, $f$ must be a call and $d$ a return. Strings of type $e^{n}(fb)^{n}$ impose that at least one of $b$ and $f$ must be a return, a contradiction for a VP alphabet. In conclusion we have the following result:

Theorem 6.1

VPL are the subfamily of OPL whose OPM is a partitioned matrix, i.e., a matrix whose structure is depicted in Figure 18.

As a corollary OPL also strictly include balanced languages and parenthesis languages. OPL are instead uncomparable with HRDPDL: we have already seen that the language $L_{1}=\{a^{n}ba^{n}\}$ is an HRDPDL but it is neither a VPL nor an OPL since it necessarily requires a conflict $a\lessdot a$ and $a\gtrdot a$; conversely, the previous language $L_{2}=\{a^{m}b^{n}c^{n}d^{m}\mid m,n\geq 1\}\cup\{a^{m}b^{+}ed^{m}\mid m\geq 1\}$ can be recognized by an OPA but by no HRDPDA (see Section 5).

The increased power of OPL over other structured languages goes far beyond the mathematical containment properties and opens several application scenarios that are hardly accessible by “traditional” structured languages. The field of programming languages was the original motivation and source of inspiration for the introduction of OPL; arithmetic expressions, used throughout this paper as running examples, are just a small but meaningful subset of such languages and we have emphasized from the beginning that their partially hidden structure cannot be “forced” to the linearity of RL, nor can always be made explicit by the insertion of parentheses.

VPL too have been presented as an extension of parenthesis languages with the motivation that not always calls, e.g. procedure calls, can be matched by corresponding returns: a sudden closure, e.g. due to an exception or an interrupt or an unexpected end may leave an open chain of suspended calls. Such a situation, however, may need a generalization that cannot be formalized by the VPL formalism, since in VPL unmatched calls can occur only at the end of a string.202020Recently, such a weakness of VPL has been acknowledged in [3] where the authors introduced colored VPL to cope with the above problem; the extended family, however, still does not reach the power of OPL ([3]). Imagine, for instance, that the occurrence of an interrupt while serving a chain of calls imposes to abort the chain to serve immediately the interrupt; after serving the interrupt, however, the normal system behavior may be resumed with new calls and corresponding returns even if some previous calls have been lost due to the need to serve the interrupt with high priority. Various, more or less sophisticated, policies can be designed to manage such systems and can be adequately formalized as OPL. The next example describes a first simple case of this type; other more sophisticated examples of the same type and further ones inspired by different application fields can be found in [37].

Example 16 (Managing interrupts)

Consider a software system that is designed to serve requests issued by different users but subject to interrupts. Precisely, assume that the system manages “normal operations” according to a traditional LIFO policy, and may receive and serve some interrupts denoted as $int$.

We model its behavior by introducing an alphabet with two pairs of calls and returns: $call$ and $ret$ denote the call to, and return from, a normal procedure; $int$, and serve denote the occurrence of an interrupt and its serving, respectively. The occurrence of an interrupt provokes discarding possible pending $call$s not already matched by corresponding $ret$s; furthermore when an interrupt is pending, i.e., not yet served, calls to normal procedures are not accepted and consequently corresponding returns cannot occur; interrupts however, can accumulate and are served themselves along a LIFO policy. Once all pending interrupts have been served the system can accept new $call$s and manage them normally.

Figure 19 (a) shows an OPM that assigns to sequences on the above alphabet a structure compatible with the described priorities. Then, a suitable OPA can specify further constraints on such sequences; for instance the automaton of Figure 19 (b) restricts the set of sequences compatible with the matrix by imposing that all $int$ are eventually served and the computation ends with no pending $call$s; furthermore unmatched serve and $ret$ are forbidden. E.g., the string $call.call.ret.int.serve.call.ret$ is accepted through the sequence of states $q_{0}\stackrel{{\scriptstyle call}}{{\longrightarrow}}q_{1}\stackrel{{\scriptstyle call}}{{\longrightarrow}}q_{1}\ext@arrow 0359$     $\hskip 11.38109pt\relbar$ →${ret}{q_{1}}\stackrel{{\scriptstyle q_{1}}}{{\Longrightarrow}}q_{1}\stackrel{{\scriptstyle q_{0}}}{{\Longrightarrow}}q_{0}\stackrel{{\scriptstyle int}}{{\longrightarrow}}q_{2}\ext@arrow 0359$     $\hskip 11.38109pt\relbar$ →${serve}{q_{2}}\stackrel{{\scriptstyle q_{0}}}{{\Longrightarrow}}q_{0}\stackrel{{\scriptstyle call}}{{\longrightarrow}}{q_{1}}\ext@arrow 0359$     $\hskip 11.38109pt\relbar$ →${ret}q_{1}\stackrel{{\scriptstyle q_{0}}}{{\Longrightarrow}}q_{0}$; on the contrary, a sequence beginning with $call.serve$ would not be accepted.

6.1.3 Closure and decidability properties

Structured languages with compatible structures often enjoy many closure properties typical of RL; noticeably, families of structured languages are often Boolean algebras. The intuitive notion of compatible structure is formally defined for each family of structured languages; for instance two VPL have compatible structure iff their tri-partition of $\Sigma$ is the same; two height-deterministic PDA languages (HPDL) have compatible structure if they are synchronized. In the case of OPL, the notion of structural compatibility is naturally formalized through the OPM.

Definition 24

Given two OPM $M_{1}$ and $M_{2}$, we define set inclusion and union:

[TABLE]

[TABLE]

Two matrices are compatible if their union is conflict-free. A matrix is total (or complete) if it contains no empty cell.

The following theorem has been proved originally in [16] by exploiting some standard forms of OPG that have been applied to grammar inference problems [17].

Theorem 6.2

For any conflict-free OPM $M$ the OPL whose OPM is contained in $M$ are a Boolean algebra. In particular, if $M$ is complete, the top language of its associated algebra is $\Sigma^{*}$ with the structure defined by $M$.

Notice however, that the same result could be proved in a simpler and fairly standard way by exploiting OPA and their traditional composition rules (which pass through determinization to achieve closure under complement). As usual in such cases, thanks to the decidablity of the emptiness problem for general CFL, a major consequence of Boolean closures is the following corollary.

Corollary 1

The inclusion problem between OPL with compatible OPM is decidable.

Closure under concatenation and Kleene ∗ has been proved more recently in [15]; whereas such closures are normally easily proved or disproved for many families of languages, the technicalities to achieve this result are not trivial for OPL; however we do not go into their description since closure or non-closure w.r.t. these operations is not of major interest in this paper.

6.1.4 Logic characterization

Achieving a logic characterization of OPL has probably been the most difficult job in the recent revisit of these languages and posed new challenges w.r.t. the analogous path previously followed for RL and then for CFL [35] and VPL [5]. In fact we have seen that moving from linear languages such as RL to tree-shaped ones such as CFL led to the introduction of the relation $M$ between the positions of leftmost and rightmost leaves of any subtree (generated by a grammar in DGNF); the obtained characterization in terms of first-order formulas existentially quantified w.r.t. the $M$ relation (which is a representation of the sentence structure) however, was suffering from the lack of closure under complementation of CFL [35]; the same relation instead proved more effective for VPL thanks to the fact that they are structured and enjoy all necessary closures.

To the best of our knowledge, however, all previous characterizations of formal languages in terms of logics that refer to string positions (for instance, there is significant literature on the characterization of various subclasses of RL in terms of first-order or temporal logics, see, e.g., [23]) have been given for real-time languages. This feature is the key that allows, in the exploitation of MSO logic, to state a natural correspondence between automaton’s state $q_{i}$ and second-order variable $\bm{X}_{i}$ in such a way that the value of $\bm{X}_{i}$ is the set of positions where the state visited by the automaton is $q_{i}$.

OPL instead include also DCFL that are not real-time and, as a consequence, there are positions where the recognizing OPA traverses different configurations with different states. As a further consequence, the $M$ relation adopted for CFL and VPL is not anymore a one-to-one relation since the same position may be the position of the left/rightmost leaf of several subtrees of the whole syntax-tree; this makes formulas such as the key ones given in Section 4.3.1 meaningless.

The following key ideas helped overtaking the above difficulties:

• •

A new relation $\mu$ replaces the original $M$ adopted in [35] and [5]; $\mu$ is based on the look-ahead-look-back mechanism which drives the (generalized) input-driven parsing of OPL based on precedence relations: thus, whereas in $M(\bm{x},\bm{y})$ $\bm{x}$, $\bm{y}$ denote the positions of the extreme leaves of a subtree, in $\mu(\bm{x},\bm{y})$ they denote the position of the context of the same subtree, i.e., respectively, of the character that yields precedence to the subtree’s leftmost leaf, and of the one over which the subtree’s rightmost leaf takes precedence. The new $\mu$ relation is not one-to-one as well, but, unlike the original $M$, its parameters $\bm{x}$, $\bm{y}$ are not “consumed” by a pop transition of the automaton and remain available to be used in further automaton transitions of any type. In other words, $\mu$ holds between the positions [math] and $n+1$ of every chain (see Definition 21). For instance, Figure 20 displays the $\mu$ relation, graphically denoted by arrows, holding for the sentence $e+e*\llparenthesis e+e\rrparenthesis$ generated by grammar $GAE_{P}$: we have $\mu(0,2)$, $\mu(2,4)$, $\mu(5,7)$, $\mu(7,9)$, $\mu(5,9)$, $\mu(4,10)$, $\mu(2,10)$, and $\mu(0,10)$. Such pairs correspond to contexts where a reduce operation is executed during the parsing of the string (they are listed according to their execution order).

In general $\mu(\textbf{{x}},\textbf{{y}})$ implies $\textbf{{y}}>\textbf{{x}}+1$, and a position x may be in relation $\mu$ with more than one position and vice versa. Moreover, if $w$ is compatible with $M$, then $\mu(0,|w|+1)$.

Example 17

The following sentence of the MSO logic enriched with the $\mu$ relation defines, within the universe of strings compatible with the OPM of Figure 14(a), the language where parentheses are used only when they are needed (i.e. to give precedence to $+$ over $*$).

[TABLE]

• •

Since in every position there may be several states held by the automaton while visiting that position, instead of associating just one second-order variable to each state of the automaton we define three different sets of second-order variables, namely, ${\textbf{{A}}}_{0},{\textbf{{A}}}_{1},\ldots,{\textbf{{A}}}_{N}$, ${\textbf{{B}}}_{0},{\textbf{{B}}}_{1},\ldots,{\textbf{{B}}}_{N}$ and ${\textbf{{C}}}_{0},{\textbf{{C}}}_{1},\ldots,{\textbf{{C}}}_{N}$. Set ${\textbf{{A}}}_{i}$ contains those positions of word $w$ where state $q_{i}$ may be assumed after a shift or push transition, i.e. after a transition that “consumes” an input symbol. Sets ${\textbf{{B}}}_{i}$ and ${\textbf{{C}}}_{i}$ encode a pop transition concluding the reading of the body of a chain ${}^{a}[w_{0}a_{1}w_{1}\dots$ $a_{l}w_{l}]^{a_{l+1}}$ in a state $q_{i}$: set ${\textbf{{B}}}_{i}$ contains the position of symbol $a$ that precedes the corresponding push, whereas ${\textbf{{C}}}_{i}$ contains the position of $a_{l}$, which is the symbol on top of the stack when the automaton performs the pop move relative to the whole chain.

Figure 21 presents such sets for the example automaton of Figure 15, with the same input as in Figure 20. Notice that each position, except the last one, belongs to exactly one ${\textbf{{A}}}_{i}$, whereas it may belong to several ${\textbf{{B}}}_{i}$ and at most one ${\textbf{{C}}}_{i}$.

We can now outline how an OPA can be derived from an MSO logic formula making use of the new symbol $\mu$ and conversely.

From MSO formula to OPA

The construction from MSO logic to OPA essentially follows the lines given originally by Büchi, and reported in Section 2.2: once the original alphabet has been enriched and the formula has been put in the canonical form in the same way as described in Section 2.2, we only need to define a suitable automaton fragment to be associated with the new atomic formula $\mu(\bm{X_{i}},\bm{X_{j}})$; then, the construction of the global automaton corresponding to the global formula proceeds in the usual inductive way.

Figure 22 represents the OPA for atomic formula $\psi=\mu(\textbf{{X}},\textbf{{Y}})$. As before, labels are triples belonging to $\Sigma\times\{0,1\}^{2}$, where the first component encodes a character $a\in\Sigma$, the second the positions belonging to X (with 1) or not (with 0), while the third component is for Y. The symbol $\circ$ is used as a shortcut for any value in $\Sigma$ compatible with the OPM, so that the resulting automaton is deterministic.

The semantics of $\mu$ requires for $\mu(\textbf{{X}},\textbf{{Y}})$ that there must be a chain ${}^{a}\!\left[w_{2}\right]\!{}^{b}$ in the input word, where $a$ is the symbol at the only position in X, and $b$ is the symbol at the only position in Y. By definition of chain, this means that $a$ must be read, hence in the position represented by X the automaton performs either a push or a shift move (see Figure 22, from state $q_{0}$ to $q_{1}$), as pop moves do not consume input. After that, the automaton must read $w_{2}$. In order to process the chain ${}^{a}[w_{2}]^{b}$, reading $w_{2}$ must start with a push move (from state $q_{1}$ to state $q_{2}$), and it must end with one or more pop moves, before reading $b$ (i.e. the only position in Y – going from state $q_{3}$ to $q_{F}$).

This means that the automaton, after a generic sequence of moves corresponding to visiting an irrelevant (for $\mu(\textbf{{X}},\textbf{{Y}})$) portion of the syntax-tree, when reading the symbol at position X performs either a push or a shift move, depending on whether X is the position of a leftmost leaf of the tree or not. Then it visits the subsequent subtree ending with a pop labeled $q_{1}$; at this point, if it reads the symbol at position Y, it accepts anything else that follows the examined fragment.

It is interesting to compare the diagram of Figure 22 with those of Figure 6 (c) and of Figure 10: the first one, referring to RL, uses two consecutive moves; the second one, referring to VPL, may perform an unbounded number of internal moves and of matching call-return pairs between the call-return pair in positions $\bm{x}$,$\bm{y}$; the OPA does the same as the VPA but needs a pair of extra moves to take into account the look-ahead-look-back implied by precedence relations.

From the OPA $\mathcal{A}$ to the MSO formula

In this case the overall structure of the logic formula is the same as in the previous cases for RL and VPL, i.e., an existential quantification over second-order variables, which represent states through sets of positions within the string, of a global formula that formalizes a) the constraints imposed by automaton’s transitions, b) the fact that in position [math] the automaton must be in an initial state, and c) that at the end of the string it must be in an accepting state. The complete formalization of the $\delta$ transition relation as a collection of formulas relating the various variables $\bm{A_{i}},\bm{B_{i}},\bm{C_{i}}$, however, is much more involved than in the two previous cases. Here we only provide a few meaningful examples of such formulas, just to give the essential ideas of how they have been built; their complete set can be found in [37] together with the equivalence proof. Without loss of generality we assume that the OPA is deterministic.

Preliminarily, we introduce some notation to make the following formulas more understandable:

• •

When considering a chain ${}^{a}\!\left[w\right]\!{}^{b}$ we assume $w=w_{0}a_{1}w_{1}$ $\dots$ $a_{\ell}w_{\ell}$, with ${}^{a}\!\left[a_{1}a_{2}\dots a_{\ell}\right]\!{}^{b}$ being a simple chain (any $w_{g}$ may be empty). We denote by $s_{g}$ the position of symbol $a_{g}$, for $g=1,2,\ldots,\ell$ and set $a_{0}=a$, $s_{0}=0$, $a_{\ell+1}=b$, and $s_{\ell+1}=|w|+1$.

• •

$\bm{x}\lessdot\bm{y}$ states that the symbol in position $\bm{x}$ yields precedence to the one in position $\bm{y}$ and similarly for the other precedence relations

• •

The fundamental abbreviation

[TABLE]

is satisfied, for every chain ${}^{a}\!\left[w\right]\!{}^{b}$ embraced within positions x and y by a (unique, maximal) z such that $\mu(\textbf{{x}},\textbf{{z}})$, if $w_{0}\not=\varepsilon$, $\textbf{{z}}=\textbf{{x}}+1$ if instead $w_{0}=\varepsilon$; symmetrically for y and v. In particular, if $w$ is the body of a simple chain, then $\mu(0,\ell+1)$ and $\operatorname{Tree}(0,1,\ell,\ell+1)$ are satisfied; if it is the body of a composed chain, then $\mu(0,|w|+1)$ and $\operatorname{Tree}(0,s_{1},s_{\ell},s_{\ell+1})$ are satisfied. If $w_{0}=\varepsilon$ then $s_{1}=1$, and if $w_{\ell}=\varepsilon$ then $s_{\ell}=|w|$. In the example of Figure 20 relations $\operatorname{Tree}(2,3,3,4)$, $\operatorname{Tree}(2,4,4,10)$, $\operatorname{Tree}(4,5,9,10)$, $\operatorname{Tree}(5,7,7,9)$ are satisfied, among others.

• •

The shortcut $Q_{i}(\textbf{{x}},\textbf{{y}})$ is used to represent that $\mathcal{A}$ is in state $q_{i}$ when at position x and the next position to read, possibly after scanning a chain, is y. Since the automaton is not real time, we must distinguish between push and shift moves (case $\operatorname{Succ}_{i}(\textbf{{x}},\textbf{{y}})$), and pop moves (case $\operatorname{Next}_{i}(\textbf{{x}},\textbf{{y}})$).

[TABLE]

E.g., with reference to Figures 20 and 21, $\operatorname{Succ}_{2}(5,6)$, $\operatorname{Next}_{3}(5,9)$, and $\operatorname{Next}_{3}(5,7)$ hold.

We can now show a meaningful sample of the various formulas that code the automaton’s transition relation.

• •

The following formula states that if $\mathcal{A}$ is in position $\bm{x}$ and state $q_{i}$ and performs a push transition by reading the character in position $\bm{y}$, it goes to state $q_{k}$ according to the transition relation $\delta$.

[TABLE]

Notice that the original formula given in Section 2.2 for RL can be seen as a particular case of the above one.

• •

Conversely, if $\mathcal{A}$ is in state $q_{k}$ after a push starting from position $\bm{x}$ and reading character $c$, in that position it must have been in a state $q_{i}$ such that $\delta(q_{i},c)=q_{k}$:

[TABLE]

• •

The formulas coding the shift transitions are similar to the previous ones and therefore omitted.

• •

To define $\varphi_{\delta_{\text{pop}}}$ we introduce the shortcut $\operatorname{Tree}_{i,j}(\textbf{{x}},\textbf{{z}},\textbf{{v}},\textbf{{y}})$, which represents the fact that $\mathcal{A}$ is ready to perform a pop transition from state $q_{i}$ having on top of the stack state $q_{j}$; such pop transition corresponds to the reduction of the portion of string between positions x and y (excluded).

[TABLE]

Formula $\varphi_{\delta_{\text{pop}}}$ is thus defined as the conjunction of three formulas. As before, the forward (abbreviated with the subscript $fw$) formula gives the sufficient condition for two positions to be in the sets $\textbf{{B}}_{k}$ and $\textbf{{C}}_{k}$, when performing a pop move, and the backward formulas state symmetric necessary conditions.

[TABLE]

[TABLE]

[TABLE]

6.2 Local parsability for parallel parsers

Let us now go back to the original motivation that inspired R. Floyd when he invented the OPG family, namely supporting efficient, deterministic parsing. In the introductory part of this section we noticed that the mechanism of precedence relations isolates grammar’s rhs from their context so that they can be reduced to the corresponding lhs independently from each other. This fact guarantees that, in whichever order such reductions are applied, at the end a complete grammar derivation will be built; such a derivation corresponds to a visit of the syntax-tree, not necessarily leftmost or rightmost, and its construction has no risk of applying any back-track as it happens instead in nondeterministic parsing. We call this property local parsability property, which intuitively can be defined as the possibility of applying deterministically a bottom-up, shift-reduce parsing algorithm by inspecting only an a priori bounded portion of any string containing a rhs. Various formal definitions of this concept have been given in the literature, the first one probably being the one proposed by Floyd himself in [27]; a fairly general definition of local parsability and a proof that OPG enjoy it can be found in [6].

Local parsability, however, has the drawback that it loses chances of deterministic parsing when the information on how to proceed with the parsing is arbitrarily far from the current position of the parser. We therefore have a trade-off between the size of the family of recognizable languages, which in the case of LR grammars is the whole DCFL class (see Section 5.2), and the constraint of proceeding rigorously left-to-right for the parser. So far this trade-off has been normally solved in favor of the generality in the absence of serious counterparts in favor of the other option. We argue however, that the massive advent of parallel processing, even in the case of small architectures such as those of tablets and smartphones, could dramatically change the present state of affairs. On the one side parallelizing parsers such as LL or LR ones requires reintroducing a kind of nondeterministic guess on the state of the parser in a given position, which in most cases voids the benefits of exploiting parallel processors (see [6] for an analysis of previous literature on various attempts to develop parallel parsers); on the contrary, OPL are from the beginning oriented toward parallel analysis whereas their previous use in compilation shows that they can be applied to a wide variety of practical languages, and further more as suggested by other examples given here and in [37].

Next we show how we exploited the local parsability property of OPG to realize a complete and general parallel parser for these grammars. A first consequence of the basic property is the following statement.

Statement 2

For every substring $a\delta b$ of $\gamma a\delta b\eta$ $\in V^{*}$ derivable from $S$, there exists a unique string $\alpha$, called the irreducible string, deriving $\delta$ such that $S\stackrel{{\scriptstyle{*}}}{{\Rightarrow}}\gamma a\alpha b\eta\stackrel{{\scriptstyle{*}}}{{\Rightarrow}}\gamma a\delta b\eta$, and the precedence relations between the consecutive terminals of $a\alpha b$ do not contain the pattern $\lessdot\left(\doteq\right)^{*}\gtrdot$. Therefore there exists a factorization $a\alpha b=\zeta\theta$ into two possibly empty factors such that the left factor does not contain $\lessdot$ and the right factor does not contain $\gtrdot$.

On the basis of the above statement, the original parsing algorithm is generalized in such a way that it may receive as input a portion of a string, not necessarily enclosed within the delimiters $\#$, and produces as output two stacks, one that stores the substring $\zeta$ and one that stores $\theta$ as defined in Statement 2, and a partial derivation of $a\alpha b=\zeta\theta\stackrel{{\scriptstyle{*}}}{{\Rightarrow}}a\,\delta\,b\,$. For instance, with reference to the grammar $GAE_{FNF}$, which is a FNF of $GAE_{1}$, if we supply to such a generalized parser the partial string $+e*e*e+e$ we obtain $\zeta=+T+$, $\theta=e$ and $+T+\stackrel{{\scriptstyle{*}}}{{\Rightarrow}}+e*e*e+$ since $+\gtrdot+$ and $+\lessdot e$. We call $\mathcal{S}^{L}$ and $\mathcal{S}^{R}$ the two stacks produced by this partial parsing.

At this point it is fairly easy to let several such generalized parsers work in parallel:

• •

Suppose to use $k$ parallel processors, also called workers; then split the input into $k$ chunks; given that an OP parser needs a look-ahead-look-back of one character, the chunks must overlap by one character for each consecutive pair. For instance, the global input string $\#e+e+e*e*e+*e+e\#$, with $k=3$ could be split as shown below:

[TABLE]

where the unmarked symbols $+$ and $e$ are shared by the adjacent segments. The splitting can be applied arbitrarily, although in practice it seems natural to use segments of approximately equal length and/or to apply some heuristic criterion (for instance, if possible one should avoid particular cases where only $\lessdot$ or $\gtrdot$ relations occur in a single chunk so that the parser could not produce any reduction).

• •

Each chunk is submitted to one of the workers which produces a partial result in the form of the pair ($\mathcal{S}^{L},\mathcal{S}^{R}$) (notice that some of those partial stacks may be empty).

• •

The partial results are concatenated into a new string $\in V^{*}$ and the process is iterated until a short enough single chunk is processed and the original input string is accepted or rejected. In practice it may be convenient to build the new segments to be supplied to the workers by facing an $\mathcal{S}^{R}$ with the following $\mathcal{S}^{L}$ so that the likelihood of applying many new reductions in the next pass is increased. For instance the $\zeta=+T+$ part produced by the parsing of the second chunk could be paired with the $\mathcal{S}^{R}=\#E+$ part obtained from the parsing of the first chunk, producing the string $\#E+T+$ to be supplied to a worker for the new iteration. Some experience shows that quite often optimal results in terms of speed-up are obtained with 2, at most 3 passes of parallel parsing.

[6] describes in detail PAPAGENO, a PArallel PArser GENeratOr built on the basis of the above algorithmic schema. It has been applied to several real-life data definition, or programming, languages including JSON, XML, and Lua and different HW architectures. The paper also reports on the experimental results in terms of the obtained speed-up compared with standard sequential parser generators as Bison. PAPAGENO is freely available at https://github.com/PAPAGENO-devels/papageno under GNU license.

7 Concluding remarks

The main goal of this paper has been to show that an old-fashioned and almost abandoned family of formal languages indeed offers considerable new benefits in apparently unrelated application fields of high interest in modern applications, i.e., automatic property verification and parallelization. In the first field OPL significantly extend the generative power of the successful class of VPL still maintaining all of their properties: to the best of our knowledge, OPL are the largest class of languages closed under all major language operations and provided with a complete classification in terms of MSO logic.

Various other results about this class of languages have been obtained or are under development, which have not been included in this paper for length limits. We mention here just the most relevant or promising ones with appropriate references for further reading.

• •

The theory of OPL for languages of finite length strings has been extended in [37] to so called $\omega$-languages, i.e. languages of infinite length strings: the obtained results perfectly parallel those originally obtained by Büchi and others for RL and subsequently extended to other families, noticeably VPL [5]; in particular, $\omega$-OPL lose determinizability in case of Büchi acceptance criterion as it happens for RL and VPL.

• •

Some investigation is going on to devise more tractable automatic verification algorithms than those allowed by the full characterization of these languages in terms of MSO logic. On this respect, the state of the art is admittedly still far from the success obtained with model checking exploiting various forms of temporal logics for FSA and several extensions thereof such as, e.g., timed automata [2]. Some interesting preliminary results have been obtained for VPL by [1] and for a subclass of OPL in [36].

• •

The local parsability property can be exploited not only to build parallel parsers but also to make them incremental, in such a way that when a large piece of text or software code is locally modified its analysis should not be redone from scratch but only the affected part of the syntax-tree is “plugged” in the original one with considerable saving; furthermore incremental and/or parallel parsing can be naturally paired with incremental and/or parallel semantic processing, e.g. realized through the classic schema of attribute evaluation [34, 14]. Some early results on incremental software verification by exploiting the locality property are reported in [8]. We also mention ongoing work on parallel XML-based query processing.

• •

A seminal paper by Schützemberger [43] introduced the concept of weighted languages as RL where each word is given a weight in a given algebra which may represent some “attribute” of the word such as importance or probability. Later, these weighted languages too have been characterized in terms of MSO logic [20] and such a characterization has also been extended to VPL [21] and $\omega$-VPL [19]. Our two research groups are both confident that those results can also be extended to weighted OPL and are starting a joint investigation on this promising approach.

*Acknowledgments. We acknowledge the contribution to our research given by Alessandro Barenghi, Stefano Crespi Reghizzi, Violetta Lonati, Angelo Morzenti, and Federica Panella.