CRANE: Reasoning with constrained LLM generation

Debangshu Banerjee; Gagandeep Singh; Sasa Misailovic; Shubham Ugare; Tarun Suresh

REVIEW 3 major objections 5 minor 4 cited by

CRANE: Reasoning with constrained LLM generation

T0 review · 3 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 constrained decoding with a finite output grammar confines any constant-layer log-precision LLM to the circuit class TC0, and that augmenting the grammar with a reasoning prefix restores expressivity while keeping…

desk verdict A genuine but narrowly scoped expressivity result for constrained decoding with finite grammars, paired with a pragmatic algorithm that works better than the theory would predict; the abstract oversells the generality. read the letter →

arxiv 2502.09061 v4 pith:QLTLL2BG submitted 2025-02-13 cs.PL cs.LG

Debangshu Banerjee , Tarun Suresh , Shubham Ugare , Sasa Misailovic , Gagandeep Singh This is my paper · ORCID

classification cs.PLcs.LG

keywords constraineddecodingLLMexpressivitycircuitcomplexityTC0chain-of-thoughtgrammaraugmentationsymbolicreasoningCRANE

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

Large language models are often forced to answer in a rigid format, such as a single expression or a yes/no token, to guarantee syntactic validity. This paper argues that such restrictive constrained decoding can genuinely reduce what the model can compute: with a finite output grammar, any constant-layer log-precision LLM is confined to problems solvable by constant-depth threshold circuits (TC0), so it cannot solve NL-complete tasks like st-connectivity unless TC0 = NL. The paper then shows the loss is not inevitable: augmenting the output grammar so that free-form reasoning can appear before the final answer restores the LLM's expressivity. Based on that, it introduces CRANE, a decoding strategy that switches between unconstrained reasoning and constrained final-answer generation, and reports accuracy gains of up to 10 percentage points over baselines on the GSM-symbolic and FOLIO benchmarks.

What carries the argument

The load-bearing mechanism is the simulation of one LLM autoregressive step by a logspace-uniform constant-depth threshold circuit. A finite output grammar keeps the number of steps constant, so the entire constrained run collapses into TC0. The fix is the grammar shape Ga -> R G, where R is a regular language of Turing-machine configuration encodings that lets the model write intermediate configurations before the final grammar-valid answer, plus CRANE's delimiter pair S1 and S2 that toggles constrained decoding on only for the final segment.

What would settle it

A concrete test would be to take a constant-layer, log-precision LLM that is known to solve st-connectivity when unconstrained and force it under a single-bit output grammar: if it still solves all instances, then TC0 would equal NL and the stated ceiling is wrong. A second check would be to ablate CRANE's delimiters; if accuracy does not drop, the delimiter-switching mechanism is not what carries the reported improvement.

Watch

Extended reading notes

Core claim

For any log-precision LLM with constant layers, one autoregressive step can be simulated by a logspace-uniform constant-depth threshold circuit. When the output grammar defines only a finite set of strings, every output is produced in a constant number of steps, so the whole constrained computation is a constant-depth threshold circuit. Hence constrained decoding with such a grammar cannot solve problems outside TC0; st-connectivity, which is NL-complete, is out of reach unless TC0 = NL. Conversely, for any Turing machine M there exists a constant-layer log-precision LLM and an augmented grammar Ga -> R G whose reasoning part R is a regular language over configuration encodings, so constrained decoding reproduces M's computation step by step and still ends with a valid final answer. The reasoning loss is therefore a property of the output grammar, not of constrained decoding per se.

Load-bearing premise

The practical payoff rests on pre-trained LLMs reliably emitting the start delimiter at the right moment and then producing a grammar-valid final answer; the theoretical restoration of expressivity is shown for a purpose-built model with a tailored reasoning grammar, not for arbitrary LLMs.

Editorial extensions

If this is right

Any system that forces a constant-layer LLM to answer with a fixed-size output grammar inherits a TC0 upper bound, so tasks such as reachability queries will fail without an escape hatch for intermediate steps.
Augmenting an output grammar with a reasoning segment restores the LLM's ability to simulate arbitrary polynomial-time Turing-machine computations, so constrained decoding is not inherently at odds with expressivity.
CRANE's delimiter-based switching gives a practical way to obtain syntax and semantic guarantees only where they matter, leaving the reasoning prefix unconstrained.
On GSM-symbolic and FOLIO, the reported gains of up to 10 accuracy points indicate that the benefit is measurable on real open-source models, not only in theory.

Reading between the lines

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

The TC0 bound is proven for constant-layer log-precision LLMs; if future or deeper models escape that circuit bound, the same grammar-augmentation argument may still apply, but the precise complexity ceiling would need revisiting.
The delimiter protocol is itself a testable interface: CRANE's practical value depends on pre-trained models learning to emit S1 before the final answer, which prompts and few-shot examples are meant to teach.
The same 'reasoning first, constrained answer second' shape could transfer to code generation and solver pipelines, where intermediate scratchpads are currently unconstrained by default.
One could try to sharpen the theory by extending Proposition 3.1 beyond finite output languages to infinite regular or context-free grammars with bounded derivation width.

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.

Desk Editor's Note

read the letter

First, the one thing to know: the paper's headline theoretical claim is genuine but narrower than the abstract suggests. Proposition 3.1 proves a TC0 upper bound for constrained decoding only when the output language L(Gc) is finite. The GSM-Symbolic expression grammar and the Prover9 FOL grammar are infinite, so the theory doesn't cover the paper's own benchmarks. The Limitation paragraph admits this, which I respect, but the abstract and conclusion state the unqualified version. That's a real gap in presentation, not a fatal flaw in the work.

What's actually new: applying the Merrill-Sabharwal circuit-complexity machinery to constrained decoding, and the augmented-grammar construction Ga -> R G showing that a purpose-built LLM can simulate t(n) steps of a Turing machine under constraints. That's a legitimate special-case result. CRANE is a simple, intuitive algorithm — generate reasoning unconstrained, then constrain only the final answer inside delimiters — and the experiments show consistent accuracy gains over both unconstrained CoT and the constrained baselines across nine models on GSM-Symbolic and three on FOLIO. The gains are meaningful: up to 10 points on FOLIO, 5-10 on GSM-Symbolic. The code is available.

Soft spots, in order of size. First, the finite-grammar gap is real and matters for how the paper will be read. The theory does not explain why constrained decoding hurts on the actual benchmarks; it explains a nearby special case. This is fixable with language, but as written the abstract oversells. Second, Proposition 3.3 is an existence theorem for a constructed LM, not a statement about real LLMs. CRANE's success relies on models emitting the start delimiter at the right time, and the paper doesn't analyze when that fails. Third, the experiments are single-run greedy without error bars or significance tests, and the constrained baselines are the authors' own ITERGEN and SYNCODE. There's no comparison to grammar-aligned decoding (Park et al. 2024), which the paper cites. The sampling ablations in the appendix help but don't settle it.

None of this kills the paper. The theory is honestly scoped in the body, the experimental claims are modest and consistent, and the problem is worth working on. This is the kind of paper that will be useful to people building constrained-decoding systems and to the expressivity crowd as a caveat-laden reference.

Recommendation: send it to peer review. It deserves a serious referee. I'd ask the authors to align the abstract and conclusion with the finite-grammar scope, add more runs or error bars, and ideally add one external constrained-decoding baseline.

Referee Report

3 major / 5 minor

Summary. The paper studies why constrained decoding can degrade the functional accuracy of LLM outputs. It proves (Proposition 3.1) that if the output language L(G_c) is finite, then any constant-layer, log-precision LLM under constrained decoding computes a logspace-uniform TC^0 function, so decision problems such as st-connectivity are unsolvable unless TC^0 = NL. It then proves an existence result (Proposition 3.3): for any Turing machine M and output grammar G containing M's outputs, there exists a constant-layer LLM L_M and an augmented grammar G_a = R_M G under which L_M can generate an unbounded reasoning prefix followed by M(x) while remaining inside G_a, thereby preserving expressivity. Building on this, the paper proposes CRANE, which alternates unconstrained generation with grammar-constrained windows delimited by << and >> tokens, and evaluates it on GSM-Symbolic and FOLIO across nine open LLMs, reporting consistent accuracy improvements over unconstrained CoT and constrained baselines.

Significance. If the theoretical claims held in the advertised generality, this would be a valuable bridge between circuit complexity and constrained decoding, providing a principled explanation for format-restriction degradation and a concrete design principle: augment the output grammar with a reasoning prefix. The proof of Proposition 3.1 is short and plausibly correct, relying on the cited Merrill--Sabharwal constant-depth circuit simulation, and Proposition 3.3 is a clean existence construction. The empirical study is broad in model coverage, and CRANE is simple and cost-efficient. However, the advertised generality is stronger than what is proved: Proposition 3.1 applies only to finite output languages, whereas the benchmark grammars used in Section 5 are recursive and infinite, and Proposition 3.3 is an existence result for a purpose-built LM rather than direct evidence that pretrained LLMs follow CRANE's delimiter protocol. The paper should be credited for stating this first limitation explicitly, but the abstract and conclusion still frame the result as a general explanation, which is not currently supported.

major comments (3)

[Abstract; §3.1; Appendix C; Limitation] Proposition 3.1 is proved only for finite output languages. The proof in Appendix C explicitly relies on L(G_c) being finite so that every output has length at most a constant N, allowing N constant-depth circuits to be stacked into one constant-depth circuit. The abstract and conclusion, however, claim that constraining outputs to 'very restrictive grammars' reduces reasoning, and the paper's own evaluations use recursive, infinite grammars: the GSM-Symbolic expression grammar in Appendix C.5.1 and the Prover9 grammar in Appendix C.5.2 both generate unboundedly many strings. For such grammars the bounded-step argument fails and no TC^0 upper bound follows. The Limitation paragraph concedes that the infinite-language case is left open, but the contribution and the conclusion are not correspondingly qualified. Please either restrict the theoretical claim to finite-output languages and reframe the contribution accordingly, or extend the argument to the infinite grammars used in the evaluation.
[§3.2; §4] Proposition 3.3 is an existence result for a purpose-built constant-layer LLM L_M whose vocabulary and augmented grammar R_M depend on the specific Turing machine M. Section 4 itself states that 'this result does not directly translate into a practical constrained decoding algorithm.' The practical claim that CRANE preserves reasoning in real LLMs therefore rests on an unverified behavioral assumption: that pretrained models emit the delimiter S1 at the right place and then produce a valid constrained final answer. If this assumption fails, CRANE degenerates to unconstrained decoding and the syntax guarantee is lost. This assumption should be tested explicitly, for example by reporting the frequency of correctly placed S1/S2 delimiters and the fraction of final answers that actually fall inside constrained windows, and by analyzing failure cases.
[§5; Tables 1–2; Tables 4–5] The headline empirical claim of consistent, up-to-10-point improvements is supported by a single fixed evaluation per model and benchmark, and the sampling comparisons in Tables 4–5 report pass@k without confidence intervals or significance tests. Even when greedy decoding is deterministic, per-instance paired tests or bootstrap intervals over the finite benchmark would quantify whether the reported few-point gains are stable. The abstract uses the word 'significantly,' so the empirical section should provide this evidence rather than only point accuracies.

minor comments (5)

[Tables 1–2] Several CRANE rows merge adjacent numeric columns (e.g., '31100', '3894', '31.0375.86'), making accuracy, parse/compile rate, and token counts unreadable; please reformat the tables.
[Proposition 3.1; Appendix B] The word 'threshold' is misspelled as 'thershold' in Proposition 3.1 and in the heading of Appendix B.
[Introduction] There is an unmatched parenthesis in the citation 'GSM-symbolic (Mirzadeh et al., 2024))' and the FOLIO citation is formatted inconsistently; please clean up the references.
[Proposition 3.3] The assumption that G contains all halting outputs of M should be stated explicitly before the proposition; otherwise the equality L_M,G_a(x) = r·M(x) is not guaranteed for outputs outside L(G).
[Related Work] The claim that grammar-aligned methods 'require a large no. of resamplings per prompt' is not supported by a quantitative comparison; please either substantiate it or soften the wording.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the expressivity results rest on external prior theorems, and the practical claims are not derived by reusing fitted inputs.

full rationale

Proposition 3.1 is not circular. It is proved from Lemma C.1, which is explicitly the external single-step circuit simulation of Merrill and Sabharwal (2023), plus the finiteness of L(Gc), which makes the number of autoregressive steps constant and allows the constant-depth circuits of successive steps to be stacked. The proof does not assume the TC0 upper bound; it derives it. Proposition 3.3 is an existence construction whose main computational content is Lemma 3.2, explicitly quoted from Merrill and Sabharwal (2024). The augmented grammar Ga = R_M G is defined only after the simulating LLM LM is constructed, so the step showing LM(x) ∈ L(Ga) and hence L_{M,Ga}(x) = LM(x) is a verification that the grammar accepts the model's output, not a hidden use of the conclusion. The paper's own Limitation paragraph concedes that Proposition 3.1 covers only finite L(Gc) and leaves infinite grammars open; the GSM-Symbolic and Prover9 grammars used in the benchmarks are infinite, so the broad phrasing in the abstract is a scope gap, but that is a correctness/coverage issue rather than circularity. Self-citations occur in the evaluation (ITERGEN and SYNCODE are used as constrained-decoding baselines), but they are compared tools, not premises of the expressivity proof, and the benchmarks are external. No fitted parameter is renamed as a prediction, and no uniqueness or validity claim is imported solely from the authors' prior work. The derivation chain is therefore self-contained; score 0.

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

The theoretical claims rest on prior theorems about transformer circuit complexity (Merrill-Sabharwal) and on the standard TC0 does not equal NL conjecture. The paper fits no parameters to data; its practical algorithm introduces no new entities beyond grammar-augmentation constructs.

assumptions (4)

domain assumption A single autoregressive step of any constant-layer log-precision transformer is simulable by a logspace-uniform TC0 circuit family.
Invoked as Lemma C.1 in the proof of Proposition 3.1, taken from Merrill and Sabharwal 2023.
domain assumption TC0 is not equal to NL.
Used after Proposition 3.1 to conclude st-connectivity is unsolvable under constrained decoding. This is a standard complexity conjecture, not a proven theorem.
standard math For any Turing machine M, there exists a constant-depth log-precision LLM LM that simulates t(n) steps of M with t(n) autoregressive steps.
Lemma 3.2 derives from Theorem 2 of Merrill and Sabharwal 2024; the paper relies on this existence result for the augmented grammar construction in Proposition 3.3.
domain assumption Constrained decoding is deterministic and sound: if the unconstrained output is in L(G), the constrained output is unchanged.
Definitions 2.2 and 2.3 in Section 2.2; used in Proposition 3.3 to argue that LM(x) = LM,Ga(x).

how reviews work

0 comments

Cite this review

Pith. "Pith review of CRANE: Reasoning with constrained LLM generation." pith.science (2026). https://pith.science/paper/QLTLL2BG

@misc{pith2026250209061,
  author       = {Pith},
  title        = {Pith review of: CRANE: Reasoning with constrained LLM generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/QLTLL2BG}},
  note         = {Machine review of arXiv:2502.09061}
}

read the original abstract

Code generation, symbolic math reasoning, and other tasks require LLMs to produce outputs that are both syntactically and semantically correct. Constrained LLM generation is a promising direction to enforce adherence to formal grammar, but prior works have empirically observed that strict enforcement of formal constraints often diminishes the reasoning capabilities of LLMs. In this work, we first provide a theoretical explanation for why constraining LLM outputs to very restrictive grammars that only allow syntactically valid final answers reduces the reasoning capabilities of the model. Second, we demonstrate that by augmenting the output grammar with carefully designed additional rules, it is always possible to preserve the reasoning capabilities of the LLM while ensuring syntactic and semantic correctness in its outputs. Building on these theoretical insights, we propose a reasoning-augmented constrained decoding algorithm, CRANE, which effectively balances the correctness of constrained generation with the flexibility of unconstrained generation. Experiments on multiple open-source LLMs and benchmarks show that CRANE significantly outperforms both state-of-the-art constrained decoding strategies and standard unconstrained decoding, showing up to 10% points accuracy improvement over baselines on challenging symbolic reasoning benchmarks GSM-symbolic and FOLIO.

Figures

Figures reproduced from arXiv: 2502.09061 by the authors.

**Figure 1.** An example from the GSM-symbolic dataset (variables in blue) where unconstrained generation produces syntactically incorrect output, while constrained generation provides a syntactically valid but incorrect answer. CRANE, however, generates a correct answer. powerful ones developed in the future. Second, we must design cost-efficient decoding strategies that address the shortcomings of existing constrained decoding… view at source ↗

**Figure 2.** CRANE adaptively switches between constrained LLM generation and unconstrained LLM generation based on start and end delimiters (in this example << and >>). Using these delimiters, CRANE dynamically tracks which windows (highlighted in the figure) of the LLM generation constraints should be applied to. We implement our approach into the CRANE algorithm (Algo 1), which extends standard autoregressive LLM generation.… view at source ↗

**Figure 3.** Accuracy (%) of Qwen2.5-Math-7B-Instruct By Method and Number of Shots on GSM-Symbolic As shown in the table, CRANE consistently improves functional correctness across all evaluated models. For example, with the Qwen2.5-Math-7B-Instruct model, CRANE achieves 38% accuracy, outperforming both constrained generation and unconstrained generation with CoT, which achieves 29% accuracy. Similarly, with the Qwen2.5-1.5BI… view at source ↗

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 4 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

Imprompt: A Language Framework for Prompt Programming
cs.AI 2026-07 conditional novelty 7.0 of 10

Prompt programs can be typed like programs and compiled in different ways; Imprompt formalizes two such compilers and tests them on tax-law reasoning and data-labeling tasks.
DINGO: Constrained Inference for Diffusion LLMs
cs.LG 2025-05 conditional novelty 7.0 of 10

DINGO is a dynamic programming decoder over a token-level DFA that makes diffusion LLM outputs obey regular expressions while maximizing the product of per-position probabilities.
The Format Tax
cs.CL 2026-04 conditional novelty 6.0 of 10

Structured-output instructions alone impose a large accuracy tax on open-weight LLMs; decoupling freeform reasoning from formatting recovers most of it, while recent closed models largely avoid the tax.
MyCulture: Exploring Malaysia's Diverse Culture under Low-Resource Language Constraints
cs.CL 2025-08 reject novelty 6.0 of 10

MyCulture, a new Malay-language cultural benchmark, shows LLM accuracy drops by at least 17% when multiple-choice questions are converted to an open-ended format.

Reference graph

Works this paper leans on

17 extracted references · 12 canonical work pages · cited by 4 Pith papers

[6]

Strobl, L., Merrill, W., Weiss, G., Chiang, D., and Angluin, D

URL https://qwenlm.github.io/blog/ qwen2.5/. Strobl, L., Merrill, W., Weiss, G., Chiang, D., and Angluin, D. What formal languages can transformers express? a survey.Trans. Assoc. Comput. Linguistics, 12:543–561,

work page
[7]

Suresh, T., Reddy, R

URL https://doi.org/10.1162/tacl_ a_00663. Suresh, T., Reddy, R. G., Xu, Y ., Nussbaum, Z., Mulyar, A., Duderstadt, B., and Ji, H. Cornstack: High-quality contrastive data for better code ranking, 2024a. URL https://arxiv.org/abs/2412.01007. Suresh, T., Ugare, S., Singh, G., and Misailovic, S. Is watermarking llm-generated code robust?, 2024b. URL https:/...

arXiv
[31]

logical conjunction of expr1 and expr2: expr1 {and} expr2

work page
[42]

logical disjunction of expr1 and expr2: expr1 {or} expr2

work page
[53]

logical exclusive disjunction of expr1 and expr2: expr1 {xor} expr2

work page
[64]

logical negation of expr1: {not}expr1

work page
[75]

expr1 implies expr2: expr1 {implies} expr2

work page
[86]

expr1 if and only if expr2: expr1 {iff} expr2

work page

Show all 17 references

[91]

emnlp-industry.91/

URL https://aclanthology.org/2024. emnlp-industry.91/. Team, Q. Qwq-32b: Embracing the power of reinforce- ment learning, March 2025. URL https://qwenlm. github.io/blog/qwq-32b/. Ugare, S., Gumaste, R., Suresh, T., Singh, G., and Mi- sailovic, S. Itergen: Iterative structured ...

2024 arXiv
[97]

logical universal quantification: {forall} x
[108]

These are the ONLY operations in the grammar

logical existential quantification: {exists} x. These are the ONLY operations in the grammar. 11------ 12 13Answer the question EXACTLY like the examples. 14 15Problem: 16All people who regularly drink coffee are dependent on caffeine. People either regularly drink coffee or j...

1946
[313]

URL http://dx.doi.org/10.18653/v1/ 2023.emnlp-main.313. OpenAI. Opneai tools, 2024. URL https://platform. openai.com/docs/assistants/tools. Pan, L., Albalak, A., Wang, X., and Wang, W. Y . Logic- lm: Empowering large language models with symbolic solvers for faithful logical r...

2023 arXiv
[2008]

ISBN 3540787992

Springer-Verlag. ISBN 3540787992. DeepSeek-AI, Guo, D., Yang, D., Zhang, H., Song, J., Zhang, R., Xu, R., Zhu, Q., Ma, S., Wang, P., Bi, X., Zhang, X., Yu, X., Wu, Y ., Wu, Z. F., Gou, Z., Shao, Z., Li, Z., Gao, Z., Liu, A., Xue, B., Wang, B., Wu, B., Feng, B., Lu, C., Zhao, C...

2025 arXiv
[2022]

URL https://openreview.net/forum? id=KmtVD97J43e. Qwen. Qwen2.5: A party of foundation models, September
[2024]

Merrill, W., Sabharwal, A., and Smith, N

URL https://openreview.net/forum? id=NjNGlPh8Wh. Merrill, W., Sabharwal, A., and Smith, N. A. Sat- urated transformers are constant-depth threshold cir- cuits.Transactions of the Association for Computa- tional Linguistics, 10:843–856, 2022. doi: 10.1162/tacl a 00493. URL http...

2022 arXiv
[3600]

<" "<" space? expr space?

- free_hours>>. The final answer is <<first_hour_cost + (int((end_hour - start_hour). total_seconds() / 3600) - free_hours - 1) * multiplier * first_hour_cost>>. 6 7CRANE: Let’s think step by step. The total time hired is from {start_hour} to {end_hour}, totaling << int(end_ho...
[8856]

De Moura, L

URL https://openreview.net/forum? id=YfZ4ZPt8zd. De Moura, L. and Bjørner, N. Z3: an efficient smt solver. InProceedings of the Theory and Practice of Software, 14th International Conference on Tools and Algorithms for the Construction and Analysis of Systems, TACAS’08/ETAPS’0...

Pith tools

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

[1] [6]

Strobl, L., Merrill, W., Weiss, G., Chiang, D., and Angluin, D

URL https://qwenlm.github.io/blog/ qwen2.5/. Strobl, L., Merrill, W., Weiss, G., Chiang, D., and Angluin, D. What formal languages can transformers express? a survey.Trans. Assoc. Comput. Linguistics, 12:543–561,

work page

[2] [7]

Suresh, T., Reddy, R

URL https://doi.org/10.1162/tacl_ a_00663. Suresh, T., Reddy, R. G., Xu, Y ., Nussbaum, Z., Mulyar, A., Duderstadt, B., and Ji, H. Cornstack: High-quality contrastive data for better code ranking, 2024a. URL https://arxiv.org/abs/2412.01007. Suresh, T., Ugare, S., Singh, G., and Misailovic, S. Is watermarking llm-generated code robust?, 2024b. URL https:/...

arXiv

[3] [31]

logical conjunction of expr1 and expr2: expr1 {and} expr2

work page

[4] [42]

logical disjunction of expr1 and expr2: expr1 {or} expr2

work page

[5] [53]

logical exclusive disjunction of expr1 and expr2: expr1 {xor} expr2

work page

[6] [64]

logical negation of expr1: {not}expr1

work page

[7] [75]

expr1 implies expr2: expr1 {implies} expr2

work page

[8] [86]

expr1 if and only if expr2: expr1 {iff} expr2

work page