Choice Disjunctive Queries in Logic Programming

One of the long-standing research problems on logic programming is to treat the cut predicate in a logical, high-level way. We argue that this problem can be solved by adopting linear logic and choice-disjunctive goal formulas of the form $G_0 \add G_1$ where $G_0, G_1$ are goals. These goals have the following intended semantics: $choose$ the true disjunct $G_i$ and execute $G_i$ where $i (= 0\ {\rm or}\ 1)$, while $discarding$ the unchosen disjunct. Note that only one goal can remain alive during execution. These goals thus allow us to specify mutually exclusive tasks in a high-level way.

💡 Research Summary

The paper tackles the long‑standing problem of giving the Prolog cut operator a logical, high‑level interpretation. Traditional cuts are procedural constructs that prune the search space but lack a declarative meaning, making reasoning about program semantics difficult. To address this, the authors adopt concepts from linear logic—specifically the notion of resource consumption—and introduce a new kind of goal, the choice‑disjunctive goal (G_0 \add G_1). Here (G_0) and (G_1) are ordinary logical goals, and the connective (\add) denotes a “choice” between them: during execution the system non‑deterministically selects one of the two goals, executes the chosen one using the standard SLD‑resolution rules, and discards the unchosen goal entirely. This mirrors the effect of a cut (which eliminates alternative branches) but does so in a way that is part of the logical semantics rather than an ad‑hoc procedural directive.

The authors formalize the semantics in two layers. The first layer is a selection rule that rewrites a choice‑disjunctive goal into either (G_0) or (G_1). The second layer applies the usual operational semantics of logic programming to the selected goal. By making the selection step explicit in the logical calculus, the overall execution becomes a composition of logical inference steps, preserving declarative clarity while still providing the pruning power of cuts.

Implementation is deliberately lightweight. The authors show that a conventional Prolog engine can be extended with a new goal type that is pushed onto the goal stack. When a (\add) node is encountered, the engine nondeterministically chooses a branch, rewrites the stack accordingly, and proceeds. Backtracking naturally supports the nondeterministic choice, and because the unchosen branch is discarded immediately, the search space and memory consumption are reduced compared to a naïve disjunction.

Several illustrative examples demonstrate the expressive benefits. A rule such as “process exactly one order” can be written as process_order \add reject_order, eliminating the need for explicit cut‑based control. Similarly, mutually exclusive alternatives in decision‑making can be encoded as option_a \add option_b, yielding clearer, more maintainable code. The authors argue that this style also aids debugging: the chosen and discarded paths are explicit in the trace, making it easier to understand why certain alternatives were never explored.

In the related‑work discussion, the paper contrasts its approach with existing extensions like if‑then‑else, soft‑cut, and other control‑operator based mechanisms. Those alternatives either retain procedural flavor or require meta‑programming tricks, whereas the choice‑disjunctive goal is grounded in a well‑studied logical framework (linear logic) and integrates seamlessly with the existing resolution machinery.

The paper acknowledges limitations and outlines future directions. Current prototypes rely on simple backtracking for choice; richer strategies such as probabilistic selection or cost‑based optimization are left for later work. Moreover, integrating (\add) with other linear‑logic connectives (e.g., tensor (\otimes) or with‑operator (&)) could enable more sophisticated resource‑aware control flows. Nonetheless, the contribution is significant: it provides a logically sound replacement for cut, bridges the gap between declarative semantics and procedural control, and opens a path toward more expressive, high‑level logic programming languages.