We thank the reviewer for their suggestions and will add the discussions to the revised paper.

Discussion on other uses of Dolphin

Dolphin can be used for any task where the output of a model can be cast as a distribution over probabilities, including discriminative models. Consider an example of autonomous driving, where an object detector is used to detect obstacles on the road. Commonly used models like Faster R-CNN (cite) output bounding boxes, class probabilities, and confidence scores for multiple objects in an image. One can create a custom Python class that associates the coordinates of each bounding box with a Distribution object over the classes and their probabilities output by the model:

CLASSES = [‘car’, ‘person’, ‘shirt’, …]
class DetectedObject
    def __init__(self, coords, score, class_logits):
        self.coords = coords
        self.score = score
        self.distr = Distribution(CLASSES, class_logits)

One can then derive the probability that given a pair of objects, it represents a person inside a car:

# function to check if one set of coordinates is inside another
def is_inside(coord_a, coord_b):
    …

def person_inside_car = apply(o1.distr, o2.distr,
    lambda c1, c2: c1 == “person” and c2 == “car” and is_inside(o1.coords, o2.coords))

Here, person_inside_car will be a distribution over “True” and “False”, giving the probability that detected objects o1 and o2 represent a person inside a car.

Explanation of Operations

We describe the Filter and Union operations in more detail:

Filter. In the Filter operation, the symbols that do not satisfy the filtering condition are completely removed from the returned distribution. So consider a Distribution $D :: \\{ 0 \rightarrow t_1, 1 \rightarrow t_2, 2 \rightarrow t_3\\},$ with a filtering condition lambda x: x % 2 == 0 which removes odd numbers from the distribution. The returned Distribution will be $D_\text{filtered} :: \\{ 0 \rightarrow t_1, 2 \rightarrow t_3 \\}.$

Union. In the Union operation, a new Distribution is returned that contains the symbols from both input Distributions. A Union can occur over any pair of Distributions regardless of the types of symbols. For instance, consider as inputs Distributions $D :: \\{0 \rightarrow t_1, 1 \rightarrow t_2, 2 \rightarrow t_3\\} \text{ and } D' :: \\{1 \rightarrow t\'\_1 , 4 \rightarrow t\'\_2\\}.$ The output Distribution will be $D_\text{union} :: \\{0 \rightarrow t_1, 1 \rightarrow t_2 \oplus t'_1, 2 \rightarrow t_3, 4 \rightarrow t'_2\\}.$ Note here that the tags for common symbols are disjuncted.

Restricted to Semiring Structures Over Tags

While symbolic operations in Dolphin are indeed defined using semiring structures over tags—similar to existing frameworks such as Scallop—this abstraction is primarily introduced to facilitate efficient computations, including GPU acceleration, and has been shown to be quite flexible for solving neurosymbolic tasks.

We thank the reviewer for their suggestions. We will add the unit of time in the caption of Table 2 and fix the grammatical errors they pointed out.

We indicate the provenance used for each benchmark in Section 4.4 (RQ2: Accuracy) and compare both provenances in Section 4.5 (RQ3: Provenance Comparisons).

The Dolphin CLUTRR program is designed for batched computations, unlike Scallop, which evaluates each sample independently. Moreover, the Scallop programs for CLUTRR-3 and CLUTRR-4 exhibit higher accuracy variance, indicating possible minor numerical issues or nondeterminism. We believe these factors account for the small (~2% pts) accuracy difference.

We thank the reviewer for suggestions on experiment design and additional literature. We will add the results from additional experiments discussed below in the paper and expand the related work.

Scallop’s Performance on Mugen

Scallop’s Mugen results were obtained from their PLDI’23 artifact. Despite significant efforts, we were unable to reproduce those results, thus, we reported the numbers we observed. We reached out to the Scallop authors, who provided us with a different symbolic program that reproduced their results using DTKP-WMC (K=5). We also redesigned the Dolphin program for Mugen to be more batchable across samples, which we run with DTKP-AM (K=5):

While Scallop now converges, Dolphin still achieves higher accuracies and trains ~3.3x faster than Scallop.

Experiment Results without a Strict Timeout

We ran the experiments until Scallop converged and report its accuracies. We will do the same for the other baselines in the revised version.

For Path-128 and 256, Scallop converges to Dolphin’s accuracies in ~11.6 and ~31.7 hours (~2.4x and ~6x slower), respectively. For HWF-15, Scallop reaches 100% on only 2 seeds out of 6, but stays below 12.5% on the rest even after ~46 hours of training on average. For HWF-19, none of the 6 runs were able to converge after ~50 hours of training on average.

DTKP-AM with Different Values of K

We report preliminary results of this experiment. As a general trend, with the exception of HWF-19, the value of K doesn’t have much impact on the final accuracy (Acc). Increasing K also does not significantly impact the per epoch time (T/ep) due to DTKP-AM's vectorizations.

Benefits of DTKP-AM

Empirically, DTKP-AM offers an advantage over DAMP of ~2% pts on average across the complex versions of all tasks. It significantly outperforms DAMP by ~50% pts on HWF-15 and ~75% pts on HWF-19, while also yielding up to ~5% pts higher accuracy on Mugen and ~3% pts improvement on PathFinder.

Model Details

For HWF/MNIST, we use the same CNN architecture as Scallop (will be added in Appendix D). For CLUTRR, we use Scallop’s Roberta configuration: a pretrained model (roberta-base) finetuned while training the classification head.

Symbolic Computations on the GPU

Precompiling symbolic computations on the GPU poses a few challenges. First, it restricts symbolic programs to PyTorch tensor operations, a small subset of the Python functions Dolphin currently supports. Second, since we perform one set of CPU computations per batch (~16% of the train time per batch), there is limited scope for improving the training time. The parallelism will only occur across combinations of symbols, not over samples in a batch. Third, enumerating all possible combinations of symbols on the GPU could pose memory consumption issues on complex tasks, as seen with LTN.

One could potentially compile symbolic computations on the GPU by representing symbols as GPU tensors and implementing user-defined functions as tensor operations since Dolphin supports arbitrary Python objects. We tested this strategy on Sum-5, but it did not show any improvements in training time, and was 2 seconds slower to train per epoch. We consider developing efficient strategies for compiling symbolic computations directly onto GPUs an exciting direction for future research.

Related Work

Thank you for highlighting these related papers. KLAY (ICLR’25) lacks released code, preventing direct comparison. It compiles symbolic and probabilistic computations into GPU operations by transforming arithmetic circuits from Boolean logic into layered tensor structures. In contrast, Dolphin separates CPU-based symbolic reasoning from GPU-based probabilistic computations. The paper also omits comparisons against LTN or Scallop on Dolphin’s benchmarks. DeepSoftLog improves NTP by using probabilistic semantics instead of fuzzy semantics, enabling non-redundant proofs, well-defined proof scores, and non-sparse gradients. A-NESI uses learned neural models to approximate the exact probabilistic semantics of WMC, boosting scalability. We will include these works in the related work section.