Cyclic Compilation Algorithm for Operator Precedence Grammars

• Cyclic Compilation Algorithm is a parallel parsing technique built on cyclic operator precedence grammars that remove acyclicity restrictions while preserving local parsability.
• The method partitions input into chunks using specific precedence relations, allowing independent local parsing and conflict-free merging of parsed segments.
• Its five-stage process—involving matrix construction, input partitioning, parallel parsing, conflict resolution, and merging—ensures scalable, efficient compilation.

The cyclic compilation algorithm is a parallel parsing and compilation method built on cyclic operator precedence grammars, an enriched form of operator precedence grammars in which the traditional acyclicity restriction on the equality precedence relation $\doteq$ is removed while conflict-freeness is preserved. In this setting, operator precedence languages retain the local parsability property, so a code fragment enclosed within suitable boundary markers can be compiled with no knowledge of its external context, but cyclic equality also permits sentences with flat unbounded substructures and unranked syntax trees that can be naturally partitioned into chunks suitable for parallel parsing (Chiari et al., 2023).

1. Formal framework and precedence structure

Let $\Sigma$ be a finite terminal alphabet and $N$ a finite nonterminal set, with $V=\Sigma\cup N$. An operator grammar (O-grammar) is a context-free grammar $G=(\Sigma,N,P,S)$ whose productions $A\to\alpha$ satisfy the operator form: in every right-hand side $\alpha\in V^*$, at least one terminal symbol is interposed between any two consecutive nonterminals. Renaming rules and $\varepsilon$-rules are forbidden, except possibly one $\varepsilon$-rule whose LHS is a start symbol not appearing on any RHS (Chiari et al., 2023).

The left and right terminal sets for $A\in N$ are

$\Sigma$0

$\Sigma$1

Over $\Sigma$2, with $\Sigma$3 a delimiter not in $\Sigma$4, the standard Floyd operator precedence relations are defined as follows. Equal precedence is

$\Sigma$5

Takes precedence is

$\Sigma$6

Yields precedence is

$\Sigma$7

These relations are collected in an operator precedence matrix

$\Sigma$8

where each cell $\Sigma$9 records the relations holding between $N$0 and $N$1. The matrix is conflict-free iff $N$2. A grammar is an operator precedence grammar iff its operator precedence matrix is conflict-free. The matrix is complete iff $N$3, and if $N$4 is nonempty then $N$5.

Prior literature traditionally assumed that $N$6 is acyclic over $N$7, meaning that the transitive closure of $N$8 is irreflexive on $N$9. This implies a uniform bound on the length of rule RHSs and prevents cycles such as $V=\Sigma\cup N$0 or longer loops. The cyclic setting removes this restriction and admits equality cycles of the form

$V=\Sigma\cup N$1

provided the matrix remains conflict-free.

2. Local parsability and chain decomposition

Local parsability is formalized through chains. Given a conflict-free operator precedence matrix $V=\Sigma\cup N$2 and $V=\Sigma\cup N$3 delimiters, a simple chain is

$V=\Sigma\cup N$4

A composed chain allows interposed subchains between the equal-precedence terminals (Chiari et al., 2023).

The locality principle states that if $V=\Sigma\cup N$5 is a conflict-free OP-alphabet, $V=\Sigma\cup N$6 is any chain, and $V=\Sigma\cup N$7 is any operator precedence automaton compatible with $V=\Sigma\cup N$8, then there exists a support run in $V=\Sigma\cup N$9, written $G=(\Sigma,N,P,S)$0, such that the first move is a push and the last move is a pop. The construction of that support depends only on $G=(\Sigma,N,P,S)$1 and the boundary relations $G=(\Sigma,N,P,S)$2 and $G=(\Sigma,N,P,S)$3, not on the context surrounding $G=(\Sigma,N,P,S)$4 and $G=(\Sigma,N,P,S)$5 in the full input.

In operator precedence automata, configurations are triples $G=(\Sigma,N,P,S)$6. If the top-of-stack symbol $G=(\Sigma,N,P,S)$7 and the next input symbol at the beginning of $G=(\Sigma,N,P,S)$8 satisfy $G=(\Sigma,N,P,S)$9, the run must begin with a push. Inside $A\to\alpha$0, all moves are shifts along $A\to\alpha$1 links and pops when ending nested subchains. Because $A\to\alpha$2 is conflict-free, the sequence of shifts and pops generated by $A\to\alpha$3 is uniquely determined by the structure of $A\to\alpha$4 as a chain. The final symbol $A\to\alpha$5 triggers a pop from the cell $A\to\alpha$6.

This locality principle holds unchanged in cyclic operator precedence grammars. Cyclic $A\to\alpha$7 only prolongs simple-chain bodies; the support within an equal-precedence run is a loop of shift moves. The first and last moves are still push and pop determined by the surrounding yield and take relations, so locality remains valid. This is the formal basis for chunk-level independence in the cyclic compilation algorithm.

3. Cyclic grammars, regular-expression RHSs, and unranked trees

To capture unbounded flat fragments implied by equality cycles, cyclic operator precedence grammars enrich the right-hand side format with simplified regular expressions. A “$A\to\alpha$8-O-expression” is a regular expression over $A\to\alpha$9 using concatenation and Kleene plus “$\alpha\in V^*$0”, subject to the operator-form constraint and with each argument to $\alpha\in V^*$1 ending in a terminal. A cyclic O-grammar (C-OG) is an O-grammar whose productions $\alpha\in V^*$2 have RHS $\alpha\in V^*$3 that is a $\alpha\in V^*$4-O-expression. Immediate derivation is defined by $\alpha\in V^*$5 if $\alpha\in V^*$6 (Chiari et al., 2023).

In this enriched setting, equal precedence is extended to RHS languages:

$\alpha\in V^*$7

The relations $\alpha\in V^*$8 and $\alpha\in V^*$9 remain defined as usual through $\varepsilon$0 and $\varepsilon$1. A C-OG is a cyclic operator precedence grammar (C-OPG) iff its operator precedence matrix is conflict-free.

Allowing “$\varepsilon$2” in RHSs lets rules denote infinite regular sets of terminal and nonterminal patterns consistent with operator form. The implicit syntax trees become unranked: nodes can have unbounded numbers of children along an equal-precedence run. This exactly matches the intended structure of flat, associative operators or list-like constructs.

A concrete cyclic grammar over terminals $\varepsilon$3 and nonterminals $\varepsilon$4 includes schematic productions such as

• $\varepsilon$5
• $\varepsilon$6
• $\varepsilon$7
• $\varepsilon$8
• $\varepsilon$9

with parenthesized $\varepsilon$0 generated by $\varepsilon$1 and $\varepsilon$2. In the corresponding matrix, $\varepsilon$3 and $\varepsilon$4 are equality cycles, multiplicative operators take precedence over additive ones, and $\varepsilon$5 and $\varepsilon$6 take precedence over $\varepsilon$7 and $\varepsilon$8 respectively. For the sentence

$\varepsilon$9

the parse tree has a $A\in N$0-node whose additive children are many, reflecting an unbounded flat structure governed by $A\in N$1.

4. Cyclic compilation algorithm

The cyclic compilation algorithm is a parallel parsing and compilation algorithm exploiting local parsability and equality cycles. It comprises five stages (Chiari et al., 2023).

The first stage is construction of the operator precedence matrix from a cyclic grammar $A\in N$2 whose RHSs are $A\in N$3-O-expressions. For every production $A\in N$4, the construction considers the regular language $A\in N$5. For each word $A\in N$6 and each pair of terminals $A\in N$7 that appear with at most one nonterminal between them, it adds $A\in N$8 if $A\in N$9 has a segment $\Sigma$00 with $\Sigma$01. Yield and take relations are computed through $\Sigma$02 and $\Sigma$03, and relations with $\Sigma$04 are set using $\Sigma$05 and $\Sigma$06. Conflict-freeness is then checked. For regular RHSs, the algorithmic trick is to use finite normalizations: let $\Sigma$07 be the set of bare RHSs with plus operators removed and $\Sigma$08 the set of prefixes of strings from $\Sigma$09 while normalizing double occurrences under $\Sigma$10 by keeping at most two occurrences. Computing $\Sigma$11 and $\Sigma$12 from these finite normalizations preserves correctness while giving a finite basis for matrix construction.

The second stage is input partitioning. For input $\Sigma$13 with $\Sigma$14 padding, the algorithm computes precedence relations between consecutive terminals. A chunk is any maximal interval $\Sigma$15 such that $\Sigma$16, $\Sigma$17, and for $\Sigma$18, $\Sigma$19 or the interval continues through nested subchains. Intuitively, a chunk is the body $\Sigma$20 of a chain $\Sigma$21. Markers such as parentheses provide obvious chunk boundaries, but equality cycles also make long equal-precedence runs available for splitting. If an equal-precedence run is extremely long, the algorithm further subpartitions it into subchunks of bounded size $\Sigma$22, a tunable parameter. Formally, within any maximal run

$\Sigma$23

one chooses boundaries $\Sigma$24 with $\Sigma$25 so that each subrun $\Sigma$26 has length at most $\Sigma$27.

The third stage is parallel parsing of chunks. Each chunk is parsed locally by a bottom-up operator precedence parser or an operator precedence automaton-based recognizer, starting from a push and ending at a pop, as guaranteed by the $\Sigma$28 and $\Sigma$29 boundaries. The chunk parser builds a partial parse forest, with unranked trees for cyclic equality runs, and uses a backward-deterministic grammar to prevent ambiguity. Synchronization points occur at chunk boundaries. Because local parsability holds, chunk parses are independent and merging only needs to inspect adjacency relations in the precedence matrix for the extreme terminals.

The fourth stage concerns determinism and conflict resolution. Determinism requires a conflict-free precedence matrix and a backward-deterministic grammar satisfying the condition that if $\Sigma$30 and $\Sigma$31 are both in $\Sigma$32, then $\Sigma$33. For cyclic $\Sigma$34 runs, the local parser uses normalized “two-occurrence” equivalence to prevent looping ambiguity; it recognizes patterns under $\Sigma$35 by detecting double occurrence of cycles and then compacting them. If precedence construction detects conflicts, the grammar must be revised. If chunk boundaries fall within an equal-precedence cycle, the algorithm meta-labels subchunks and merges them under a single parent node representing the operator at that precedence level.

The fifth stage is merging. Chunks are processed in input order, and merging examines only the extreme terminals of adjacent chunks. If the previous chunk’s right extreme and the next chunk’s left extreme satisfy $\Sigma$36, the algorithm performs an equal-precedence merge, combining the partial parses under a single flat node. If they satisfy $\Sigma$37 or $\Sigma$38, the algorithm uses operator precedence to decide nesting and perform reductions or pops. The invariants are that each chunk parse respects operator form and precedence relations inside the chunk, merging checks only adjacency of chunk extremes via the precedence matrix and performs reductions without peeking inside chunk bodies, and after merging the frontier of the global tree equals the original input while the parse respects the matrix.

The stated complexity is as follows. Let $\Sigma$39, $\Sigma$40 be the number of chunks, and $\Sigma$41 the number of processors. Building the precedence matrix is linear in grammar size and in the finite normalization of RHSs; if $\Sigma$42 is the maximum nesting depth of $\Sigma$43 and $\Sigma$44 is the maximum primitive RHS length, the normalization yields $\Sigma$45 distinct prefixes and building the matrix is $\Sigma$46 in the worst case. Partitioning is $\Sigma$47, with chunk splitting incurring $\Sigma$48. Parsing chunks has total work $\Sigma$49, since each terminal participates in $\Sigma$50 local decisions under a conflict-free matrix, and the parallel parse time is approximately $\Sigma$51, where $\Sigma$52 are chunk lengths. Merging is $\Sigma$53. Overall sequential time is $\Sigma$54, and the parallel time is described as

$\Sigma$55

Space usage is $\Sigma$56 for distributed parse stacks and $\Sigma$57 for the precedence matrix.

5. Expressive equivalences and formal correspondences

The enriched cyclic formalism is presented as fully equivalent in expressive power to other formalisms for