## Code Snippets: Digit Addition Modeling Across Tools
### Overview
The image contains three code snippets demonstrating different approaches to modeling digit addition and concept relationships across three tools: DomiKnowS, DeepProbLog, and Scallop. Each snippet represents a distinct programming/knowledge representation paradigm.
### Components/Axes
1. **DomiKnowS (Left Panel)**
- Class hierarchy: `Concept` → `NumericalConcept` → `EnumConcept`
- Key elements:
- `image` and `digit` as concept instances
- `image_pair` with `pair_d0` and `pair_d1` attributes
- `sum_combinations` list with `andL` logical operations
- `getattr` path-based attribute access
2. **DeepProbLog (Top Right)**
- Prolog-style logic programming
- Key elements:
- `nn/3` predicate for digit addition
- `addition/3` rule with digit decomposition
- Range constraints `[0...9]` for digit values
3. **Scallop (Bottom Right)**
- Object-oriented Python implementation
- Key elements:
- `scl_ctx` context manager
- `add_relation` for digit mappings
- `sum_2` rule with arithmetic operations
- `forward_function` with output mapping
### Detailed Analysis
**DomiKnowS Implementation**
```python
image = Concept()
digit = image(ConceptClass=NumericalConcept)
image_pair = Concept()
pair_d0 = image_pair.has_a(digit0=image)
pair_d1 = image_pair.has_a(digit1=image)
s = image_pair(ConceptClass=EnumConcept, values=summations)
sum_combinations.append(
andL(
getattr(digit, d0_nm)(path=('x', pair_d0)),
getattr(digit, d1_nm)(path=('x', pair_d1))
)
)
```
**DeepProbLog Implementation**
```prolog
nn(m_digit, [X], Y, [0...9]):- digit(X, X2), digit(Y, Y2), Z is X2+Y2.
addition(X, Y, Z):- digit(X, X2), digit(Y, Y2), Z is X2+Y2.
```
**Scallop Implementation**
```python
scl_ctx.add_relation(
"digit_1", int,
input_mapping=list(range(10))
)
self.sum_2 = self.scl_ctx.forward_function(
"sum_2",
output_mapping=[(i,) for i in range(19)]
)
```
### Key Observations
1. **Paradigm Differences**:
- DomiKnowS uses object-oriented concept chaining
- DeepProbLog employs Prolog-style logical inference
- Scallop implements rule-based forward chaining
2. **Digit Handling**:
- All three tools decompose digits into numerical components
- DomiKnowS uses path-based attribute access
- DeepProbLog uses explicit range constraints
- Scallop implements digit-to-integer mapping
3. **Summation Logic**:
- DomiKnowS builds combinations through logical AND operations
- DeepProbLog uses arithmetic constraints
- Scallop implements explicit forward function mapping
### Interpretation
The three implementations demonstrate different approaches to formalizing digit addition:
- **DomiKnowS** focuses on conceptual relationships through object composition
- **DeepProbLog** emphasizes logical constraints and arithmetic inference
- **Scallop** combines rule-based programming with explicit output mapping
The choice of implementation affects:
1. **Expressiveness**: How naturally the problem domain is represented
2. **Performance**: Efficiency of constraint solving vs object instantiation
3. **Maintainability**: Ease of modifying rules vs class hierarchies
Notably, the Scallop implementation shows explicit handling of output ranges (0-18 for digit sums), while DeepProbLog uses Prolog's built-in range constraints. DomiKnowS's approach appears most flexible for extending to complex concept relationships beyond simple arithmetic.
