Clause: Units in Logic, Legal, NLP & ML

• Clause is a domain-dependent unit and modular building block used in logic, legal drafting, NLP, and rule-based machine learning to represent local structure.
• Formalizations range from CNF disjunctions in automated reasoning and reusable contractual provisions in legal texts to discourse segmentation in NLP and AND-rules in Tsetlin machines.
• Techniques such as clause learning and dynamic selection enhance performance in search algorithms, theorem proving, neural verification, and complex legal retrieval tasks.

A clause is a domain-dependent formal or textual unit whose technical meaning varies across logic, automated reasoning, legal drafting, natural-language processing, programming languages, and rule-based machine learning. In the cited literatures, the term denotes, among other things, a disjunction of literals in QBF and description-logic normal forms, a reusable contractual provision in legal authoring, a discourse unit for clause-level semantic analysis, and an AND-rule in Tsetlin machines. What unifies these uses is not a single syntax, but a recurring role: clauses are the units through which systems represent local structure, compose global behavior, and control inference or generation (Giunchiglia et al., 2011, Takahashi et al., 2022, Aggarwal et al., 2021, Dai et al., 2018, Glimsdal et al., 2021).

Domain	Meaning of “clause”	Representative sources
Logic and reasoning	Disjunction of literals or learned proof object	(Giunchiglia et al., 2011, Takahashi et al., 2022)
Legal NLP	Contract provision with a specific legal function	(Aggarwal et al., 2021, Joshi et al., 2023, Wang et al., 11 Jan 2025)
Clause-level NLP	Discourse or segmentation unit within a paragraph or utterance	(Dai et al., 2018, Nandy, 30 Mar 2026, Goldman et al., 2022)
Rule-based ML	Conjunctive logical pattern that votes for outputs	(Glimsdal et al., 2021)

1. Formal meanings and semantic constructions

In clause-based reasoning, a clause is often a CNF object. For QBF in CNF, the clause is a finite disjunction of literals, assumed to be non-tautological and minimal, and falsity is witnessed by deriving the empty clause via Q-resolution. Q-resolution differs from propositional resolution in two ways: only existential pivots may be resolved, and the resolvent is minimized by deleting universal literals that violate the minimality condition. The same paper develops the dual notion of term resolution for truth proofs, making clauses the proof objects for falsity and terms the proof objects for truth (Giunchiglia et al., 2011).

In description logic $\mathcal{ALC}$, the clause is reinterpreted inside a CNF concept. A concept literal can be $A$, $\lnot A$, $\exists R.F$, or $\forall R.F$, and a clause is a disjunction

$CL = L_1 \sqcup \cdots \sqcup L_m.$

A CNF concept is then a conjunction of such clauses,

$F = CL_1 \sqcap \cdots \sqcap CL_n,$

represented operationally as a clause set. This preserves a clause-based search discipline while remaining within $\mathcal{ALC}$ syntax rather than classical first-order CNF (Takahashi et al., 2022).

A third formalization appears in the redesign of Prolog-like computation. There, a clause is not merely a head-body pair but an abstraction over call arguments, a continuation, and clause-local variables. Inclusive clauses correspond to disjunction across cases, while exclusive clauses correspond to if-then-else across cases. Clause sequencing is expressed by ordinary functional application and $\beta$-reduction, and a complete definition is obtained by “closing” an open clause chain with a failure continuation. This shifts clause order from an implicit operational mechanism to an explicit compositional object (Porto, 2011).

These formalisms show that “clause” is not a fixed syntactic primitive across fields. A plausible implication is that the persistence of the term reflects a shared modularity principle: a clause is the local unit from which a larger proof object, program, ontology, or search state is assembled.

2. Clauses as proof objects and learned constraints

Clause learning is central in search procedures because clauses can record the reason a branch fails and make that reason reusable. In QBF, this generalizes SAT-style nogood learning. The search tree generated by DLL corresponds to alternating clause- and term-resolution derivations, and learning is formalized by extending a QBF to an EQBF

$Q_1 z_1 \cdots Q_n z_n(\Psi,\Phi,\Theta),$

where $A$0 is a set of learned goods (terms) and $A$1 a set of learned nogoods (clauses). The paper also introduces Rec-C-Resolve to eliminate blocking universal literals during clause learning, and reports that learning in QuBE solved 16 instances the non-learning version did not solve, while the non-learning version solved only 1 instance missed by the learning version (Giunchiglia et al., 2011).

In neural-network verification, clause learning reappears in a CDCL(T)-style setting. Each ReLU phase is abstracted to a Boolean variable $A$2, and the verifier learns Boolean clauses over these phase variables from UNSAT proofs rather than merely blocking full assignments. Conflict clauses are extracted from Farkas-style proof vectors, optionally recursively incorporating lemma dependencies. Implemented via an IPASIR-UP interface, the proof-driven approach yields roughly 2X--3X improvement over a similar approach, with some cases outperforming the state of the art (Isac et al., 15 Mar 2025).

The same basic idea is generalized beyond Boolean SAT in the VarMonad framework. There, clause learning is obtained by tracking read operations before assignment in recursive programs over algebraic data types. The tracked reads become the dependency graph required for conflict analysis, and the learned clause becomes a generalized constraint that blocks a conflicting pattern of assignments rather than a traditional CNF disjunction. The paper does not present a full solver, but it makes the dependency extraction mechanism explicit enough to support one (Friedemann et al., 2022).

Across these settings, a clause is not just an input formula fragment. It is a reusable explanation of failure, propagation, or proof structure. This suggests that clause learning is best understood as a theory of reusable local certificates rather than as a SAT-specific trick.

3. Clause management and selection in automated reasoning

Once clauses are learned or generated in large numbers, performance depends on which ones are kept and which ones are selected next. In CDCL SAT, the learned-clause database is often split into permanent and temporary stores. An experimental study of MapleLCMDistChronoBT analyzes its three-way partition into Core, Tier2, and Local, with default insertion by LBD: $A$3 goes to Core, $A$4 to Local, and the rest to Tier2. Attempts to cap or shrink the permanent store were generally harmful. By contrast, sending all learned clauses with size $A$5 to the permanent store worked well, and combining this with selected high-centrality clauses improved performance from 184 solved instances to 197 on a 400-instance benchmark (Jamali et al., 2021).

A later SAT paper argues that the dominant LBD metric becomes ineffective on complex arithmetic circuit verification, especially multipliers, where LBD collapses toward clause length. It therefore proposes a fully LBD-free, two-stage reduction policy: Stage 1 keeps clauses with positive dynamic-usage score, updated by BCP and conflict-analysis participation and aged periodically; Stage 2 sorts zero-score clauses by descending length and deletes a fraction of the longest ones. On 60 multiplier LEC instances, kissat improved from 56 solved to 60, and PAR-2 dropped from 2841.65 to 1724.01 (Cai et al., 24 Feb 2026).

Clause selection has an analogous role in saturation-based theorem proving. In Vampire, one strategy measures how theory-heavy a clause’s derivation is by th-distance, then uses multi-split layered queues to prefer clauses with lower theory intensity while retaining a fallback queue over all passive clauses. On 20,795 selected SMT-LIB problems, the layered variants improved the 10-second default from 886 solved problems to 1176, and inserting the best configuration into the SMTCOMP2019 schedule raised solved problems from 5479 to 5629 (Gleiss et al., 2020).

The same decision point has also been framed as reinforcement learning. A neural clause scorer integrated into Vampire 4.9 uses a startup GNN, derivation-history and syntax RvNNs, and retrospective rewards from successful proof attempts. On TPTP v9.0.0 under a short instruction limit, the neurally guided prover improved over its baseline by about 20% on unseen problems, while being explicitly engineered for low per-clause evaluation cost (Suda, 10 Mar 2025).

A recurrent theme is that clause quality is not reducible to a single static statistic. Size, LBD, centrality, derivation lineage, dynamic use, and theory content are treated as distinct signals in the cited work.

4. Contract clauses in legal drafting, retrieval, and reasoning

In legal NLP, a clause is a contractual provision expressing a particular legal function, often involving obligations, permissions, or prohibitions. Contract-clause analysis has been formulated as a three-way NLI problem over a premise $A$6 and a hypothesis $A$7, with labels entailment, contradiction, and neutral. A decoder-only Transformer classifier trained on SNLI with about 570K sentence pairs reached 82.1% test accuracy on SNLI and transferred qualitatively to a Norm Conflict Dataset of contract clauses. It handled some deontic-modality and deontic-structure conflicts, but struggled with deontic-object and object-conditional cases, indicating heavy reliance on modal verbs and negation markers rather than deeper object-level semantics (Ichida et al., 2021).

Contract authoring work treats clauses as the natural unit of recommendation. ClauseRec is a two-stage pipeline that first predicts whether a target clause type is relevant to a contract and then recommends clause text for that type. It is built on ContractBERT, further pretrained on 250k contracts, and uses LEDGAR-derived proxy datasets from a corpus of around 60,000 contracts, 12,608 clause types, and 846,274 clauses. In parallel, later work on clause recommendation models the task as conditional generation $A$8 and studies strategies that combine current-contract context, clause type, and retrieved similar contracts. On the top 15 clause types, the strongest setting is CONTR_TYPE_FULLSIM, with overall performance around 39.26 ROUGE-L / 23.05 BLEU, showing that similar-contract retrieval helps most when clause type is explicitly provided (Aggarwal et al., 2021, Joshi et al., 2023).

Retrieval has also been isolated as a drafting benchmark. ACORD contains 114 unique queries, over 126,000 query-clause pairs, and 9 clause categories, each pair graded on a 1-to-5 star scale. It is explicitly expert annotated and released in BEIR format with an extension for 1-star judgments. The best reported system, Bi-Encoder-MiniLM + GPT-4o, achieves NDCG@5 = 79.1%, NDCG@10 = 81.2%, 4-star precision@5 = 62.1%, and 5-star precision@5 = 17.2%, underscoring that retrieving the best precedent clause remains difficult even when some relevant text is found (Wang et al., 11 Jan 2025).

A different legal benchmark, CLAUSE, stress-tests discrepancy detection in perturbed real-world contracts. It reports dataset totals of 4,711 CUAD contracts with 12,869 perturbations and 2,803 ContractNLI contracts with 11,086 perturbations, organized into 10 anomaly categories across legal and in-text contradictions. Human review of 25% of the dataset yielded a 98.58% validation rate, with Cohen’s $A$9 in $\lnot A$0. The benchmark finds that LLMs often localize issues better than they justify them legally, and that legal citation matching remains very weak, with the best reported law-match score below 14% (Choudhury et al., 1 Nov 2025).

Taken together, these results position the contract clause as both a drafting primitive and a reasoning unit: it is retrieved, generated, classified, compared, and audited at clause granularity rather than only at document level.

5. Clause-level modeling in NLP and morphology

Clause-level NLP treats the clause as a semantic or compositional unit whose interpretation depends on wider context. For situation entity type classification, a hierarchical recurrent architecture reads an entire paragraph, max-pools word-level Bi-LSTM states into clause embeddings, then contextualizes the clause sequence with a second Bi-LSTM. On the MASC+Wiki corpus, the paragraph-level model with CRF reaches 77.4 macro F1 / 80.7 accuracy, compared with 73.5 / 76.7 for a clause-only Bi-LSTM, and approaches reported human performance of 78.6 macro F1 / 79.6 accuracy (Dai et al., 2018).

Clause factorization has also been used as an inductive bias for compositional generalization. ClauseCompose trains only on singleton intents, segments a test utterance into clauses using a small discourse-marker grammar, classifies each segment independently, and greedily builds the final intent set while discouraging duplicates. On CoMIX-Shift, it achieves 95.7 exact match on unseen intent pairs, 93.9 on discourse-shifted pairs, 62.5 on longer/noisier pairs, 49.8 on held-out templates, and 91.1 on zero-shot triples, substantially outperforming whole-utterance baselines on shifted settings (Nandy, 30 Mar 2026).

The clause has also been proposed as the proper unit for morphology. MightyMorph replaces word-level paradigms with clause-level forms $\lnot A$1 realizing a lexeme $\lnot A$2 and a feature bundle $\lnot A$3 over a saturated clause. The dataset covers English, German, Turkish, and Hebrew, and defines clause-level inflection, reinflection, and analysis tasks. The reported result is not that clause-level morphology is easier, but that it is substantially harder than word-level morphology while exhibiting comparable complexity across languages, because it no longer depends on a language-specific notion of “word” (Goldman et al., 2022).

A common misconception is that clause-level modeling merely adds a segmentation step. The cited work instead treats clause structure as a representational commitment: paragraph semantics, multi-intent compositionality, and cross-linguistic morphology are all redefined around the clause as the locus of interpretation.

6. Clauses as reusable computational patterns

In Tsetlin machines, a clause is a conjunctive propositional pattern—an AND-rule over literals such as $\lnot A$4. Standard TMs allocate separate clause sets per output, but the Coalesced Tsetlin Machine (CoTM) introduces clause sharing: each clause is connected to each output by a learned signed weight, with positive weights voting for output 1 and negative weights for output 0. The model jointly learns clause composition through Tsetlin Automata and clause-output weights through Stochastic Searching on the Line. The empirical effect is strongest in low-clause regimes; for example, on Fashion-MNIST with 50 clauses per class, accuracy rises from 71.99% to 89.66%, and on MNIST with 8K clauses CoTM reaches peak accuracy about 3× faster than the baseline TM (Glimsdal et al., 2021).

Clause structure has even been exploited in quantum search. For clause satisfaction problems with $\lnot A$5 Boolean clauses $\lnot A$6, the standard Grover oracle would require computing the conjunction $\lnot A$7, creating coupling among clause circuits. A tailored alternative instead assigns each clause its own diagonal phase operator $\lnot A$8, multiplies them into a commuting product oracle $\lnot A$9, and searches using an iterate $\exists R.F$0. The implementation advantage is that it avoids explicit circuit-level AND-coupling across all clause computations while retaining $\exists R.F$1 scaling when the problem-dependent factor $\exists R.F$2 is $\exists R.F$3 (Tulsi, 2015).

These uses are far from the legal or linguistic senses of the term, but they preserve the same structural intuition: a clause is a local constraint or pattern that can be composed, weighted, shared, or phase-encoded to drive a larger computation.