Pith. sign in

REVIEW 4 major objections 5 minor 40 references

Earley-Driven Dynamic Pruning for Efficient Structured Decoding

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read The paper claims that dynamically pruning Earley parser states by dependency reachability keeps a context-free grammar decoder complete while cutting memory and boosting structured-generation speed by up to 2x.

desk verdict Real engineering with honest ablations, but the formal pruning definition is vacuous as written and the completeness claim needs a proof before the 2x headline deserves any weight. read the letter →

arxiv 2506.01151 v1 pith:C4SJHHAM submitted 2025-06-01 cs.LG cs.AIcs.CL

Xintong Sun , Chi Wei , Minghao Tian , Shiwen Ni This is my paper
classification cs.LGcs.AIcs.CL
keywords constraineddecodingEarleyparserdynamicpruningdependencygraphcontext-freegrammartokenlogitsmaskstatecachingstructuredgeneration
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper claims that a dynamic pruning rule for the Earley parser (a parsing algorithm that tracks every partial parse as a set of states)—dropping any parse state that is not reachable, through dependency edges, from the current last state set—preserves the set of valid grammar continuations while sharply reducing the number of states the decoder must carry. The payoff matters because constrained decoding for large language models must rebuild a token logits mask—a filter over the vocabulary—at every generation step, and the cost of that mask construction can dominate inference. If the pruning guarantee holds, a decoder can produce token masks identical to those of a full Earley parser while using less memory and running up to twice as fast, with no loss in output validity. The paper implements the idea in a decoding engine called Formatron and reports consistent throughput gains across JSON, JSON Schema, and semantic-parsing tasks on four model families.

What carries the argument

The machinery is the dependency graph over extended Earley items. An Earley item is a production rule with a dot marker and a span, written $(A\to\alpha\bullet\beta,i,j)$, recording how much of the rule has been matched and over which input positions. Edges record that one item was produced from another by Predict, Scan, or Complete; the Compact phase, run after Complete and before Predict, deletes every item not in the reachability closure of the latest Earley set—every item from which no directed path leads to an item in the last set. The claim is that the reachability test identifies exactly the states that can still contribute to future parsing, so deleting the rest preserves the accepted language while shrinking the state set that must be cached and searched.

What would settle it

Run the pruned parser and a standard full parser on the same grammar, with completions deliberately delayed across many steps so that intermediate states are compacted away; any input where the full parser accepts a token the pruned parser masks, or where the pruned parse fails, would refute the completeness claim.

Watch

Extended reading notes

Core claim

The central claim is that Earley items outside the reachability closure of the most recent Earley set are dead: they cannot participate in any future Predict, Scan, or Complete step, so they can be discarded online. The paper formalizes this with an extended item notation, defines three dependency relations generated by Predict, Scan, and Complete, builds a directed dependency graph over all items, and retains only items that have a directed path to some item in the last set. This pruning makes it practical to cache pruned Earley states across queries, since many different token sequences collapse to the same pruned state set. The paper's experiments show that removing the pruning step lowers throughput by roughly 30–50% and that full Formatron reaches up to 2x speedups while maintaining 100% structural compliance on the tested tasks.

Load-bearing premise

The argument hinges on believing that any partially parsed rule that cannot be reached from the latest parse state can never be needed later, and the paper does not give a formal proof of that belief.

Editorial extensions

If this is right

  • Earley-based constrained decoders can keep full context-free grammar support without keeping every historical state set, because only states in the reachability closure of the current set are retained.
  • Throughput on JSON, JSON Schema, and semantic-parsing tasks improves up to 2x over existing engines, and the gap widens when the same grammar is reused across many runs because the pruned state cache hits more often.
  • The speed gain comes without trading away output validity: the paper reports 100% structural compliance on the tested tasks and accuracy at least comparable to baselines.
  • Removing the pruning step alone lowers throughput by 30–50% in the paper's ablations, and disabling the cache as well degrades performance further.
  • The approach transfers across four model families without fine-tuning, supporting the paper's generality claim.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Unstated but implied: the pruning rule defines a stronger invariant—only states on a dependency path to the parser's current frontier ever need storage—which, if correct, would make Earley parsing memory scale with the grammar's live frontier rather than total input length; the paper only evaluates LLM decoding, not long-document streaming.
  • Editorial: a randomized differential test against a full Earley parser—sampling small grammars and random prefixes and comparing the token masks the two parsers produce—would give direct evidence about where the reachability invariant does or does not hold.
  • Editorial: the paper's 'high-level regular rule' description of which rules generate dead states is informal; formalizing it could turn the pruning rule into a provable transformation and might enable more aggressive deletion than the current rule.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes ZapFormat, a dynamic pruning strategy for Earley parsing in the context of LLM constrained decoding, and presents Formatron, an engine that implements it together with a context-independent token mask cache and rejection-prefix optimization. The authors claim that pruning redundant Earley states reduces memory and improves parsing-mask throughput by up to 2x over state-of-the-art engines such as XGrammar, while preserving grammatical completeness. Experiments cover JSON generation, JSON Schema, and Geoquery across four LLMs, with an ablation showing pruning contributes 30--50% of the parsing-stage throughput. The full-pipeline results in Appendix B.1, however, show Formatron essentially matching XGrammar, and the formal active-item-set definition in Section 4.2.3 is mathematically vacuous. Key results therefore need substantial clarification and, in the central formal claim, correction.

Significance. The problem of reducing constrained-decoding overhead is important, and a sound dynamic pruning scheme for Earley-based mask construction would be a useful contribution. The paper reports a substantial empirically measured parsing-stage speedup and releases an open-source implementation, both of which are valuable. However, the central algorithmic definition, as written, prunes nothing, and the completeness guarantee for the intended rule is unsupported. As a result, the paper's main technical contribution is not currently established. With a corrected definition, a proof or adversarial differential evaluation, and more careful end-to-end claims, the work could become a solid systems contribution, but the current form overstates both the theoretical and practical results.

major comments (4)
  1. [Section 4.2.3] The formal definition of the Active Item Set is vacuous. Because Reach(a) = {x in V | x ->* a} includes x = a via the zero-length path, the union R = union over a in V Reach(a) equals V. Thus the defined pruning rule removes no states at all, directly contradicting Table 3's ablation where pruning contributes 30--50% of parsing-stage throughput. The prose description says the union should be over items "in the last earley set," so the formal definition must be corrected to R = union over a in LastSet Reach(a), and the implementation must be checked against this corrected definition.
  2. [Section 4.2.3] The paper asserts "theoretical completeness guarantees" for the pruning rule, but no invariant or proof is supplied. For the intended rule, items outside the forward dependency closure of the current last set are discarded; without an argument that every item that could be consumed by a future Complete operation lies in this closure, completeness is not established. The authors should either prove an invariant or, at minimum, run a differential test against an unpruned Earley parser on a large collection of CFGs including left-recursive, ambiguous, nullable, and deeply nested grammars.
  3. [Abstract and Section 5.2 vs. Appendix B.1] The headline claim of "inference speed up to 2x" is not supported for end-to-end inference. Table 1 reports parsing and masking stage throughput, but Appendix B.1, Table 6 shows full-pipeline JSON/s essentially identical to XGrammar (e.g., 30.42 vs 30.42 for Llama3, 34.46 vs 34.34 for Qwen). The abstract and conclusion should qualify the speedup as parsing-stage-only or should use end-to-end numbers for the headline claim.
  4. [Section 5.4, Table 4] The memory reduction reported in Table 4 is about 1% (Llama3: 1655.48 to 1635.92 MB; Mistral: 1530.77 to 1519.09 MB), which does not support the abstract and Section 1 claims of "significantly reducing memory occupation." The paper should either present more extensive memory measurements across all tasks and models (and ideally a memory profiling over decoding steps) or substantially soften the memory-reduction claim.
minor comments (5)
  1. [Table 1] Several entries are malformed with missing separators, e.g., "1473.9910245.04" and "12174.68 7943.348668.69"; the table also uses inconsistent shorthand "Json s" and "Json g" which should be expanded as JSON Schema and JSON Grammar.
  2. [Section 5.4] The text references "Table 5.4" when presenting the ablation study, but the actual table number is Table 3; the citation should be corrected.
  3. [Appendix C] The notation table states that the span [i, j] captures "β's coverage range," but Section 4.2.1 correctly defines it as capturing α's coverage of the input; the appendix should be aligned with the section.
  4. [Section 4.4] The sentence "These prefixes represent fundamental grammatical violations that cannot be completion" should read "cannot be completed" or "cannot be completed by any extension."
  5. [References] The reference list contains duplicate entries for Geng et al. 2023 (one with a URL and one without); these should be merged.

Circularity Check

1 steps flagged · score 6.0 of 10

The Active Item Set definition in §4.2.3 is self-definitional: because reachability is reflexive, R = ⋃_{a∈V} Reach(a) equals V, so the stated pruning rule prunes nothing by construction.

  1. self definitional [Section 4.2.3, 'Reachability and Dynamic Pruning', Active Item Set definition.]
    "Reachability Closure: For each item x∈V , if there exists a path from x to an item a in the last earley set, we consider this item ”reachable”. Formally, we define the reachability closure as: Reach(a) ={x∈V|x→ ∗ a}, where →∗ denotes a directed path (potentially multi-step) fromxtoa. Active Item Set: We define the active item setR as the union of all reachable items: R= [ a∈V Reach(a). Only items within this active set need to be retained."

    The formal definition takes the union over every vertex a∈V, not over the last Earley set as the preceding prose states. Since →∗ is the reflexive transitive closure, every item x has the zero-length path x→∗x, so x∈Reach(x)⊆R and therefore R=V by construction. The rule 'only items within this active set need to be retained' then retains every item, making the stated pruning rule exactly equivalent to the no-pruning baseline. Yet the paper claims this reachability pruning eliminates dead states and 'provides theoretical completeness guarantees,' and Table 3 attributes 30–50% of throughput to pruning. Only a different, unstated rule (union over last-set items) could prune, and its completeness is asserted without proof.

full rationale

The central formal step of the paper's pruning derivation is self-definitional and vacuous: the Active Item Set R is defined as the union of Reach(a) over all a∈V, and because every Earley item reaches itself via a zero-length path, R=V. The claimed 'dynamic pruning that identifies and eliminates invalid or redundant Earley states' therefore reduces, by the paper's own equations, to retaining every state. The prose indicates the intended rule is the union over items in the last Earley set, but that rule is not the one formalized, and its 'theoretical completeness guarantees' are asserted without a proof or invariant. This is a genuine reduction-by-construction in the paper's stated derivation chain. Apart from this step, the paper's evidence is not circular: there are no fitted parameters renamed as predictions, no load-bearing self-citations (the cited XGrammar work is by different authors and used as an external baseline/dependency), and the throughput and accuracy results are measured against external engines (lm-format-enforcer, outlines, XGrammar) on independent tasks. Those empirical comparisons are self-contained and would remain meaningful even if the formal pruning definition were corrected. The score of 6 reflects that one core algorithmic 'prediction'—that the active set prunes states while preserving completeness—reduces by construction to no pruning, while the rest of the evaluation is independent.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The central load-bearing assumption is the reachability-based pruning correctness, which is stated but not proved. The other axioms are standard parsing results or borrowed optimization techniques.

assumptions (4)
  • ad hoc to paper Reachability closure of the last Earley set captures all items that could be needed in future completions, so items outside the active set can be safely discarded.
    This is the core correctness assumption of ZapFormat, asserted in Section 4.2.3 without a formal proof. If false, the parser would drop states needed for later Complete operations and generate incorrect token masks.
  • standard math The grammar transformation removing useless and nullable rules preserves the language of the original CFG.
    Invoked in Section 4.5 with reference to Hopcroft and Ullman; standard result.
  • standard math Earley's algorithm correctly parses any context-free grammar in cubic time.
    Standard background, cited Earley (1970).
  • domain assumption The context-independent token mask cache from XGrammar is compatible with the modified Earley parser and remains correct under dynamic pruning.
    The paper adapts XGrammar's token classification in Section 4.3, but it does not analyze how pruning interacts with the cached masks.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Earley-Driven Dynamic Pruning for Efficient Structured Decoding." pith.science (2026). https://pith.science/paper/C4SJHHAM

@misc{pith2026250601151,
  author       = {Pith},
  title        = {Pith review of: Earley-Driven Dynamic Pruning for Efficient Structured Decoding},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/C4SJHHAM}},
  note         = {Machine review of arXiv:2506.01151}
}
abstract

Large Language Models (LLMs) have shown remarkable capabilities, yet ensuring their outputs conform to strict structural or grammatical constraints remains challenging, which is critical in function calls and domain-specific language (DSL) generation. Constrained decoding with context-free grammar is a flexible approach to guarantee LLMs' adherence to a specific format by dynamically building a token logits mask. However, creating this mask requires checking the validity of all tokens in the LLM vocabulary at every decoding step, which often incurs significant overheads in existing constrained decoding engines. To address this challenge, we propose $\textbf{ZapFormat}$, a novel $\textbf{dynamic pruning}$ strategy based on the Earley algorithm that identifies and eliminates invalid or redundant Earley states in real-time, significantly reducing memory occupation of the Earley algorithm's states. This further enables us to use a state cache to speed up structured generations on a large number of queries. We implemented ZapFormat in a new constrained decoding engine called Formatron which also incorporates existing optimizations. Through comprehensive experiments on structured generation tasks, including JSON generation, JSON Schema validation, and semantic parsing, we demonstrate that Formatron not only $\textbf{consistently maintains}$ high-precision compliant outputs but also achieves $\textbf{significant improvements}$ in inference speed up to 2x compared to state-of-the-art implementations. More importantly, Formatron is generally applicable across various LLM architectures. We release Formatron as open source at https://github.com/Dan-wanna-M/formatron.

Figures

Figures reproduced from arXiv: 2506.01151 by the authors.

Figure 1
Figure 1. Early parse. This diagram provides a detailed illustration of the Earley parsing process for the input string ’a + d’ based on the grammar S → A + B, A → a|c, B → b|d. In the diagram, red arrows indicate Predict operations; yellow arrows represent Scan operations; and green arrows denote Complete operations. 3.2. Earley’s Algorithm The Earley algorithm represents a dynamic programming approach to parsing context-fre… view at source ↗
Figure 2
Figure 2. Constrained decoding. Constrained decoding can be achieved by masking the illegal tokens at the current step. valid tokens can be sampled. To illustrate, consider generating a JSON structure with a simple CFG JSON -> "{" PairList "}", where PairList represents key-value pairs. During generation, after producing ’{’, an Earley parser identifies that only ’"’ (for starting a string) or ’}’ (for empty objects) are vali… view at source ↗
Figure 3
Figure 3. Dynamic pruning. Red parts indicate prunable nodes, and green dashed lines represent Complete dependency paths. First,already completed Earley items only lead to modifications on their residing Earley set. Once their residing Earley set is fully processed, we can remove them. In addition, after one Earley set is fully processed, if an Earley set is not referenced by the union of reference chains of all items in the … view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

40 extracted references · 22 canonical work pages

  1. [1]

    Prompting is programming: A query language for large language models

    Beurer-Kellner, L., Fischer, M., and Vechev, M. Prompting is programming: A query language for large language models. Proceedings of the ACM on Programming Languages, 7 0 (PLDI): 0 1946--1969, 2023

    work page 1946

  2. [2]

    Guiding llms the right way: fast, non-invasive constrained generation

    Beurer-Kellner, L., Fischer, M., and Vechev, M. Guiding llms the right way: fast, non-invasive constrained generation. In Proceedings of the 41st International Conference on Machine Learning, ICML'24. JMLR.org, 2024

    work page 2024

  3. [3]

    P., Cummings, D

    Chen, M., Tworek, J., Jun, H., Yuan, Q., Pond \'e , H., Kaplan, J., Edwards, H., Burda, Y., Joseph, N., Brockman, G., Ray, A., Puri, R., Krueger, G., Petrov, M., Khlaaf, H., Sastry, G., Mishkin, P., Chan, B., Gray, S., Ryder, N., Pavlov, M., Power, A., Kaiser, L., Bavarian, M., Winter, C., Tillet, P., Such, F. P., Cummings, D. W., Plappert, M., Chantzis, ...

    arXiv 2021

  4. [4]

    Three models for the description of language

    Chomsky, N. Three models for the description of language. IRE Transactions on information theory, 2 0 (3): 0 113--124, 1956

    work page 1956

  5. [5]

    and Meltzer, P

    Davis, S. and Meltzer, P. S. Geoquery: a bridge between the gene expression omnibus (geo) and bioconductor. Bioinformatics, 23 0 (14): 0 1846--1847, 2007

    work page 2007

  6. [6]

    A general-purpose algorithm for constrained sequential inference

    Deutsch, D., Upadhyay, S., and Roth, D. A general-purpose algorithm for constrained sequential inference. In Proceedings of the 23rd Conference on Computational Natural Language Learning (CoNLL), pp.\ 482--492, 2019

    work page 2019

  7. [7]

    F., Cai, Y., Lai, R., Xu, Z., Zhao, Y., and Chen, T

    Dong, Y., Ruan, C. F., Cai, Y., Lai, R., Xu, Z., Zhao, Y., and Chen, T. Xgrammar: Flexible and efficient structured generation engine for large language models. arXiv preprint arXiv:2411.15100, 2024

    arXiv 2024

  8. [8]

    Implement json schema field constraints \#215, August 2023

    dottxt-ai/outlines contributors . Implement json schema field constraints \#215, August 2023. URL https://github.com/dottxt-ai/outlines/issues/215. Accessed: [2025-01-15]

    work page 2023

Show all 40 references
  1. [9]

    The llama 3 herd of models

    Dubey, A., Jauhri, A., Pandey, A., Kadian, A., Al-Dahle, A., Letman, A., Mathur, A., Schelten, A., Yang, A., Fan, A., et al. The llama 3 herd of models. arXiv preprint arXiv:2407.21783, 2024

    2024 arXiv

  2. [10]

    An efficient context-free parsing algorithm

    Earley, J. An efficient context-free parsing algorithm. Commun. ACM, 13 0 (2): 0 94–102, February 1970. ISSN 0001-0782. doi:10.1145/362007.362035. URL https://doi.org/10.1145/362007.362035

    1970

  3. [11]

    The whole truth and nothing but the truth: Faithful and controllable dialogue response generation with dataflow transduction and constrained decoding

    Fang, H., Balakrishnan, A., Jhamtani, H., Bufe, J., Crawford, J., Krishnamurthy, J., Pauls, A., Eisner, J., Andreas, J., and Klein, D. The whole truth and nothing but the truth: Faithful and controllable dialogue response generation with dataflow transduction and constrained d...

    2023

  4. [12]

    Gemma Team, M. R. and Shreya Pathak, e. Gemma 2: Improving open language models at a practical size, 2024. URL https://arxiv.org/abs/2408.00118

    2024 arXiv

  5. [13]

    Grammar-constrained decoding for structured nlp tasks without finetuning

    Geng, S., Josifoski, M., Peyrard, M., and West, R. Grammar-constrained decoding for structured nlp tasks without finetuning. In The 2023 Conference on Empirical Methods in Natural Language Processing

    2023

  6. [14]

    Grammar-constrained decoding for structured NLP tasks without finetuning

    Geng, S., Josifoski, M., Peyrard, M., and West, R. Grammar-constrained decoding for structured NLP tasks without finetuning. In Bouamor, H., Pino, J., and Bali, K. (eds.), Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pp.\ 10932--10952...

    2023 doi

  7. [15]

    Hopcroft, J. E. and Ullman, J. D. Introduction to Automata Theory, Languages, and Computation. Addison-Wesley, 1st edition, 1979 a . remove useless rules

    1979

  8. [16]

    Hopcroft, J. E. and Ullman, J. D. Introduction to Automata Theory, Languages, and Computation. Addison-Wesley, 1st edition, 1979 b . remove nullable rules

    1979

  9. [17]

    Q., Sablayrolles, A., Mensch, A., Bamford, C., Chaplot, D

    Jiang, A. Q., Sablayrolles, A., Mensch, A., Bamford, C., Chaplot, D. S., Casas, D. d. l., Bressand, F., Lengyel, G., Lample, G., Saulnier, L., et al. Mistral 7b. arXiv preprint arXiv:2310.06825, 2023

    2023 arXiv

  10. [18]

    Sketch: A toolkit for streamlining llm operations

    Jiang, X., Li, X., Ma, W., Fang, X., Yao, Y., Yu, N., Meng, X., Han, P., Li, J., Sun, A., et al. Sketch: A toolkit for streamlining llm operations. arXiv preprint arXiv:2409.03346, 2024

    2024 arXiv

  11. [19]

    Automata-based constraints for language model decoding

    Koo, T., Liu, F., and He, L. Automata-based constraints for language model decoding. In First Conference on Language Modeling

  12. [20]

    Validating large language models with relm

    Kuchnik, M., Smith, V., and Amvrosiadis, G. Validating large language models with relm. Proceedings of Machine Learning and Systems, 5: 0 457--476, 2023

    2023

  13. [21]

    Crafting papers on machine learning

    Langley, P. Crafting papers on machine learning. In Langley, P. (ed.), Proceedings of the 17th International Conference on Machine Learning (ICML 2000), pp.\ 1207--1216, Stanford, CA, 2000. Morgan Kaufmann

    2000

  14. [22]

    Leo, J. M. A general context-free parsing algorithm running in linear time on every lr(k) grammar without using lookahead. Theoretical Computer Science, 82 0 (1): 0 165--176, 1991. ISSN 0304-3975. doi:https://doi.org/10.1016/0304-3975(91)90180-A. URL https://www.sciencedirect....

    1991

  15. [23]

    Llm+p: Empowering large language models with optimal planning proficiency

    Liu, B., Jiang, Y., Zhang, X., Liu, Q., Zhang, S., Biswas, J., and Stone, P. Llm+p: Empowering large language models with optimal planning proficiency. arXiv preprint arXiv:2304.11477, 2023

    2023 arXiv

  16. [24]

    Lundberg, S., Ribeiro, M. T. C., et al. Guidance-ai/guidance: A guidance language for controlling large language models. URL https://github. com/guidance-ai/guidance, 2023

    2023

  17. [25]

    Support left recursive grammars

    mlc-ai/xgrammar contributors . Support left recursive grammars. currently going into infinite loop \#126, December 2024. URL https://github.com/mlc-ai/xgrammar/issues/126. Accessed: [205-01-15]

    2024

  18. [26]

    Efficient semiring-weighted E arley parsing

    Opedal, A., Zmigrod, R., Vieira, T., Cotterell, R., and Eisner, J. Efficient semiring-weighted E arley parsing. In Rogers, A., Boyd-Graber, J., and Okazaki, N. (eds.), Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Paper...

    2023 doi

  19. [27]

    Function calling - OpenAI API , 2024

    OpenAI. Function calling - OpenAI API , 2024. URL https://platform.openai.com/docs/guides/function-calling. [Accessed 26-10-2024]

    2024

  20. [28]

    OpenAI, Josh Achiam, S. A. and Sandhini Agarwal, e. Gpt-4 technical report, 2024. URL https://arxiv.org/abs/2303.08774

    2024 arXiv

  21. [29]

    L., Suarez, F., Ugarte, M., and Vrgo c , D

    Pezoa, F., Reutter, J. L., Suarez, F., Ugarte, M., and Vrgo c , D. Foundations of json schema. In Proceedings of the 25th International Conference on World Wide Web, WWW '16, pp.\ 263–273, Republic and Canton of Geneva, CHE, 2016. International World Wide Web Conferences Steer...

    2016

  22. [30]

    Synchromesh: Reliable code generation from pre-trained language models

    Poesia, G., Polozov, A., Le, V., Tiwari, A., Soares, G., Meek, C., and Gulwani, S. Synchromesh: Reliable code generation from pre-trained language models. In International Conference on Learning Representations

  23. [31]

    Benchclamp: A benchmark for evaluating language models on syntactic and semantic parsing

    Roy, S., Thomson, S., Chen, T., Shin, R., Pauls, A., Eisner, J., and Van Durme, B. Benchclamp: A benchmark for evaluating language models on syntactic and semantic parsing. Advances in Neural Information Processing Systems, 36, 2024

    2024

  24. [32]

    Picard: Parsing incrementally for constrained auto-regressive decoding from language models

    Scholak, T., Schucher, N., and Bahdanau, D. Picard: Parsing incrementally for constrained auto-regressive decoding from language models. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pp.\ 9895--9901, 2021

    2021

  25. [33]

    A., Pauls, A., Klein, D., Eisner, J., and Van Durme, B

    Shin, R., Lin, C., Thomson, S., Chen, C., Roy, S., Platanios, E. A., Pauls, A., Klein, D., Eisner, J., and Van Durme, B. Constrained language models yield few-shot semantic parsers. In Moens, M.-F., Huang, X., Specia, L., and Yih, S. W.-t. (eds.), Proceedings of the 2021 Confe...

    2021 doi

  26. [34]

    Neural machine translation with byte-level subwords

    Wang, C., Cho, K., and Gu, J. Neural machine translation with byte-level subwords. In Proceedings of the AAAI conference on artificial intelligence, volume 34, pp.\ 9154--9160, 2020

    2020

  27. [35]

    Wang, Y., Wang, W., Joty, S., and Hoi, S. C. C ode T 5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation. In Moens, M.-F., Huang, X., Specia, L., and Yih, S. W.-t. (eds.), Proceedings of the 2021 Conference on Empirical Methods ...

    2021 doi

  28. [36]

    Willard, B. T. and Louf, R. Efficient guided generation for large language models, 2023. URL https://arxiv.org/abs/2307.09702

    2023 arXiv

  29. [37]

    Sequence-based structured prediction for semantic parsing

    Xiao, C., Dymetman, M., and Gardent, C. Sequence-based structured prediction for semantic parsing. In Erk, K. and Smith, N. A. (eds.), Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp.\ 1341--1350, Berlin, Germ...

    2016 doi

  30. [38]

    Yang, A., Yang, B., Zhang, B., Hui, B., Zheng, B., Yu, B., Li, C., Liu, D., Huang, F., Wei, H., et al. Qwen2. 5 technical report. arXiv preprint arXiv:2412.15115, 2024

    2024 arXiv

  31. [39]

    and Neubig, G

    Yin, P. and Neubig, G. A syntactic neural model for general-purpose code generation. In Barzilay, R. and Kan, M.-Y. (eds.), Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp.\ 440--450, Vancouver, Canada, July 2...

    2017 doi

  32. [40]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.