Answer Set Programming (ASP)

The foundational theory behind ASP. A stable model represents a valid solution to the problem. For a given logic program, the semantics define which sets of atoms (facts) are considered acceptable answers. This provides a rigorous mathematical basis for handling default reasoning and non-monotonic logic, where adding new information can invalidate previous conclusions—a critical property for modeling legal exceptions.

ASP programs are typically structured into three parts:

• Generate: Rules that define the search space of potential solutions (e.g., {assign(X)} :- task(X).).
• Define: Auxiliary rules that derive new knowledge from generated facts.
• Test: Integrity constraints (:-) that eliminate candidate solutions violating problem requirements. This clean separation allows for a direct encoding of Constraint Satisfaction Problems (CSPs) and combinatorial optimization.

ASP uses negation as failure (not), which is fundamentally different from classical logical negation. The statement not p is true if there is no evidence proving p. This is essential for modeling defeasible reasoning: a rule like fly(X) :- bird(X), not penguin(X). means birds fly by default, unless they are known to be penguins. This elegantly handles the lex specialis principle in legal reasoning.

Beyond finding any solution, ASP can find the best solution using weak constraints. Unlike hard constraints (:-) that eliminate models, weak constraints penalize less desirable solutions. The solver then searches for the answer set that minimizes the total penalty score. This is crucial for normative conflict resolution, where the goal is to find the most coherent subset of rules with the fewest violations of lower-priority norms.

ASP execution is a two-phase process:

1. Grounding: A grounder (e.g., Gringo) intelligently instantiates the schematic rules with all relevant object constants, creating a large but finite propositional program.
2. Solving: A solver (e.g., Clasp) applies conflict-driven clause learning (CDCL) to find the stable models of the ground program. This architecture allows for highly optimized reasoning over complex, domain-specific knowledge bases.

A formal logic system where adding new premises can invalidate previously valid conclusions. This is critical for ASP's stable model semantics, as legal reasoning constantly encounters exceptions and overrides. Unlike classical logic, non-monotonic logic allows a system to retract a conclusion when new evidence—such as a superior statute or a specific exception—is introduced, making it the foundational mathematical framework for handling defeasible rules in normative conflict resolution.

A mode of inference where a conclusion can be retracted when faced with contradictory evidence or superior rules. In ASP, this is modeled through default negation and rule priorities. A typical example is a general rule with an exception: 'Birds fly' is a defeasible rule that is retracted for the specific case of penguins. This enables the encoding of prima facie obligations that hold unless overridden by a contrary-to-duty obligation or a higher-priority norm.

A computational method for resolving normative conflicts by identifying the largest subset of non-contradictory rules from an inconsistent rule base. When a legal corpus contains direct collisions—such as an obligation to act and a prohibition against the same act—an MCS algorithm computes one or more conflict-free subsets. ASP solvers like clingo can be used to generate these subsets by defining choice rules and integrity constraints that maximize the inclusion of rules while maintaining logical consistency.

A directed acyclic graph representing precedence relationships between legal rules based on three core principles: lex superior (authority hierarchy), lex specialis (specificity), and lex posterior (temporality). In an ASP encoding, this graph is represented as facts like overrides(ruleA, ruleB). The solver traverses this structure to deterministically resolve conflicts, ensuring that a constitutional norm always defeats a conflicting statutory provision in the final answer set.

An extension of default logic that incorporates deontic modalities—obligation, permission, and prohibition—to represent prima facie duties that can be defeated. In ASP, this is implemented by encoding norms as default rules with explicit exception predicates. For example, a contract clause requiring payment by a date is a default obligation that can be defeated by a force majeure exception. This formalizes contrary-to-duty reasoning, a classic challenge in deontic logic.

A technique for organizing rules into ordered layers based on priority or specificity, ensuring deterministic conflict resolution. In ASP, this is achieved through weak constraints or explicit priority atoms that guide the solver to prefer higher strata. When a collision is detected, the system consults the stratification hierarchy: a rule in Stratum 1 always defeats a conflicting rule in Stratum 2. This directly implements the lex specialis principle in a computational framework for legal reasoning.