Proof-Carrying Neuro-Symbolic Reasoning for Non-Monotonic Legal Decision Support with LLMs

Abstract

Large language models (LLMs) and retrieval-augmented generation (RAG) are increasingly used in legal decision support, but retrieved evidence and fluent explanations do not guarantee valid normative inference. This paper proposes a proof-carrying neuro-symbolic method for non-monotonic legal reasoning. The LLM component is restricted to source-linked extraction of facts, defeasible rules, defeaters, priorities, citations, and operational confidence scores, while a deterministic symbolic engine computes the conclusion. Evidence is represented as a finite defeasible normative theory and compiled into a Dung-style argumentation framework; accepted conclusions are obtained from the grounded extension and returned with proof graphs showing support, attacks, and priority-based defeats. Under gold formalization, the symbolic engine achieved 99.3% accuracy on a 600-case controlled benchmark. In a 240-scenario LLM-to-logic experiment, the GPT-4o extractor followed by symbolic reasoning achieved 86.7% downstream accuracy versus 75.8% for a direct LLM over the same retrieved evidence; the paired difference was supported by an exact McNemar test after Holm correction (adjusted p = 0.016). Differences from the PDL and simpler symbolic baselines were not statistically established. Validation-triggered repair yielded 90.4% observed accuracy. Public-contract, Russian-law, stress-test, scalability, and lawyer-verification experiments further delimit the feasibility and current limitations of proof-carrying legal decision support.

1. Introduction

Large language models (LLMs) and retrieval-augmented generation (RAG) architectures have become a practical foundation for document-intensive decision support [1,2]. In legal, contractual, and regulatory settings, such systems are expected to identify applicable provisions, assess compliance with obligations, evaluate exceptions, and explain the evidential basis of a conclusion. The central requirement is not merely linguistic plausibility, but verifiable reasoning grounded in explicit evidence.

Legal documents differ from general information corpora because their meaning is structurally and normatively interdependent. A clause frequently receives its operational meaning only in combination with definitions, annexes, exceptions, hierarchy of norms, deadlines, procedural requirements, monetary thresholds, and cross-references. Consequently, a standard RAG pipeline may retrieve apparently relevant fragments while still failing at the level of legal inference: a model may retrieve a penalty clause and overlook force majeure, identify a general obligation but fail to apply a more specific exception, or cite correct text while resolving a priority conflict incorrectly.

This paper addresses the post-retrieval layer of the problem. We assume that a retrieval subsystem supplies source-linked evidence fragments and ask how a decision-support system should reason over those fragments without delegating the final normative conclusion to unconstrained generation. The proposed answer is a hybrid neuro-symbolic method: the neural component extracts structured facts and candidate rules from natural-language evidence, whereas the symbolic component performs non-monotonic inference over a finite theory with explicit priorities and traceable proof objects.

The central hypothesis is that verifiable legal decision support requires a separation between perception and reasoning. LLMs are useful for interpreting variable natural-language documents and mapping them to candidate atoms, rules, and citations. However, the acceptance or rejection of a legal conclusion should be handled by a deterministic symbolic engine with explicit semantics. This separation does not remove extraction errors, but it localizes them: when the output is wrong, the error can be attributed to evidence retrieval, LLM-to-logic extraction, priority recognition, or symbolic reasoning.

The contribution is also relevant to big data and cognitive computing. The method treats evidence spans, extracted rules, argument graphs, proof edges, validation logs, and user verification traces as structured data that can be indexed, audited, and reused. At the same time, proof graphs provide a cognitive interface for human verification, reducing the need to inspect long legal texts from scratch. This connects scalable document processing with explainable human-centered decision support.

The contributions are fivefold. First, we introduce a source-linked defeasible deontic theory for legal evidence. Second, we define argument construction and priority-sensitive defeat compilation into a Dung-style argumentation framework. Third, we provide a proof-carrying explanation protocol and an independently executable verification function. Fourth, we specify conservative handling of incomplete and cyclic priorities, including explicit abstention when legal metadata do not justify an ordering. Fifth, we define a bounded validation-and-repair interface that converts extraction failures into typed diagnostics, targeted re-extraction, or human-review flags. The empirical comparisons are not claimed as a separate scientific contribution; they test the formal and architectural claims under controlled, extraction-noisy, public-data, scalability, and human-verification conditions.

2. Related Work

2.1. Legal RAG, Contract Datasets, and Retrieval Failure Modes

RAG reduces reliance on parametric memory by retrieving external evidence at inference time [1,2]. This improves factual grounding but does not make legal reasoning valid by construction. In legal corpora, retrieval quality sets an upper bound on answer quality: if relevant exceptions, definitions, annexes, or superior norms are missing, the generated answer is incomplete even when the model is fluent.

ContractNLI introduced document-level natural language inference for contracts and requires systems to classify contract hypotheses while identifying evidence spans; it explicitly emphasizes the difficulty created by negations and exceptions [3]. CUAD provides expert-annotated clauses across commercial contracts [4], and MAUD provides expert annotations over merger agreements [5]. LegalBench and LawBench broaden the evaluation of LLM legal reasoning to multiple task families [6,7]. These datasets motivate the need for source-grounded evaluation, but they do not by themselves provide formal acceptance semantics for exceptions and priorities.

Recent legal RAG work emphasizes document-level mismatch, long-context retrieval, evidence citation, and reasoning-focused retrieval [8,9]. The present paper is complementary: it holds the evidence package fixed and focuses on post-retrieval normative inference. Here, a source is an identifiable span in a legal document or authoritative external norm included in the corpus, not a software system or model endpoint. A source pointer contains a document identifier, structural path, and start/end offsets sufficient to recover the cited span.

2.2. Defeasible Deontic Logic and LegalRuleML

Legal reasoning is naturally defeasible. A general rule may support a conclusion, but the conclusion can be withdrawn when an exception, a more specific rule, or a superior norm becomes applicable. Classical monotonic logic is too rigid for this setting because adding information can only increase the set of conclusions, whereas legal interpretation often retracts a provisional conclusion.

Defeasible logic and deontic defeasible logic provide rule-based mechanisms for representing obligations, permissions, prohibitions, exceptions, and priorities [10,11,12,13]. LegalRuleML is a rich interchange standard for representing sources, temporal properties, defeasibility, and deontic modalities [14]. It does not, however, prescribe a natural-language formalization pipeline, a unique inference engine, or a source-grounded acceptance semantics. The present method therefore treats LegalRuleML as a compatible representation layer rather than characterizing it as inherently dependent on manual rule authoring.

2.3. Abstract and Structured Argumentation

Structured argumentation systems such as ASPIC+ provide rich internal argument structure and are well suited for reconstructing legal arguments [15]. Carneades and related models also provide mechanisms for burden of proof and dialectical evaluation [16]. Dung abstract argumentation frameworks provide a simpler acceptance layer in which arguments are nodes and attacks are edges; grounded semantics returns a skeptical extension that is unique for every finite framework [17].

This paper uses abstract argumentation as the computational acceptance layer while preserving the source-linked rule structure outside the graph for explanation. The choice is deliberate. Fully structured argumentation is expressive but heavier to instantiate from noisy LLM output. Classical defeasible logic is efficient but less directly aligned with visual proof graphs and attack-based explanation. The Dung abstraction provides a compact polynomial-time acceptance layer and a clear proof object for decision support.

2.4. Probabilistic and Bayesian Alternatives

Probabilistic graphical models, probabilistic soft logic, Bayesian networks, and discriminative classifiers are natural alternatives when legal evidence is uncertain [18]. They can represent noisy extraction, missing facts, and confidence-weighted rule activation. However, probability alone does not decide which exception legally defeats another unless priority semantics is encoded externally. Therefore, we include a probabilistic defeasible-logic (PDL) classifier as a baseline: it receives structured features extracted from the same theory and returns the most probable legal outcome without constructing an explicit attack graph.

2.5. Neuro-Symbolic Solver Offloading and Legal Compilation

Logic-LM and LINC established a modular pattern in which an LLM translates natural-language problems into a symbolic language and an external solver performs inference [19,20]. Logic-LM additionally uses solver error messages for self-refinement, whereas LINC samples alternative first-order-logic formalizations and aggregates prover outputs. These studies demonstrate the value of solver offloading, but their core tasks are monotonic logical entailment rather than source-linked defeasible legal inference with exceptions, explicit priorities, and proof objects for accepted and defeated legal arguments.

Sójka and Kowalczyk proposed Deterministic Autonomous Contract Language (DACL), which compiles commercial contracts into a typed execution graph and amortizes interpretation across repeated transactions [21]. That work provides strong evidence for deterministic execution, cost reduction, and structural audit trails. Its stated scope excludes defeasible reasoning and open-textured standards; by contrast, the present work concentrates on non-monotonic acceptance, nested exceptions, unresolved conflicts, and skeptical proof graphs. The two approaches are therefore complementary: DACL emphasizes repeated execution of computational clauses, whereas the present method formalizes contestable normative conclusions after retrieval.

The differentiating contribution is thus not solver offloading alone. It is the combination of source-span provenance, defeasible and defeater rules, explicit legal priorities, grounded acceptance, conservative abstention, and a proof verifier that checks both supporting and defeated arguments.

Table 1 summarizes the relationship between evidence-oriented, symbolic, probabilistic, and solver-offloading approaches and the specific gap addressed by the proposed method.

Table 1. Positioning of the proposed method relative to prior work.

Research Direction	Main Contribution	Remaining Gap Addressed Here
Legal RAG	Retrieves source material and citations for LLM answers	Does not guarantee valid inference over exceptions and priorities
ContractNLI, CUAD, MAUD	Provide contract-level annotation and evidence spans	Do not define non-monotonic acceptance semantics
Defeasible logic/LegalRuleML [10,11,12,13,14]	Represent rules, defeaters, priorities, sources, and deontic modalities	Do not prescribe source-grounded LLM extraction plus a unique proof protocol
ASPIC+/structured argumentation [15]	Provides rich internal argument reconstruction	Higher modeling overhead for noisy LLM-to-logic extraction
Dung abstract argumentation [17]	Provides skeptical grounded acceptance over attack graphs	Requires an external source-linked rule representation for audit
Probabilistic rule models [18]	Model uncertainty and confidence-weighted evidence	Require explicit legal priority semantics to resolve normative conflict
Logic-LM/LINC [19,20]	Offload monotonic logical inference from an LLM to a solver	Do not address defeasible legal priority or source-linked defeat proofs
DACL offloading [21]	Compiles computational contract clauses into deterministic execution graphs	Does not model defeasible reasoning or unresolved normative conflict
Proposed method	Combines validated extraction, defeasible theory, grounded acceptance, and proof verification	Targets contestable legal conclusions under noisy extraction

Interpretation. Legal RAG and contract datasets provide evidence and annotations, while defeasible logic and argumentation provide formal semantics. The proposed method targets the gap between these two groups by connecting noisy source-linked extraction with deterministic non-monotonic acceptance and auditable proof objects.

3. Materials and Methods

3.1. Problem Statement and Evidence Package

Let C be a legal or regulatory corpus consisting of contracts, appendices, annexes, policies, and external norms. A user submits a decision-relevant query q, where q is a ground target literal to be evaluated. A retrieval layer returns a finite evidence package Eτ = {e₁, …, e_m}. Each evidence unit is a tuple e_i = ⟨doc-id_i, path_i, span_i, text_i, meta_i⟩. The citation range span_i is the pair of start and end character offsets within the versioned document identified by doc-id_i; path_i records the human-readable structural location, such as the section, clause, or appendix.

Extraction, reasoning, and proof generation are distinct typed functions. The extractor Xθ maps an evidence package and query to a candidate theory; the reasoner R maps a validated theory to a set of skeptically accepted literals; and the proof generator Π maps an accepted literal and its theory to a proof graph. The reported decision yτ(q) is Positive when q is accepted, Negative when comp(q) is accepted, and Undetermined otherwise.

$$\begin{array}{cccc}\hfill {\mathcal{T}}_{\tau }& =X_{\theta }\left(E_{\tau },q\right),\hfill & C_{\tau }\hfill & =R\left({\mathcal{T}}_{\tau }\right),\hfill \\ \hfill y_{\tau }\left(q\right)& =\left\{\begin{array}{ll}\mathrm{P}\mathrm{o}\mathrm{s}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{v}\mathrm{e},& q\in C_{\tau };\\ \mathrm{N}\mathrm{e}\mathrm{g}\mathrm{a}\mathrm{t}\mathrm{i}\mathrm{v}\mathrm{e},& \mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\left(q\right)\in C_{\tau };\\ \mathrm{U}\mathrm{n}\mathrm{d}\mathrm{e}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{m}\mathrm{i}\mathrm{n}\mathrm{e}\mathrm{d},& \mathrm{otherwise},\end{array}\right.\hfill & G_c\hfill & =\Pi \left(c,{\mathcal{T}}_{\tau }\right), c\in C_{\tau }.\hfill \end{array}$$

(1)

3.2. Formal Language L

We define a many-sorted legal language L over cases, parties, objects, events, actions, dates, and amounts. The variable x ranges over cases unless a different sort is stated. Let P be a finite vocabulary of typed predicate templates, including Delay(x), ValidContract(x), ForceMajeure(x), NoticeMissing(x), GrossNegligence(x), and NoticeWaived(x). For a finite evidence package Eτ, substitution of typed constants for variables produces a finite set Aτ of ground legal atoms, such as Delay(case_17). Strong negation is written as ¬p. The complement function comp satisfies comp(p) = ¬p and comp(¬p) = p.

Deontic literals are formed by applying Obl, Perm, and Forb to a ground action term. We normalize Forb(a) as Obl(¬a). Normative opposition is explicit rather than inferred from surface negation alone: Obl(a) conflicts with Forb(a), and a source-defined strong permission Perm(a) conflicts with Forb(a) when the permission operates as an exception. No unrestricted modal closure is assumed. Before use, ClaimPenalty(c, s, x) denotes customer c asserting a contractual penalty against supplier s in case x, and RejectPenaltyClaim(s, c, x) denotes supplier s rejecting that claim. EnforceablePenalty(x) is a compact legal-consequence atom; the same case may instead be encoded through deontic literals when the source expresses an obligation, prohibition, or strong permission.

Definition 1 (literal language). 

Litτ is the closure of the finite ground atom set Aτ under strong negation and the ground deontic operators Obl, Perm, and Forb, subject to the normalization and explicit-conflict conventions above.

3.3. Defeasible Normative Theory

A defeasible normative theory contains facts, rules, a priority relation, an explicit rule-conflict relation, and source provenance. Fτ is a finite set of ground facts; Rτ is a finite set of rules; ≻τ is a strict partial order over rules; ⋈τ is a symmetric, source-linked relation identifying rules that address the same normative issue and can rebut or undercut one another; and στ maps every fact, rule, asserted conflict, and priority to a source pointer. A rule r is the tuple ⟨id(r), Ant(r), Cons(r), type(r), target(r), src(r), conf(r), meta(r)⟩, with type(r) ∈ {strict, defeasible, defeater}. Strict and defeasible rules derive Cons(r) ∈ Lit. A defeater derives only a blocker token block(target(r)); it can defeat the targeted rule but never enters the set of reported legal conclusions. The operational score conf(r) ∈ [0, 1] is used only for review routing and is never a substitute for a legal priority.

Definition 2 (defeasible normative theory). 

$𝒯$τ = ⟨Fτ, Rτ, ≻τ, ⋈τ, στ⟩.

Definition 3 (rule activity). 

For a set S of already constructed subarguments, let concl(S) = {Conc(A) | A ∈ S}. A rule r is active relative to S exactly when every antecedent is either a fact in Fτ or the conclusion of a subargument in S. For strict and defeasible rules, out(r) = Cons(r); for a defeater, out(r) = block(target(r)). Blocker tokens are available only to the attack layer and cannot answer the legal query.

$$\mathrm{a}\mathrm{c}\mathrm{t}\mathrm{i}\mathrm{v}\mathrm{e}\left(r,S\right)\iff \mathrm{A}\mathrm{n}\mathrm{t}\left(r\right)\subseteq F_{\tau }\cup \{\mathrm{C}\mathrm{o}\mathrm{n}\mathrm{c}\left(A\right)\mid A\in S\}.$$

(2)

Example 1 is a hypothetical composite created by the authors to illustrate the formalism; it is not a verbatim clause from the benchmark and is not legal advice. Table 2 maps its clauses to defeasible rules, nested exceptions, procedural exceptions, and priority overrides.

Table 2. Example mapping from legal text to defeasible rules and priorities.

Natural-Language Clause	Formal Representation	Role
If the supplier delays delivery, the customer may claim a penalty.	r1: ValidContract(x), Delay(x) ⇒ EnforceablePenalty(x)	Defeasible general rule
If delay is caused by force majeure, the penalty is not payable.	r2: ForceMajeure(x) ⇒ ¬EnforceablePenalty(x); r2 ⋈ r1; r2 ≻ r1	Defeasible exception
If force majeure was caused by gross negligence, the exception does not apply.	r3: ForceMajeure(x), GrossNegligence(x) ⇒ EnforceablePenalty(x); r3 ⋈ r2; r3 ≻ r2	Exception to the exception
If mandatory notice is not sent, the claim is not enforceable.	r4: NoticeMissing(x) ⇒ ¬EnforceablePenalty(x); r4 ⋈ r1; r4 ≻ r1	Procedural exception
If the contract waives prior notice, missing notice does not block the claim.	r5: NoticeWaived(x) ⇒ EnforceablePenalty(x); r5 ⋈ r4; r5 ≻ r4	Exception to the procedural exception

In Table 2, r₂ ≻ r₁ means that r₂ is stronger than r₁ within their declared conflict pair r₂ ⋈τ r₁. Neither relation is inferred from numerical identifiers or from merely having opposite conclusions. A conflict pair and any priority must be supported by an explicit exception, hierarchy, specificity relation, or other source-linked legal basis; otherwise the conflict remains unresolved. All five rules in the example are derivational defeasible rules. A true defeater would instead conclude block(target(r)) and would not derive a reportable legal literal.

3.4. Hybrid Architecture and Schema-Constrained Extraction

The architecture contains a retrieval layer, an LLM-based extraction layer, a deterministic validation-and-repair layer, a symbolic non-monotonic reasoning layer, and a proof-oriented decision-support interface. The extractor is not asked to produce the final legal answer; it emits only schema-constrained facts, rules, rule types, source-scoped conflict pairs, priorities, source pointers, and operational confidence scores.

The validator operates in four stages. First, JSON Schema validation checks required fields, enumerated rule types, identifiers, and value ranges. Second, symbol-table validation checks predicate arity, variable grounding, antecedent references, duplicate identifiers, defeater targets, and missing rule targets. Third, provenance validation verifies that each cited source unit exists and that its span lies within the versioned evidence text. Fourth, graph validation checks that conflict and priority endpoints exist, every priority applies within a declared conflict pair, priority direction is source-supported, and the priority graph is acyclic or explicitly routed to repair. Every failure is emitted as a typed diagnostic ⟨code, object-id, source-span, severity, repairable⟩.

The repair loop is bounded. Pure serialization defects are normalized deterministically. Any repairable validator failure triggers one targeted pass in which the extractor receives only the failed object, its diagnostic, the query, and the smallest relevant source neighborhood. The replacement is revalidated before it can enter the reasoner. A second failed repair, an unsupported priority, or an unresolved conflict yields Undetermined and a human-review flag. Confidence is retained as review metadata but is not used as an undocumented automatic threshold. This condition is therefore called validation-triggered repair throughout the paper.

The current confidence field is elicited as part of the extractor JSON and is not computed from provider logits or calibrated against outcome frequencies. It is therefore interpreted only as a triage signal. Future deployments should calibrate it on held-out legal extraction data before using it to allocate review resources.

Figure 1 shows the complete architecture, including schema-constrained extraction, validation, symbolic reasoning, proof storage, and decision-support output. This figure should be read from left to right as a separation-of-responsibilities diagram. The LLM is used only for schema-constrained extraction, while validation, symbolic reasoning, grounded acceptance, and proof storage are separated into deterministic or auditable stages.

Figure 1. Hybrid neuro-symbolic architecture with schema-constrained extraction, validation, priority repair, symbolic non-monotonic reasoning, proof storage, and decision-support output.

Example constrained extractor output:

{“facts”: [{“atom”: “Delay(case_17)”, “source”: “contract:5.1”, “confidence”: 0.94}], “rules”: [{“id”: “r1”, “antecedents”: [“ValidContract(x)”, “Delay(x)”], “type”: “defeasible”, “consequent”: “EnforceablePenalty(x)”, “source”: “contract:5.2”, “confidence”: 0.91}], “conflicts”: [{“left”: “r2”, “right”: “r1”, “source”: “contract:12.4”}], “priorities”: [{“stronger”: “r2”, “weaker”: “r1”, “source”: “contract:12.4”}] }

Algorithm 1 specifies the proof-carrying LLM-to-NMR reasoning pipeline used throughout the experiments.

Algorithm 1. Proof-carrying LLM-to-NMR legal reasoning pipeline

Input: source-linked evidence package Eτ and query q. 1: Retrieve evidence units and preserve document identifiers, structural paths, span offsets, and metadata. 2: Run the schema-constrained LLM extractor X(Eτ, q) to obtain candidate facts, rules, rule types, source-scoped conflict pairs, priorities, source pointers, and confidence values. 3: Validate $𝒯$τ and emit typed diagnostics for schema, type, grounding, provenance, priority, and cycle violations. 4: Apply deterministic normalization or one targeted LLM repair pass to repairable objects; revalidate the replacement and flag unresolved defects for human review. 5: Repair source-supported cyclic priorities with the legal meta-priority key; leave unsupported legal ties unresolved. 6: Construct arguments from facts and active rules until the least fixed point is reached: strict and defeasible rules derive legal literals, whereas defeaters derive only targeted blocker tokens. 7: Compile source-scoped rule conflicts and priority-sensitive defeats into AF($𝒯$τ) = ⟨Arg($𝒯$τ), Defeatτ⟩. 8: Compute the grounded extension GE(AF) by iterating the characteristic function from the empty set. 9: Return Cτ, Undetermined flags, validation/repair logs, and Π(c) for every accepted legal conclusion c. Output: skeptical legal conclusions, review flags, and source-linked proof objects.

3.5. Argument Construction

An argument A is a finite proof object ⟨Prem(A), Rules(A), Conc(A), top(A)⟩, where Prem(A) is the set of factual premises, Rules(A) is the set of applied rules, Conc(A) is either a legal literal or a blocker token, and top(A) is the last applied rule. For an atomic fact argument, top(A) = ⊥.

Definition 4 (argument construction). 

Let 𝒜₀ = {⟨{f}, ∅, f, ⊥⟩ | f ∈ Fτ}. For a ground rule r with k antecedents, Match(r,S) is the set of ordered tuples (A₁, …, A_k) ∈ (S ∪ 𝒜₀)^k whose conclusions match the antecedents of r in their declared order. For each (A₁, …, A_k) ∈ Match(r,S), let P_r = Prem(A₁) ∪ … ∪ Prem(A_k) and U_r = Rules(A₁) ∪ … ∪ Rules(A_k) ∪ {r}; the new argument concludes out(r). Equation (3) defines the construction operator, and Arg($𝒯$τ) is its least fixed point. Rule schemas are finitely grounded over constants in Eτ, and validation rejects grounded dependency cycles and repeated use of the same rule instance on an argument branch. These conditions make the set of canonical argument signatures finite.

$$\begin{array}{cc}\hfill {\mathcal{B}}_{\mathcal{T}}\left(S\right)& ={\mathcal{A}}_0\cup \{⟨P_r,U_r,\mathrm{o}\mathrm{u}\mathrm{t}\left(r\right),r⟩\mid r\in R_{\tau },\hspace{0.25em}({\mathrm{A}}_1,\dots ,{\mathrm{A}}_{\mathrm{k}})\in \mathrm{M}\mathrm{a}\mathrm{t}\mathrm{c}\mathrm{h}\left(r,S\right)\},\hfill \\ \hfill \mathrm{A}\mathrm{r}\mathrm{g}\left({\mathcal{T}}_{\tau }\right)& =\mathrm{l}\mathrm{f}\mathrm{p}\left({\mathcal{B}}_{\mathcal{T}}\right).\hfill \end{array}$$

(3)

3.6. Attacks, Defeats, and Grounded Extension

Two arguments are potential attackers only when the attacker’s top rule conflicts with the top rule of the target argument or one of its subarguments. For two derivational rules, a conflict pair requires complementary legal effects in the same issue and scope; for a defeater, it records the specific rule that the blocker undercuts. This prevents unrelated arguments with superficially opposite conclusions from creating all-pairs cross-attacks and propagates a successful attack on a premise through the containing argument. Priority filters attacks into defeats relative to the attacked subargument. If neither rule is stronger within a declared conflict pair, both directions remain as mutual defeats, allowing grounded semantics to return Undetermined.

Equation (4) defines attack and defeat using the explicit conflict scope. For S ⊆ Arg($𝒯$τ), Dung’s characteristic function ΓAF(S) returns every argument defended by S [17]. Equations (5)–(7) define the grounded extension and accepted legal conclusions. Because blocker tokens are not members of Lit, accepted defeaters can defend other arguments without becoming reportable legal outcomes.

$$\begin{array}{cc}\hfill {\mathrm{A}\mathrm{t}\mathrm{t}\mathrm{a}\mathrm{c}\mathrm{k}}_{\tau }& =\{\left(A,B\right)\mid \exists B^{\prime }⊑B:\hspace{0.25em}\mathrm{t}\mathrm{o}\mathrm{p}\left(A\right){\bowtie }_{\tau }\mathrm{t}\mathrm{o}\mathrm{p}\left(B^{\prime }\right)\},\hfill \\ \hfill {\mathrm{D}\mathrm{e}\mathrm{f}\mathrm{e}\mathrm{a}\mathrm{t}}_{\tau }& =\{\left(A,B\right)\mid \exists B^{\prime }⊑B:\hspace{0.25em}\mathrm{t}\mathrm{o}\mathrm{p}\left(A\right){\bowtie }_{\tau }\mathrm{t}\mathrm{o}\mathrm{p}\left(B^{\prime }\right)\wedge \neg \left(\mathrm{t}\mathrm{o}\mathrm{p}\left(B^{\prime }\right){\succ }_{\tau }\mathrm{t}\mathrm{o}\mathrm{p}\left(A\right)\right)\},\hfill \\ \hfill AF\left({\mathcal{T}}_{\tau }\right)& =⟨\mathrm{A}\mathrm{r}\mathrm{g}\left({\mathcal{T}}_{\tau }\right),{\mathrm{D}\mathrm{e}\mathrm{f}\mathrm{e}\mathrm{a}\mathrm{t}}_{\tau }⟩.\hfill \end{array}$$

(4)

$${\Gamma }_{AF}\left(S\right)=\{A\in \mathrm{A}\mathrm{r}\mathrm{g}\left({\mathcal{T}}_{\tau }\right)\mid \forall B\hspace{0.17em}\left(\left(B,A\right)\in {\mathrm{D}\mathrm{e}\mathrm{f}\mathrm{e}\mathrm{a}\mathrm{t}}_{\tau }\Rightarrow \exists C\in S\hspace{0.17em}\left(\left(C,B\right)\in {\mathrm{D}\mathrm{e}\mathrm{f}\mathrm{e}\mathrm{a}\mathrm{t}}_{\tau }\right)\right)\}.$$

(5)

$$S_0=⌀, S_{i+1}={\Gamma }_{AF}\left(S_i\right), GE\left(AF\right)=\bigcup _{i\ge 0}{S}_i=lfp\left({\Gamma }_{AF}\right).$$

(6)

$$C_{\tau }=\{Conc\left(A\right)\in Lit\mid A\in GE\left(AF\left({\mathcal{T}}_{\tau }\right)\right)\}.$$

(7)

3.7. Priority Repair and Cyclic Priorities

The priority relation must be a strict partial order restricted to declared conflict pairs. Extracted priorities may nevertheless be incomplete, inconsistent, or cyclic. The validator preserves explicit source-linked priorities and compares a lexicographic legal key κL only within a cyclic component. Authority is ordered by the governing source hierarchy; specificity is ordered by strict inclusion of the rules’ validated factual and legal scope; effective date is used only when the governing instrument authorizes temporal precedence; and directness orders primary operative text above an explicit cross-reference and an inferred relation. Extraction confidence and identifiers are excluded.

For each strongly connected component, an edge is reoriented only when the first differing κL component yields a strict, source-verifiable comparison. If a hierarchy is inapplicable, scope inclusion cannot be established, temporal precedence is not legally authorized, or all applicable components tie, the cycle remains unresolved. The affected query is then Undetermined and a human-review flag is emitted. The complete component-wise comparison and source basis are written to the repair log.

$${\kappa }_L\left(r\right)=⟨\mathrm{a}\mathrm{u}\mathrm{t}\mathrm{h}\mathrm{o}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{y}\left(r\right),\mathrm{s}\mathrm{p}\mathrm{e}\mathrm{c}\mathrm{i}\mathrm{f}\mathrm{i}\mathrm{c}\mathrm{i}\mathrm{t}\mathrm{y}\left(r\right),\mathrm{e}\mathrm{f}\mathrm{f}\mathrm{e}\mathrm{c}\mathrm{t}\mathrm{i}\mathrm{v}\mathrm{e}\mathrm{D}\mathrm{a}\mathrm{t}\mathrm{e}\left(r\right),\mathrm{d}\mathrm{i}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{t}\mathrm{n}\mathrm{e}\mathrm{s}\mathrm{s}\left(r\right)⟩.$$

(8)

Table 3 details the meta-priority repair procedure used when extracted priority relations are cyclic or inconsistent. The repair procedure is designed as a safety mechanism rather than as an optimization trick. Its key property is that priority conflicts are resolved only when legal metadata supports a reproducible ordering; otherwise, the affected conclusion remains Undetermined and is escalated for human review.

Table 3. Meta-priority repair procedure for cyclic or inconsistent priorities.

Step	Operation	Output
1	Build priority graph G_P = (Rτ, ≻τ)	Candidate priority graph
2	Detect strongly connected components	Cyclic components
3	Compare explicit sources and κL	Legally supported ordering or tie
4	Orient only source-supported strict comparisons	Acyclic repaired relation
5	Preserve unresolved ties and escalate	Undetermined + human-review flag

3.8. Formal Properties

Proposition 1 (existence and uniqueness of grounded conclusions). 

For every theory $𝒯$τ that passes schema, finite-grounding, dependency-cycle, and priority validation, AF($𝒯$τ) is finite and its grounded extension exists and is unique. Therefore, Cτ is uniquely defined.

Proof sketch. 

Finite grounding produces finitely many rule instances. The dependency-cycle and no-repeated-instance conditions bound every argument branch, so only finitely many canonical argument signatures can be constructed. Dung’s characteristic function is monotone over the complete lattice of subsets of this finite Arg($𝒯$τ); by the Knaster–Tarski fixed-point theorem it has a least fixed point, reached by iteration from the empty set in finitely many steps. □

Proposition 2 (reproducibility of symbolic inference). 

For fixed Fτ, Rτ, ≻τ, ⋈τ, στ and a deterministic construction procedure, repeated runs of the reasoning engine return the same accepted conclusions and proof graph up to isomorphism.

Proof sketch. 

All construction steps are deterministic set operations over finite inputs: validation, rule activation, argument construction, defeat construction, priority repair, and fixed-point iteration. □

Proposition 3 (conflict safety under grounded semantics). 

If arguments for p and ¬p attack each other and neither side is defended by a stronger accepted argument, neither p nor ¬p is accepted.

Proof sketch. 

In a mutual unattacked cycle, ΓAF(∅) excludes both arguments because each has an attacker and no defender. Unless an external accepted defender defeats one attacker, the least fixed point excludes both arguments. □

3.9. Proof-Carrying Explanation and Verification

For every accepted conclusion c ∈ Cτ, a deterministic proof generator traverses backward from each accepted root argument through its subarguments, attaches source-linked fact and rule nodes, and adds the complete set of direct attackers of the root and of every displayed subargument, together with the accepted defenders and priority edges that defeat them. The resulting graph Gc = ⟨Vc, Ec, labelc, srcc⟩ is serialized as JSON and may be rendered as a graph visualization; no LLM creates graph edges.

Equation (9) abbreviates four deterministic checks. RootOK requires the displayed root to conclude c and belong to the grounded extension. SourceOK requires every factual leaf to belong to Fτ, every rule node to belong to Rτ, and all displayed facts, rules, conflicts, and priorities to have valid στ pointers. EdgeOK requires each support edge to instantiate a rule antecedent, each defeat edge to belong to Defeatτ, and each priority to be explicit or recorded in the repair log. CompleteOK requires the listed attackers to equal the full set computed for the displayed root and every displayed subargument. This completeness check prevents a proof from hiding an undefeated counterargument.

$$\mathrm{C}\mathrm{h}\mathrm{e}\mathrm{c}\mathrm{k}\left(G_c,{\mathcal{T}}_{\tau },c\right):=\mathrm{R}\mathrm{o}\mathrm{o}\mathrm{t}\mathrm{O}\mathrm{K}\wedge \mathrm{S}\mathrm{o}\mathrm{u}\mathrm{r}\mathrm{c}\mathrm{e}\mathrm{O}\mathrm{K}\wedge \mathrm{E}\mathrm{d}\mathrm{g}\mathrm{e}\mathrm{O}\mathrm{K}\wedge \mathrm{C}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{l}\mathrm{e}\mathrm{t}\mathrm{e}\mathrm{O}\mathrm{K}.$$

(9)

Table 4 lists the components of the proof-carrying explanation protocol and their audit value. The table shows what the reviewer is expected to inspect in a proof-carrying answer. Auditability is distributed across the proof object: facts identify evidence spans, rules identify applied norms, attacks identify considered counterarguments, and priority edges explain why one argument defeated another.

Table 4. Components of the proof-carrying explanation protocol.

Proof Component	Formal Object and Producer	Audit/Verification Operation
Fact node	f in Fτ; extractor + validator	Recover and compare the cited evidence span
Rule node	r in Rτ; extractor + validator	Check antecedents, consequent, type, and source
Attack/defeat edge	(A,B) ∈ Defeatτ; symbolic reasoner	Check declared conflict scope, attacked subargument, and priority filter
Priority edge	stronger-than relation; validator/repair layer	Check explicit source or repair-log justification
Accepted conclusion	c in Cτ; grounded engine	Check membership in GE and equality to proof root

The formal object is generated by the extractor, validator, symbolic reasoner, and deterministic proof serializer as specified above. Its audit value is realized by the separate Check procedure and by a human reviewer following the source pointers; it is not a second learned output.

3.10. Implementation and Evaluation Design

3.10.1. Datasets, Benchmark, and Annotation Protocol

The implementation and disclosed evaluation artifacts are available at https://github.com/thecontrey/neuro_symbolic (accessed on 27 August 2026). The evaluation uses three complementary datasets: a controlled contract-derived benchmark, a natural-language LLM-to-logic experiment, and a public-contract/Russian-law adaptation subset. The released files support schema inspection, formal unit tests on explicit synthetic fixtures, proof-example checks, and recomputation of disclosed statistics from scenario-level predictions. Confidential raw contracts, reversible source-to-normalized-item mappings, and provider-side model responses are not released; source-level extraction and LLM-call replay are therefore outside the public reproducibility scope.

First, we constructed a 600-case controlled legal reasoning benchmark derived from real contract materials and divided it into four equal tiers: Tier 0, general rules; Tier 1, simple exceptions; Tier 2, priority conflicts; and Tier 3, nested exceptions. Each tier contained 150 cases. The anonymized representation preserves facts, rule types, exceptions, priorities, procedural conditions, attack relations, target conclusions, and proof objects. Gold labels were produced by seven legal experts with 3–20 years of practice (mean 9.3 years; median 6 years). All seven had experience with Russian law, and five also had experience in international commercial arbitration. Experts assessed each item independently. No chance-corrected inter-rater coefficient was computed; disagreements were adjudicated by a designated senior expert. We therefore report expert composition and adjudication explicitly rather than implying measured inter-rater reliability.

Second, we created a 240-scenario LLM-to-logic extraction experiment. Each scenario was presented as a preassembled, source-linked legal evidence package and required schema-constrained facts, rules, rule types, conflicts, priorities, citations, and confidence values. The extraction models and the Qwen direct baseline were run through OpenRouter in 2026 under the configurations in Table 5. Decoding was kept close to zero to minimize generative variability.

Table 5. LLM model configuration and low-randomness decoding settings.

Parameter	GPT-4o	Llama-3.3-70B-Instruct	Qwen2.5-72B-Instruct	Qwen3.6-27B Baseline
Provider, endpoint	OpenAI via OpenRouter	Meta via OpenRouter	Qwen Team via OpenRouter	Qwen via OpenRouter
Exact model ID	openai/gpt-4o	meta-llama/llama-3.3-70b-instruct	qwen/qwen-2.5-72b-instruct	qwen/qwen3.6-27b
Temperature	0.01	0.01	0.01	0.01
top_p	0.01	0.01	0.01	0.01
max_tokens	4096	4096	4096	4096
Context window	128K	128K	128K	262K
Seed	42	42	42	42

Third, we evaluated the method on 200 adapted items: 60 ContractNLI items [3], available at https://stanfordnlp.github.io/contract-nli/ (accessed on 27 August 2026); 60 CUAD items [4], available at https://www.atticusprojectai.org/cuad/ (accessed on 27 August 2026); 40 MAUD items [5], available at https://www.atticusprojectai.org/maud/ (accessed on 27 August 2026); and 40 Russian-law contract examples. Public items were reduced to decision-relevant evidence units before formalization; Russian-law items were manually abstracted from contractual scenarios. The released adaptation records are normalized legal-logical abstractions and do not retain a reversible item-to-source-text mapping. The same seven-expert panel used for the main annotation independently checked the target conclusion, applicable facts, conflict scope, priority relation, and proof structure; disagreements were adjudicated by the designated senior expert.

Annotation and scenario-validation protocol. The same seven-expert panel independently assigned the target gold labels for the 240 extraction scenarios, and the designated senior expert adjudicated disagreements. A record entered the evaluation only after passing (i) JSON-schema validation; (ii) completeness checks for the query, source units, facts, operative rules, exceptions, conflict pairs, priorities, and target label; (iii) logical consistency checks between active facts, attacks, priorities, and the expected proof; and (iv) legal review of the target conclusion and cited basis. Disagreements were adjudicated against the source-linked theory.

For the LLM-to-logic pilot, outputs were adjudicated at the level of facts, rules, rule types, conflict pairs, priority relations, citation spans, and schema validity. Error labels included false-positive and false-negative facts and rules, omitted exceptions, rule-type errors, missing or unsupported conflicts and priorities, priority-direction errors, citation-span mismatches, and schema violations. The final labels were used to compute the Fact Extraction Error Rate (FEER), Rule Extraction Error Rate (REER), Priority Extraction Error Rate (PEER), citation accuracy, schema-valid output rate, and downstream conclusion accuracy; formal definitions appear in Section 3.10.4.

The public repository, https://github.com/thecontrey/neuro_symbolic (accessed on 27 August 2026), includes JSON schemas, prompt templates, anonymized structural records, disclosed labels and scenario-level predictions, proof fixtures, cognitive-verification rows, statistical scripts, aggregate tables, and figure-generation code. Reference baseline interfaces are included, but raw provider outputs and the source-derived artifacts needed to refit the reported PDL classifier exactly are not released.Additional implementation and evaluation artifacts are listed in the Supplementary Materials; the benchmark schema is provided in Appendix A, and an illustrative anonymized item is provided in Appendix B.

3.10.2. LLM Experimental Setup

The LLM extraction experiments used GPT-4o, Llama-3.3-70B-Instruct, and Qwen2.5-72B-Instruct through OpenRouter. The direct post-retrieval baseline used qwen/qwen3.6-27b, selected before the paired downstream comparison as the lowest-cost option satisfying the project’s deployment constraints. GPT-4o was designated as the primary extractor before downstream labels were compared. The experiment therefore evaluates one prespecified deployment configuration and does not constitute a model-family ranking.

Table 5 reports the exact model identifiers and low-randomness decoding settings used in the experiments. The configuration table makes the extraction experiment reproducible and limits interpretation of the results. Low-randomness decoding was used to evaluate structured extraction capability rather than creative generation, while the direct post-retrieval baseline was evaluated under comparable settings.

The extractor was not allowed to produce the final legal conclusion. It returned only facts, rules, rule types, source-scoped conflict pairs, priorities, confidence metadata, and provenance pointers; the deterministic reasoner produced the label and proof graph. Retrieval itself was held outside the comparison: every method received the same preassembled evidence units, preserving document identifiers, structural paths, and span offsets. The direct baseline received the query plus all units in that fixed package and generated a label, rationale, and source identifiers. No retriever, chunking strategy, or top-k setting was varied or scored; accordingly, this is a controlled post-retrieval comparison, not a full end-to-end RAG benchmark.

Temperature and top_p were both fixed at 0.01 with seed 42 to reduce stochastic variability in the schema-constrained experiment. Each model was called once per scenario. This was a controlled low-randomness regime, not a claim of model-optimal decoding. No temperature sweep, repeated-seed study, or repeated stochastic robustness experiment was conducted; therefore, the paper does not infer whether a setting such as 0.6 would improve or degrade Qwen performance. A hosted seed also does not guarantee bitwise determinism across providers. This limitation is material when comparing absolute model performance but does not affect the determinism of the symbolic layer conditional on a fixed extracted theory.

3.10.3. Probabilistic Defeasible-Logic Baseline

The PDL baseline receives deterministic numeric features extracted from the same validated theory $𝒯$τ as the proposed method, but it does not construct an attack graph and does not apply priorities as hard normative constraints. It is a multinomial logistic-regression diagnostic rather than a separate probabilistic logic semantics.

The classifier uses L2 regularization with C = 1.0, the lbfgs solver, and max_iter = 1000. Scenario-level results are out-of-fold predictions from StratifiedKFold with 10 folds, shuffle = true, and random_state = 42. No hyperparameter search was performed. Accuracy and macro-F1 are computed once from the concatenated out-of-fold predictions, rather than by treating fold means as independent observations. The classifier was implemented with scikit-learn 1.9.0.

The feature vector is generated deterministically from each validated JSON object and contains activated fact indicators, counts of active rules, conflict indicators, extracted-priority indicators, sums and differences of confidence-weighted support, source-span counts, and schema-validity indicators. Missing numeric counts are set to zero; no grounded-extension label, accepted-argument identifier, or attack-graph feature is supplied.

Table 6 defines the observable features used by the probabilistic defeasible-logic baseline. The baseline features deliberately exclude grounded-extension labels, accepted-argument identifiers, and attack-graph outputs. Therefore, the PDL classifier tests whether statistical aggregation of extraction-level signals can replace explicit symbolic defeat, without leaking the proposed reasoner into the comparison.

Table 6. Features used by the probabilistic defeasible-logic baseline.

Category	Feature	Type	Purpose
Simple facts	Delay(x), ForceMajeure(x), GrossNegligence(x), NoticeMissing(x), NoticeWaived(x)	binary	Captures activation of general rules, exceptions, nested exceptions, and procedural defeaters
Rules	Number of active rules; presence of conflicting rules for the same conclusion	integer/binary	Measures the amount of normative support and dialectical conflict
Priorities	Presence of an extracted stronger/weaker relation for a declared conflict pair	binary	Captures whether a priority signal was extracted without applying it as a hard constraint
Confidence	Sum of rule confidence supporting p; sum supporting not p; support difference	non-negative real	Approximates weighted support and rebuttal
Source metadata	Number of unique source spans; schema-valid indicator	integer/binary	Measures evidential density and extraction quality

3.10.4. Evaluation Metrics and Baselines

We evaluate the conclusion accuracy, macro-F1, exception sensitivity, extraction error rates, downstream accuracy, traceability coverage, runtime, proof validity, and cognitive verification effort. Accuracy is the fraction of scenarios matching the expert gold class. Macro-F1 is the unweighted mean of class-specific F1 for Positive, Negative, and Undetermined. Exception sensitivity is recall on gold scenarios whose correct outcome depends on at least one active exception; nested-exception accuracy is accuracy on scenarios marked as requiring an exception to an exception or a multi-level defeat.

Traceability coverage is the proportion of all decisions for which every fact and rule used by the method has a recoverable source pointer. Proof coverage is the proportion of all scenarios for which the method returns a trace containing a label, source identifiers, and ordered supporting steps; proof validity is the proportion of produced formal proof objects that pass Check. Unsupported answer rate is the proportion of all scenarios with a determinate label lacking an adjudicated evidence-supported rule chain. Citation accuracy is the number of predicted source pointers whose document, path, and span match an adjudicated pointer divided by all predicted pointers; schema-valid output rate is the proportion of scenario outputs passing validation before repair.

The extraction metrics are FEER (Fact Extraction Error Rate), REER (Rule Extraction Error Rate), and PEER (Priority Extraction Error Rate), defined in Equations (10)–(12). Objects are matched one-to-one to the adjudicated representation. A matched rule with the wrong type is counted once as TE, not again as both FP and FN; a matched priority with reversed direction is counted once as DE under the same convention.

$$\mathrm{F}\mathrm{E}\mathrm{E}\mathrm{R}={\displaystyle \frac{F{P}_{\mathrm{f}\mathrm{a}\mathrm{c}\mathrm{t}\mathrm{s}}+F{N}_{\mathrm{f}\mathrm{a}\mathrm{c}\mathrm{t}\mathrm{s}}}{T{P}_{\mathrm{f}\mathrm{a}\mathrm{c}\mathrm{t}\mathrm{s}}+F{P}_{\mathrm{f}\mathrm{a}\mathrm{c}\mathrm{t}\mathrm{s}}+F{N}_{\mathrm{f}\mathrm{a}\mathrm{c}\mathrm{t}\mathrm{s}}}}.$$

(10)

$$\mathrm{R}\mathrm{E}\mathrm{E}\mathrm{R}={\displaystyle \frac{F{P}_{\mathrm{r}\mathrm{u}\mathrm{l}\mathrm{e}\mathrm{s}}+F{N}_{\mathrm{r}\mathrm{u}\mathrm{l}\mathrm{e}\mathrm{s}}+T{E}_{\mathrm{r}\mathrm{u}\mathrm{l}\mathrm{e}\mathrm{s}}}{T{P}_{\mathrm{r}\mathrm{u}\mathrm{l}\mathrm{e}\mathrm{s}}+F{P}_{\mathrm{r}\mathrm{u}\mathrm{l}\mathrm{e}\mathrm{s}}+F{N}_{\mathrm{r}\mathrm{u}\mathrm{l}\mathrm{e}\mathrm{s}}+T{E}_{\mathrm{r}\mathrm{u}\mathrm{l}\mathrm{e}\mathrm{s}}}}.$$

(11)

$$\mathrm{P}\mathrm{E}\mathrm{E}\mathrm{R}={\displaystyle \frac{F{P}_{\mathrm{p}\mathrm{r}\mathrm{i}\mathrm{o}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{e}\mathrm{s}}+F{N}_{\mathrm{p}\mathrm{r}\mathrm{i}\mathrm{o}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{e}\mathrm{s}}+D{E}_{\mathrm{p}\mathrm{r}\mathrm{i}\mathrm{o}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{e}\mathrm{s}}}{T{P}_{\mathrm{p}\mathrm{r}\mathrm{i}\mathrm{o}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{e}\mathrm{s}}+F{P}_{\mathrm{p}\mathrm{r}\mathrm{i}\mathrm{o}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{e}\mathrm{s}}+F{N}_{\mathrm{p}\mathrm{r}\mathrm{i}\mathrm{o}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{e}\mathrm{s}}+D{E}_{\mathrm{p}\mathrm{r}\mathrm{i}\mathrm{o}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{e}\mathrm{s}}}}.$$

(12)

Table 7 summarizes the baselines and the diagnostic role of each comparison. Each baseline isolates a specific failure mode: lexical shortcut behavior, monotonic reasoning under exceptions, missing nested defeats, probabilistic aggregation without hard priority semantics, or direct neural answer generation.

Table 7. Baselines and diagnostic role.

Baseline	Input	Decision Rule	Purpose
Lexical top-rule heuristic	Retrieved clause labels	Selects the highest lexical match	Tests retrieval-like shortcut behavior
Monotonic forward chaining	Gold or extracted rules	Accepts all derivable conclusions	Tests failure under exceptions
Priority without nested defeats	Rules and simple priorities	Applies only one-level priority overrides	Tests nested-exception handling
PDL logistic-regression classifier	Structured features extracted from $𝒯$τ	Multinomial logistic regression returns the MAP class	Tests statistical aggregation without hard priority defeat
Direct LLM over retrieved evidence	Fixed evidence package and query	Generates label, rationale, and source IDs	Tests direct neural decision support
Proposed LLM-to-NMR	Extracted theory with validation	Computes grounded extension and proof graph	Tests neuro-symbolic acceptance

3.10.5. Statistical Analysis

For each method, 95% Wilson intervals were computed for accuracy [22]. Because all methods predicted the same 240 scenarios, pairwise accuracy comparisons used the two-sided exact McNemar test [23]. The primary family compared the unrepaired proposed pipeline with the direct LLM, PDL, and priority-without-nested-defeats baselines; Holm’s procedure controlled family-wise error across these three tests [24]. Effect uncertainty was estimated with 20,000 paired bootstrap resamples of scenarios using Python’s random.Random(42) generator [25]. The repair-versus-unrepaired contrast was exploratory.

For the probabilistic baseline, the fixed 10-fold procedure described above produced one out-of-fold prediction per scenario. These paired scenario-level predictions, rather than fold-level means, were used in the downstream comparisons and McNemar analyses. The released file contains the resulting out-of-fold predictions; exact refitting is outside the public reproducibility scope because the original source-derived feature matrices and fold assignments are not released.

The 216 cognitive-verification rows are repeated observations: 12 lawyers each evaluated six cases in all three modes. We used 20,000-resample participant-cluster bootstrap intervals with NumPy’s default_rng(42) generator for verification rate and median time [25]. The two prespecified proof-graph comparisons (proof graph versus each alternative) used participant-level mean correctness or median time with a two-sided Wilcoxon signed-rank test (zero_method = wilcox, method = auto, no continuity correction), followed by Holm correction within each outcome [26]. This accounts for within-lawyer clustering; recurrence remains a limitation. Statistical analyses were run in Python 3.11 with NumPy 2.4.6 and SciPy 1.17.1.

Scenario-level predictions, anonymized cognitive rows, metric and statistical code, aggregate tables, and figure-generation scripts are available in the public repository. These materials reproduce the paired and participant-cluster analyses from disclosed rows; they do not recreate provider-side LLM calls or refit the reported PDL model.

3.10.6. Public-Contract and Russian-Law Adaptation Protocol

To avoid treating the controlled benchmark as the only evidence of representational coverage, we defined a separate adaptation protocol for public-contract and Russian-law materials. ContractNLI, CUAD, and MAUD items were first reduced to decision-relevant evidence units and then mapped into $𝒯$τ by identifying legal facts, candidate rules, deontic status, exceptions, priority relations, and source spans. Russian-law examples were abstracted into the same representation from real contractual scenarios.

Each adapted item was checked by external legal experts for the target legal conclusion, applicable facts, rule structure, exception pattern, priority relation, and expected proof object. The subset was evaluated separately from the controlled benchmark; its purpose was to provide a limited check of representational portability at the normalized theory level, not to claim complete coverage of contract-review tasks or independently replayable source-text extraction.

3.10.7. Realistic Extraction-Error Stress-Test Protocol

To evaluate robustness under realistic LLM failures, the stress test used the 240 adjudicated GPT-4o candidate theories. With seed 42, each eligible fact, rule, priority, or citation pointer was independently perturbed at the condition-specific perturbation rate; the mixed condition distributed perturbations evenly across the five families. A fact or rule omission removed one matched object, a hallucination inserted a schema-valid but unsupported fact, a rule-type error changed only the type field, a priority-direction error swapped stronger and weaker endpoints, and a citation mismatch shifted the span outside the adjudicated unit. The reasoner and verifier were then rerun without changing the gold labels.

The stress test reports conclusion accuracy and proof validity after perturbation. Proof validity means that the produced proof passed Equation (9), including provenance, root acceptance, and attacker-completeness checks. A single seeded perturbation run is reported for each condition, so this is a descriptive sensitivity analysis rather than a stochastic confidence interval.

3.10.8. Scalability and Performance Protocol

The runtime experiment used deterministic synthetic policy-like theories with 10, 50, 200, 1000, and 5000 rules and twice as many facts. The generator (seed 42) created acyclic dependency layers with one to three antecedents per rule, inserted source-scoped complementary or defeater conflict pairs through ⋈τ, and assigned priorities only inside those pairs. The same generated theory was reused for all repetitions at a given size. The reported argument count includes only rule-derived composite arguments; the |Fτ| atomic fact arguments in 𝒜₀ are reported separately in the Facts column. Thus, the total canonical argument count is |Fτ| plus the reported rule-derived count. Arguments were indexed by conflict pair and conclusion to avoid all-pairs checks. The implementation ran on an AMD Ryzen 9 7950X CPU (Advanced Micro Devices, Inc., Santa Clara, CA, USA) with 64 GB RAM under Ubuntu 22.04 and Python 3.11. Five warm-up runs preceded 31 measured repetitions; medians of construction time, grounded-extension time, total time, and tracemalloc peak allocation are reported.

The experiment was diagnostic rather than deployment-specific. It was designed to identify the point at which batch processing, incremental recomputation, and argument indexing become necessary for large legal corpora.

3.10.9. Cyclic Priority Stress-Test Protocol

The priority-cycle test sampled 25, 50, and 100 eligible theories with seed 42 and injected one three-rule cycle per selected theory by adding a closing priority edge inside an existing source-scoped conflict component. Each component was checked first for an explicit source-based resolution and then, where legally supported, by κL. Confidence and identifiers were not allowed to determine a legal preference. Unresolved components were assigned Undetermined and routed to review.

The test measured automatic repair, review flags, false determinate conclusions, and accuracy after repair. Accuracy after repair was validated by comparing the repaired output with the same expert-verified gold label used before cycle injection; an unresolved case was correct only when the gold outcome was Undetermined or the protocol explicitly required abstention. False determinate conclusions were counted separately to detect unsafe over-resolution.

3.10.10. Cognitive Verification Study Protocol

Because correctness alone is insufficient for decision support, we conducted an exploratory within-subject study with 12 practicing lawyers. Each lawyer evaluated the same six cases once in each of three modes (LLM answer only, textual rationale, and proof graph), yielding 18 judgments per lawyer and 216 observations. We used all six possible mode-block orders, assigned two participants to each order at random with seed 42, and shuffled cases within each mode separately for every participant using a recorded fixed seed. Repeat presentations of an underlying case were separated by five neutral tasks and a three-minute pause. Participants were not told that cases would recur until debriefing. These controls reduce order and expectation effects but cannot eliminate learning or recall, so the pilot cannot fully isolate explanation format from recurrence.

Participants were recruited by purposive sampling through the authors’ professional networks, a law-faculty alumni network, and contacts in legal departments of information-technology companies. Eligibility required at least three years of commercial or corporate legal practice, regular experience reading B2B supply agreements or service-level agreements, and fluency in Russian- or English-language contract drafting. Students and graduate students were excluded, and participation was voluntary. Participants judged whether the conclusion followed from the displayed evidence. Outcomes were verification correctness, time, NASA-TLX workload, and confidence on a 1–5 scale. Participants provided informed consent, and the minimal-risk study collected no sensitive personal data. The public package contains anonymized item-level rows. This purposive exploratory sample is not representative of legal practice as a whole.

4. Results

4.1. Controlled Formal Reasoning Benchmark

The controlled benchmark described in Section 3.10.1 validates the implementation against expert-verified gold formalizations. It is a conformance diagnostic for the symbolic layer, not evidence that extraction errors have been eliminated.

Table 8 reports the controlled formal reasoning benchmark results. Table 9 reports accuracy by reasoning complexity tier.

Table 8. Results on 600 controlled contract-derived scenarios.

Method	Accuracy, %	Macro-F1, %	Exception Sensitivity, %	Traceability Coverage, %
Lexical top-rule heuristic	67.0	63.4	30.4	0.0
Monotonic forward chaining	66.7	64.3	30.4	54.7
Priority rules without nested defeats	92.3	91.1	87.3	81.3
Proposed grounded NMR engine	99.3	99.2	98.7	96.8

Table 9. Accuracy by reasoning complexity tier, %.

Method	Tier 0	Tier 1	Tier 2	Tier 3
Lexical top-rule heuristic	99.3	47.3	54.7	66.7
Monotonic forward chaining	98.0	47.3	54.7	66.7
Priority rules without nested defeats	97.3	96.0	92.0	84.0
Proposed grounded NMR engine	100.0	99.3	98.7	99.3

Under gold formalization, the proposed implementation had the highest observed accuracy, macro-F1, exception sensitivity, and traceability coverage. The comparison isolates handling of exceptions and nested defeats; it does not evaluate the neural extractor.

The tier-level breakdown indicates where the difference comes from. Simple Tier-0 cases are easy for all methods, but performance drops sharply for lexical and monotonic baselines once exceptions and priority conflicts appear; the proposed engine remains stable even on Tier-3 nested exceptions.

The 99.3% result is a frozen pre-correction conformance snapshot, not a substantive disagreement between legal experts and grounded semantics. Audit of the four mismatches identified implementation defects between the recorded prediction and the rule/proof structure: one negative exception was mapped to Undetermined, one unresolved priority tie lost its review flag, one explicit exception priority was applied in the wrong direction, and one nested defeat was not propagated to the final label. The gold label and stored proof structure agreed in all four records. These defects were corrected in the released implementation and covered by regression tests, while Table 8 retains the originally evaluated snapshot for transparency; no unevaluated replacement benchmark score is claimed. The result must not be interpreted as real-world legal accuracy. Table 10 summarizes the audited discrepancies and their implications.

Table 10. Audit of the four discrepancies under gold formalization.

Case	Gold/Recorded	Audited Cause	Implication
CTRL_T1_088	Negative/Undetermined	Negative exception mapped to abstention	Test exception-to-label mapping
CTRL_T2_070	Undetermined/Positive	Review flag lost for unresolved tie	Enforce abstention invariant
CTRL_T2_142	Negative/Positive	Priority direction applied incorrectly	Test stronger/weaker orientation
CTRL_T3_076	Positive/Negative	Nested defeat not propagated	Test multi-level defeat closure

4.2. LLM-to-Logic Extraction Experiment

Here, the neural component means only the LLM-based mapping from natural-language evidence to the candidate formal theory; it excludes validation, priority repair, grounded inference, and proof generation. Each of 240 scenarios was processed under the constrained JSON schema and evaluated for fact, rule, priority, citation, and schema errors before downstream reasoning.

Figure 2 visualizes extraction error rates for facts, rules, and priorities.

Figure 2. LLM-to-logic extraction error rates in the experiment. FEER, REER, and PEER are reported as percentages; lower values indicate fewer extraction errors.

The figure highlights that extraction quality is uneven across object types. Priority extraction errors are higher than fact errors, which explains why legal conclusion accuracy is constrained by priority recognition rather than by factual extraction alone.

Table 11 reports the LLM extraction results and downstream accuracy after symbolic reasoning.

Table 11. LLM extraction results.

Extractor	Cases	FEER, %	REER, %	PEER, %	Citation Accuracy, %	Schema-Valid Outputs, %	Downstream Accuracy, %
GPT-4o, schema constrained	240	6.8	10.9	13.7	92.1	96.3	86.7
Llama-3.3-70B-Instruct, schema constrained	240	10.7	15.8	20.4	89.6	92.5	80.8
Qwen2.5-72B-Instruct, schema constrained	240	9.4	14.3	18.9	86.3	95.4	82.5
GPT-4o + validation-triggered repair	240	4.9	8.1	10.6	92.1	99.6	90.4

Priority extraction was the most fragile stage. Validation-triggered repair reduced every aggregate extraction-error rate, increased schema-valid output from 96.3% to 99.6%, and raised observed downstream accuracy from 86.7% to 90.4%. Citation accuracy remained 92.1% after rounding. The paired repair-versus-unrepaired difference was 3.8 percentage points, but its bootstrap interval included zero and McNemar’s test was not significant (p = 0.233); the increase is exploratory.

Adjudication and stress testing show that omitted exceptions and missing or reversed priorities are more consequential than isolated factual errors. A single priority-direction error can invert the accepted conclusion, whereas a citation mismatch may preserve the label but invalidate the proof trail.

These mitigations define the next extraction step but are not all separately validated interventions. The reported repair result aggregates the bounded validator-guided process; future work should ablate clause-neighborhood retrieval, exception-pair extraction, and priority-direction checks individually. Table 12 summarizes the extraction failure taxonomy and corresponding mitigation design.

Table 12. Extraction failure taxonomy and legal-domain mitigation design.

Failure	Downstream Risk	Targeted Mitigation/Feedback Trigger
Omitted fact, rule, or exception	False conclusion or unwarranted Undetermined	Retrieve clause neighborhood and re-extract exception pairs
Rule-type misclassification	Incorrect support, rebuttal, or defeater behavior	Type checklist plus validator request for cited legal function
Missing or reversed priority	Defeat relation and final label may invert	Require stronger/weaker fields, cited basis, and direction check
Citation-span mismatch	Conclusion may survive while proof becomes unauditable	Span containment check and targeted re-retrieval
Schema or grounding failure	Object cannot safely enter the reasoner	Reject object, issue typed diagnostic, allow one bounded repair

4.3. Direct LLM over Fixed Retrieved Evidence and Probabilistic Baseline Comparison

The same 240 scenarios and identical preassembled evidence packages were evaluated with the direct post-retrieval LLM baseline, PDL, priority-without-nested-defeats, and the proposed pipeline. Retrieval quality was not evaluated. Because predictions are paired by scenario, exact McNemar tests and paired-bootstrap confidence intervals are used for the accuracy comparisons reported below.

Aggregate metrics remain diagnostic, but accuracy differences are now accompanied by paired inference. The family-wise primary question is whether the unrepaired proposed pipeline differs from each comparator; the repair contrast is exploratory.

Figure 3 compares downstream accuracy across the direct post-retrieval, probabilistic, and symbolic baselines.

Figure 3. Downstream accuracy on the 240-scenario experiment. Error bars are 95% Wilson intervals for each method; paired significance is reported separately.

The bars show the observed ordering, but overlapping marginal intervals do not determine paired significance. The proposed pipeline exceeded the direct LLM baseline by 10.8 percentage points, while smaller differences from PDL and the simpler symbolic baseline were not statistically established.

Table 13 reports the downstream comparison against the direct post-retrieval and probabilistic baselines.

Table 13. Downstream comparison against direct post-retrieval and probabilistic baselines.

Method	Accuracy, %	Macro-F1, %	Exception Accuracy, %	Nested-Exception Accuracy, %	Unsupported Answer Rate, %	Proof Coverage, %
Direct LLM over fixed retrieved evidence	75.8	73.9	68.1	61.7	8.8	41.2
PDL logistic-regression classifier	82.1	80.1	76.4	70.0	2.9	0.0
Priority rules without nested defeats on extracted theory	84.2	81.5	79.1	68.3	0.0	81.7
Proposed LLM-to-NMR, GPT-4o extractor	86.7	84.7	83.6	78.3	0.0	96.3
Proposed LLM-to-NMR + validation-triggered repair	90.4	89.0	88.1	83.3	0.0	94.2

The direct-baseline comparison was supported after multiplicity correction: 54 scenarios were correct only under the proposed pipeline and 28 only under the direct LLM (Holm-adjusted p = 0.016). Comparisons with PDL and priority-without-nested-defeats did not reject equality. Proof coverage and unsupported-answer rate remain architectural outcomes rather than accuracy significance tests.

Table 14 reports paired accuracy comparisons. Positive differences favor the proposed method. Only the comparison with the direct LLM baseline is significant after Holm correction; the aggregate ranking must not be read as a statistically established ordering of all methods.

Table 14. Paired accuracy comparisons on 240 scenarios.

Comparison	Accuracy Difference, Percentage Points (95% Paired Bootstrap CI)	Exact McNemar p
Proposed vs. direct LLM over retrieved evidence	+10.8 [3.3, 17.9]	0.016, Holm-adjusted
Proposed vs. PDL	+4.6 [−1.7, 10.8]	0.400, Holm-adjusted
Proposed vs. priority/no nested defeat	+2.5 [−3.8, 8.8]	0.512, Holm-adjusted
Proposed + repair vs. proposed	+3.8 [−1.7, 9.2]	0.233, exploratory unadjusted

4.4. Adaptation Results on Public-Contract and Russian-Law Items

Using the adaptation protocol described in Section 3.10.6, the method was evaluated on a 200-item subset combining public contract datasets and Russian-law contract examples. The subset included 60 ContractNLI-derived items, 60 CUAD-derived items, 40 MAUD-derived items, and 40 Russian-law examples abstracted from real contractual scenarios.

The adaptation subset provides a limited representational check beyond the controlled templates: the normalized records encode negations, survival clauses, carve-outs, cross-references, thresholds, procedural conditions, and Russian-law contract formulations. Because the release omits reversible source-text mappings, this result supports comparison at the normalized representation level rather than independent source-level extraction replay.

Table 15 reports performance on the public-contract and Russian-law adaptation subset. Within this normalized subset, MAUD-derived items have lower observed scores, consistent with the added difficulty of definitions, cross-references, and thresholds; validation-triggered repair improves every subset. These differences should not be read as a source-level benchmark of the underlying public datasets.

Table 15. Public-contract and Russian-law adaptation subset.

Subset	Items	Typical Phenomenon	Direct Post-Retrieval LLM Acc., %	PDL Baseline Acc., %	Proposed Acc., %	Proposed + Repair Acc., %
ContractNLI-derived items	60	Negations, survival clauses, exceptions	76.7	83.3	88.3	91.7
CUAD-derived items	60	Clause-type variation, carve-outs	73.3	80.0	85.0	90.0
MAUD-derived items	40	Definitions, cross-references, thresholds	67.5	77.5	80.0	87.5
Russian-law contract examples	40	Procedural conditions, mandatory rules, priority conflicts	72.5	82.5	85.0	90.0
Total	200	Mixed public-contract and Russian-law subset	73.0	81.0	85.0	90.0

4.5. Robustness to Realistic Extraction Errors

Using the stress-test protocol described in Section 3.10.7, five realistic extraction-error families were evaluated: fact omissions, hallucinated facts, rule-type misclassification, priority-direction errors, and citation-span mismatches.

Table 16 reports the realistic extraction-error stress test. The stress test identifies which extraction errors are most damaging.

Table 16. Realistic extraction-error stress test.

Injected Error Family	Rate, %	Accuracy After Perturbation, %	Proof Validity After Perturbation, %	Interpretation
Fact omission	5	91.2	96.7	Often returns Undetermined when a premise is missing
Fact hallucination	5	88.8	94.1	Can activate an unsupported exception
Rule-type error	5	86.7	92.5	Confuses defeasible rules and defeaters
Priority-direction error	5	81.7	90.0	Most harmful because defeat is inverted
Citation-span mismatch	5	89.6	78.3	Conclusion may survive, but auditability drops
Mixed realistic error profile	10	79.2	84.2	Matches observed LLM extraction failure composition

Priority-direction errors caused the largest accuracy drop because they invert the defeat relation that determines which legal argument survives. Citation-span mismatches had a weaker effect on conclusion accuracy but the strongest effect on proof validity, confirming that auditability must be evaluated separately from answer correctness.

4.6. Scalability and Performance

Using the scalability protocol described in Section 3.10.8, the runtime experiment scaled the number of rules from small clause sets to large policy corpora. The results indicate that theories with hundreds of rules remain comfortably interactive, while theories with thousands of rules require indexing and incremental recomputation.

Figure 4 visualizes runtime scaling for argument construction and grounded-extension computation. The runtime curve shows that larger legal theories remain feasible, but the bottleneck shifts toward constructing the attack framework. This supports the need for indexed conflict lookup and incremental recomputation when the method is deployed on large policy or contract corpora.

Figure 4. Runtime scaling for indexed argument construction and grounded-extension computation. The axes use logarithmic scaling to show behavior from small clause sets to large policy corpora.

Table 17 reports scalability results for increasing theory size. Its rule-derived argument column excludes the atomic fact arguments counted separately in the facts column.

Table 17. Scalability results for increasing theory size.

Rules	Facts	Rule-Derived Arguments	Attack Edges	Build AF, ms	GE Compute, ms	Total, ms	Peak Memory, MB
10	20	18	12	2.0	0.4	2.4	18
50	100	87	141	8.9	1.9	10.8	27
200	400	346	1912	39.2	8.4	47.6	61
1000	2000	1740	48,300	286	72	358	132
5000	10,000	8600	1,176,000	4820	1410	6230	420

The scalability table shows that the main runtime driver is attack-framework construction rather than grounded-extension computation. This supports the implementation choice to use indexing and incremental recomputation for larger corpora, because attack edges grow much faster than the number of rules.

4.7. Cyclic Priority Handling

Using the protocol in Section 3.10.9, cyclic priorities were injected into otherwise valid theories. Repaired outputs were compared with expert-verified gold labels, while unsafe determinate outputs were counted separately.

Table 18 reports priority-cycle handling results. The cyclic-priority results support the conservative behavior of the method. As the number of injected cycles increases, more cases are routed to human review, but the false determinate conclusion rate remains zero; this is the desired trade-off for high-risk legal decision support.

Table 18. Priority-cycle handling results.

Injected Cyclic-Priority Cases	Cycles Repaired Automatically, %	Human-Review Flags, %	False Determinate Conclusions, %	Accuracy After Repair, %
25	88.0	12.0	0.0	92.0
50	84.0	16.0	0.0	90.0
100	79.0	21.0	0.0	87.0

The priority-cycle stress test supports the conservative design choice: unresolved legal priority ties increase human-review flags but do not create false determinate conclusions. This behavior is preferable in high-risk legal decision support, where unsupported certainty is more harmful than explicit escalation.

4.8. Cognitive Verification Study

Using the protocol in Section 3.10.10, 12 lawyers each assessed six repeated cases in all three explanation modes, producing 72 observations per mode and 216 observations overall.

The proof-graph condition had the highest observed verification rate, shortest median time, lowest workload, and highest confidence. Participant-cluster intervals and participant-level paired tests are reported because observations within a lawyer are not independent.

Figure 5 summarizes median verification time with participant-cluster bootstrap intervals. The time difference was consistent at the participant level, but repeated exposure to the same cases prevents a strong causal claim about explanation format alone.

Figure 5. Median lawyer verification time by explanation mode. Error bars show 95% participant-cluster bootstrap intervals.

Table 19 reports the cognitive verification study results with confidence intervals.

Table 19. Cognitive verification results with participant-cluster 95% confidence intervals.

Mode	Participants	Cases/Obs.	Correct, %	Cluster 95% CI	Median, s	Cluster 95% CI	NASA-TLX	Confidence
LLM answer only	12	6/72	58.3	[48.6, 68.1]	130	[108.5, 136.0]	60.7	3.2
Textual rationale	12	6/72	66.7	[58.3, 75.0]	98	[90.0, 108.0]	53.6	3.5
Proof graph	12	6/72	83.3	[70.8, 94.4]	59	[55.0, 65.0]	37.2	4.3

Note. Values are computed from the 216 disclosed rows. Confidence intervals resample the 12 participants as clusters (20,000 iterations), preserving the six repeated cases within each sampled lawyer. NASA-TLX and confidence are item-level means.

The proof graph had the strongest observed descriptive profile. However, clustered correctness intervals overlap, and the small number of lawyers and repeated cases limits precision. The result supports a larger confirmatory study rather than a general claim that proof graphs always improve legal verification.

At the participant level, proof-graph median time was lower than both answer-only and textual-rationale time (two-sided Wilcoxon raw p = 0.00049 for each; Holm-adjusted p = 0.001). Correctness differences were not significant after correction (proof graph vs. textual rationale: raw p = 0.027, adjusted p = 0.055; proof graph vs. answer only: raw p = 0.059, adjusted p = 0.059).

4.9. Case Study: Nested Exceptions and Procedural Rules

The following Tier-3 case illustrates the proof object. The supplier delayed delivery under a valid contract. A force-majeure event occurred, and the customer also failed to send notice within the default contractual period. However, the force-majeure event was caused by the supplier’s gross negligence, and the contract contained a clause waiving prior notice for delays confirmed by the supplier in writing.

The method constructs five principal arguments. A2 defeats A1 within the declared conflict pair r2 ⋈ r1. A3 defeats A2 because r3 ≻ r2. A4 supports ¬EnforceablePenalty(x) and defeats A1 through r4 ⋈ r1, while A5 defeats A4 because r5 ≻ r4. No conflict pair is declared between A3 and A4 or between A5 and A2, so those unrelated arguments do not cross-attack. The grounded extension is {A1, A3, A5}; therefore, EnforceablePenalty(x) is accepted.

Figure 6 shows the argumentation attack graph for the nested-exception case study.

Figure 6. Attack graph for the Tier-3 case. Arrows denote attacks and dashed nodes are accepted under grounded semantics. A1/r1: Delay; A2/r2: ForceMajeure; A3/r3: GrossNegligence; A4/r4: NoticeMissing; A5/r5: NoticeWaived.

The figure should be read as an audit trail for a nested-exception conclusion. It shows that the force-majeure and notice-missing counterarguments are not ignored; they are represented as attacks and defeated only by stronger gross-negligence and notice-waiver arguments.

The case study illustrates the central advantage of proof-carrying reasoning. The system does not merely return EnforceablePenalty(x); it shows that both counterarguments were considered and defeated by stronger nested exceptions or priority overrides. This is the information a legal reviewer needs to challenge the conclusion at the level of source facts, rules, or priority relations.

5. Discussion

The results support the main claim: legal RAG should not be treated as a substitute for formal reasoning. Retrieval can provide evidence, and LLMs can map natural language into candidate facts and rules, but the final normative acceptance step should be governed by explicit semantics. This is particularly important for exceptions, nested exceptions, and priority conflicts, where fluent text generation often masks logical instability.

The controlled benchmark validates near-conformance of the implementation to the target non-monotonic behavior under gold formalization and exposes four concrete software-level discrepancies in the frozen evaluation snapshot. Those defects were corrected in the released implementation and assigned regression tests; the reported benchmark was not retrospectively replaced. The LLM experiment tests a different claim: symbolic acceptance localizes and reduces some downstream failures, but cannot reconstruct an omitted exception or correct every reversed priority.

The probabilistic baseline is competitive on ordinary cases. The proposed pipeline’s observed accuracy was higher, but the paired difference from PDL was not statistically established. The conceptual distinction remains: probability aggregates uncertain signals, whereas legal priority is an explicit normative override that must be represented and audited.

Grounded semantics was chosen because every finite framework has a unique skeptical extension and the fixed-point computation is tractable [17]. The cost of this choice is conservatism: cycles or balanced attacks can produce an empty extension or Undetermined even when a lawyer may wish to retain several plausible interpretations. Preferred semantics can expose maximal admissible alternatives and may better represent competing legal positions, but it can yield multiple extensions, complicate a single decision-support output and proof interface, and make skeptical acceptance computationally harder [27]. Grounded semantics is therefore appropriate for the paper’s high-risk abstention policy, not asserted to be universally superior for legal argumentation.

The validation layer enables a limited closed loop: schema, grounding, citation, and priority diagnostics can trigger targeted re-extraction of a failed object and its source neighborhood. It does not autonomously broaden retrieval without bounds or resolve an interpretive legal tie. Future work should evaluate iterative retrieval, clarification questions, confidence calibration, and ablations of exception-pair and priority-direction extraction.

The public-contract and Russian-law adaptation subset provides limited evidence that the representation can encode phenomena beyond the controlled templates, including negations, survival clauses, carve-outs, procedural conditions, thresholds, cross-references, and Russian-law contract formulations. Because the released items are normalized abstractions without reversible source-text mappings, the result does not establish independently replayable extraction from the underlying public clauses or universal coverage of legal reasoning tasks. The representation is strongest when evidence can be reduced to explicit facts, rules, exceptions, and priorities.

The method stores evidence units, rules, argument graphs, proof edges, and validation logs as structured data. Scalability results identify attack-framework construction as the dominant cost. The lawyer pilot suggests a possible reduction in verification time, but clustered correctness tests and repeated-case exposure require more cautious interpretation than the original descriptive ranking.

The term auditable must be used carefully. The method is fully auditable at the symbolic layer: given $𝒯$τ, every accepted conclusion can be checked against the proof graph. It is not automatically fully auditable at the extraction layer, because an LLM may attach a rule to an incorrect span or omit a relevant clause. For this reason, citation validation, confidence metadata, validation/repair logs, and human-review triggers are treated as first-class components and are released as part of the reproducibility package (see Appendix C).

6. Limitations

First, the method depends on extraction quality. Symbolic reasoning can reject contradictory or unsupported structures, but it cannot infer an exception that was never extracted from evidence. In deployment, the extraction layer must be evaluated separately and monitored continuously.

Second, the meta-priority repair procedure is an operational policy, not a substitute for legal interpretation. When legal metadata are insufficient or conflicting, the system should return Undetermined and request human review.

Third, the raw confidential contracts cannot be disclosed. The public package at https://github.com/thecontrey/neuro_symbolic (accessed on 27 August 2026) provides 600 anonymized controlled records, 240 LLM-to-logic records, 200 adaptation records, scenario-level predictions, 216 cognitive-verification rows, schemas, proof fixtures, and evaluation code. It supports schema validation, formal unit tests on explicit synthetic fixtures, recomputation of prediction-based metrics, exact McNemar and bootstrap comparisons, participant-cluster analyses, and inspection of proof examples. It cannot reproduce the confidential text-to-record transformation, reversible source-level adaptation mapping, provider-side LLM calls, or exact PDL refitting; extraction reproducibility therefore remains partial.

Fourth, proof graphs improve transparency, but they may still be too complex for non-expert users. Future work should evaluate graph simplification, progressive disclosure, and domain-specific explanation templates.

Fifth, the experiments focus primarily on contract-derived and Russian-law legal scenarios. Further validation is needed for other legal domains, including administrative regulation, litigation support, tax compliance, and multilingual legal corpora.

Sixth, the cognitive study included only 12 practicing lawyers and six cases. Each case recurred under all three modes, so counterbalancing reduces but cannot eliminate learning and recall. Participant-cluster intervals are wider than independence-based intervals, and adjusted correctness comparisons are inconclusive. A confirmatory study should use more lawyers, more cases, preregistered participant criteria, concealed randomized allocation, and a design in which a participant sees each underlying case in only one mode.

Seventh, the direct LLM baseline uses one architecture-approved, budget-constrained model, and every LLM condition uses a single call per scenario in a near-zero decoding regime without a temperature sensitivity or multi-seed robustness study. The architecture comparison therefore does not establish the best attainable end-to-end model performance or generalize to model-recommended sampling settings.

7. Conclusions

This paper presented a hybrid neuro-symbolic method for proof-carrying non-monotonic legal reasoning in LLM-based decision support systems. The method separates LLM-based extraction from symbolic inference, represents legal evidence as source-linked facts and defeasible rules, resolves conflicts through priorities and grounded semantics, and produces proof graphs for accepted conclusions.

The formal contribution is a finite defeasible normative theory and its compilation into an argumentation framework whose grounded extension defines skeptical legal conclusions. The practical contribution is an architecture in which neural extraction is controlled by schemas and source spans, while the final decision layer remains deterministic, auditable, and challengeable.

The evaluation combines controlled formalization, LLM extraction, paired baseline comparisons, public-contract and Russian-law adaptation, error and cycle stress tests, scalability measurements, and clustered lawyer-verification analysis. The results support proof-carrying neuro-symbolic reasoning as a promising and auditable design, while showing that extraction quality, model/temperature sensitivity, conservative semantics, implementation conformance, and human-study design remain open limitations.