## Code Snippets: DomiKnowS, DeepProbLog, and Scallop ### Overview The image presents three code snippets, each associated with a different system or framework: DomiKnowS, DeepProbLog, and Scallop. Each snippet demonstrates a specific aspect of the respective system, likely related to defining concepts, probabilistic logic, and data relations. ### Components/Axes * **DomiKnowS (Top-Left, Light Beige Background):** Code snippet defining concepts related to images, digits, and summations. * **DeepProbLog (Top-Right, Light Purple Background):** Code snippet demonstrating probabilistic logic rules for digits and addition. * **Scallop (Bottom-Center, Light Green Background):** Code snippet showing how to add relations and rules within the Scallop framework, specifically for digits and their summation. ### Detailed Analysis or ### Content Details **DomiKnowS:** ``` image = Concept() digit = image(ConceptClass=NumericalConcept) image_pair = Concept() (pair_d0, pair_d1) = image_pair.has_a( digit0=image, 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:** ``` nn(m_digit, [X], Y, [0.....9]):: digit(X,Y). addition(X,Y,Z) :- digit(X,X2), digit(Y,Y2), Z is X2+Y2. ``` **Scallop:** ``` scl_ctx.add_relation( "digit_1", int, input_mapping= list(range(10))) self.scl_ctx.add_relation( "digit_2", int, input_mapping= list(range(10))) self.scl_ctx.add_rule( "sum_2(a + b) :- digit_1(a), digit_2(b)") self.sum_2 = self.scl_ctx.forward_function ("sum_2", output_mapping= [(i,) for i in range(19)]) ``` ### Key Observations * **DomiKnowS:** Focuses on defining hierarchical concepts, such as `image`, `digit`, and `image_pair`. It uses `getattr` to access attributes within these concepts. * **DeepProbLog:** Uses a probabilistic logic syntax to define a digit predicate based on neural network output and an addition rule. * **Scallop:** Demonstrates the creation of relations (`digit_1`, `digit_2`) and a rule for summing two digits (`sum_2`). It also shows the use of a forward function to map the sum. ### Interpretation The image provides a glimpse into three different approaches to knowledge representation and reasoning. DomiKnowS appears to use a concept-based approach with attribute access, DeepProbLog employs probabilistic logic, and Scallop utilizes relations and rules for data manipulation. The snippets suggest that each system is designed for different types of tasks, with DomiKnowS potentially suited for hierarchical knowledge representation, DeepProbLog for probabilistic reasoning, and Scallop for data-driven computations. The common theme is the manipulation of digits and their summation, showcasing how each system handles this basic operation.

\n ## Code Snippets: Logic and Relation Definitions ### Overview The image presents four distinct code snippets, likely representing different modules or components of a larger system. The snippets appear to define concepts, relations, and functions related to numerical operations and image processing. The snippets are arranged in a 2x2 grid. ### Components/Axes The image does not contain axes or charts. It consists of text-based code snippets. The snippets are labeled as follows: * **Top-Left:** DomiKnowS * **Top-Right:** DeepProbLog * **Bottom-Left:** (No explicit label, but related to DomiKnowS) * **Bottom-Right:** Scallop ### Detailed Analysis or Content Details **1. DomiKnowS (Top-Left)** ```python image = Concept() digit = image(ConceptClass=NumericalConcept) image_pair = Concept() (pair_d0, pair_d1) = image_pair.has_a( digit0=image, 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)))) .... ``` This snippet defines a concept `image` and a `digit` associated with it, classified as `NumericalConcept`. It also defines `image_pair` and its relationship to two digits (`pair_d0`, `pair_d1`). The `s` variable is an `image_pair` with a `ConceptClass` of `EnumConcept` and `values` set to `summations`. The code also includes a section appending to `sum_combinations` based on attributes of `digit` and paths related to `pair_d0` and `pair_d1`. **2. DeepProbLog (Top-Right)** ```prolog nn(m_digit, [X], Y, [0....9]):: digit(X,Y). addition(X,Y,Z) :- digit(X,X2), digit(Y,Y2), Z is X2+Y2. ``` This snippet appears to be written in Prolog. It defines a neural network `nn` that takes a digit `X` as input and produces an output `Y`. The rule `digit(X,Y)` is associated with the range 0 to 9. It also defines an `addition` predicate that takes two inputs `X` and `Y`, finds their digit representations `X2` and `Y2`, and calculates their sum `Z`. **3. DomiKnowS (Bottom-Left)** ```python 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)))) .... ``` This snippet is a continuation of the DomiKnowS code from the top-left, repeating the definition of `s` and the `sum_combinations.append` section. **4. Scallop (Bottom-Right)** ```python scl_ctx.add_relation( "digit_1", int, input_mapping=list(range(10))) self.scl_ctx.add_relation( "digit_2", int, input_mapping=list(range(10))) self.scl_ctx.add_rule( "sum_2(a + b) :- digit_1(a), digit_2(b)") self.sum_2 = self.scl_ctx.forward_function( "sum_2", output_mapping=[(i, i) for i in range(19)]) ``` This snippet defines relations `digit_1` and `digit_2` using `scl_ctx.add_relation`, both of type `int` and with input mappings ranging from 0 to 9. It then adds a rule `sum_2(a + b)` that depends on `digit_1(a)` and `digit_2(b)`. Finally, it defines `self.sum_2` as a forward function of `sum_2` with an output mapping that maps each input `i` to itself for `i` in the range 0 to 18. ### Key Observations * The code snippets demonstrate a combination of different programming paradigms (Python, Prolog). * The snippets focus on defining concepts and relations related to digits, images, and summations. * The Scallop snippet appears to be building a system for performing addition of digits. * The DomiKnowS snippets seem to be related to representing and manipulating concepts and their attributes. * The DeepProbLog snippet suggests a probabilistic approach to digit recognition. ### Interpretation The image suggests a system that integrates different approaches to numerical reasoning and image understanding. DomiKnowS appears to provide a conceptual framework, DeepProbLog offers a probabilistic model for digit recognition, and Scallop implements a rule-based system for addition. The combination of these components could be used to build a more robust and flexible system for tasks such as image-based arithmetic or logical reasoning. The repetition in the DomiKnowS snippets might indicate an incomplete or iterative development process. The use of `getattr` and `path` suggests a dynamic and potentially complex object model. The output mapping in Scallop's `forward_function` is a simple identity mapping, which might be a placeholder for a more sophisticated transformation. The overall system seems to be focused on representing and manipulating numerical concepts and their relationships.

## Diagram: Code Snippets from Three Neural-Symbolic Programming Frameworks ### Overview The image displays three distinct code snippets, each contained within a colored box, representing different programming frameworks or languages for defining probabilistic logical models, likely for a digit recognition and addition task. The frameworks are labeled as **DomiKnowS**, **DeepProbLog**, and **Scallop**. The layout is asymmetrical, with the DomiKnowS box occupying the left half, and the DeepProbLog and Scallop boxes stacked vertically on the right half. ### Components/Axes The image is a technical diagram composed of three primary components: 1. **Left Box (Light Beige Background):** Titled "DomiKnowS". Contains Python-like code defining concepts and logical relationships. 2. **Top-Right Box (Light Pink Background):** Titled "DeepProbLog". Contains Prolog-style syntax with neural network integration. 3. **Bottom-Right Box (Light Green Background):** Titled "Scallop". Contains Python code using a context object to define relations and rules. ### Detailed Analysis / Content Details #### **1. DomiKnowS (Left Box)** This section contains Python code defining a model structure. * **Line 1:** `image = Concept()` * **Line 2-3:** `digit = image(ConceptClass=NumericalConcept)` * **Line 5:** `image_pair = Concept()` * **Line 6-9:** `(pair_d0, pair_d1) = image_pair.has_a(digit0=image, digit1=image)` * **Line 11-13:** `s = image_pair(ConceptClass=EnumConcept, values=summations)` * **Line 15:** `...` (Ellipsis indicating omitted code) * **Line 16-22:** A multi-line statement beginning with `sum_combinations.append(` and containing an `andL` function call with nested `getattr` calls specifying paths `('x', pair_d0)` and `('x', pair_d1)`. * **Line 23:** `...` (Ellipsis indicating omitted code) #### **2. DeepProbLog (Top-Right Box)** This section contains logic programming syntax. * **Line 1-2:** `nn(m_digit, [X], Y, [0....9]):: digit(X,Y).` - Defines a neural network predicate `digit(X,Y)` where `Y` is a digit from 0 to 9, inferred from input `X` by network `m_digit`. * **Line 4-6:** `addition(X,Y,Z) :- digit(X,X2), digit(Y,Y2), Z is X2+Y2.` - Defines an `addition` rule: `Z` is the sum of `X2` and `Y2`, where `X2` and `Y2` are the digit values of inputs `X` and `Y`. #### **3. Scallop (Bottom-Right Box)** This section contains Python code interacting with a Scallop context (`scl_ctx`). * **Line 1-4:** `scl_ctx.add_relation("digit_1", int, input_mapping=list(range(10)))` - Adds a relation named "digit_1" of type integer, with an input mapping over the list of integers from 0 to 9. * **Line 5-8:** `self.scl_ctx.add_relation("digit_2", int, input_mapping=list(range(10)))` - Adds a second relation named "digit_2" with the same structure. * **Line 9-11:** `self.scl_ctx.add_rule("sum_2(a + b) :- digit_1(a), digit_2(b)")` - Adds a logical rule defining `sum_2` as the sum of `a` and `b`, where `a` and `b` come from the `digit_1` and `digit_2` relations. * **Line 12-14:** `self.sum_2 = self.scl_ctx.forward_function("sum_2", output_mapping=[(i,) for i in range(19)])` - Creates a forward function for the `sum_2` rule, with an output mapping over tuples for integers from 0 to 18 (the possible range of summing two single-digit numbers). ### Key Observations 1. **Common Task:** All three snippets model the same fundamental problem: recognizing digits from images and computing their sum. 2. **Divergent Paradigms:** * **DomiKnowS:** Uses an object-oriented, concept-based approach with explicit class definitions (`Concept`, `NumericalConcept`, `EnumConcept`) and relationship mapping (`has_a`). * **DeepProbLog:** Uses a logic programming (Prolog) paradigm extended with neural network predicates (`nn/4`) and standard logical rules. * **Scallop:** Uses a Python API to declaratively add relations and rules to a context, then compiles them into a differentiable forward function. 3. **Abstraction Level:** DomiKnowS and Scallop operate at a higher level of abstraction within Python, while DeepProbLog uses a distinct logic syntax. 4. **Output Specification:** The Scallop snippet explicitly defines the output range (0-18) for the sum, which is implicit in the other two frameworks. ### Interpretation This diagram serves as a comparative technical illustration, showcasing the syntactic and conceptual differences between three prominent frameworks for neuro-symbolic AI. It demonstrates how each framework approaches the integration of neural perception (digit recognition) with symbolic reasoning (addition). * **DomiKnowS** emphasizes a structured, ontological view of the problem domain, defining concepts and their relationships explicitly. Its code reads like a domain model definition. * **DeepProbLog** stays closest to traditional logic programming, seamlessly embedding a neural network as a probabilistic predicate within a Prolog-like knowledge base. The logic is concise and declarative. * **Scallop** provides a hybrid Pythonic interface that blends relational database-style declarations (`add_relation`) with logic rules, ultimately producing a differentiable program. The explicit `output_mapping` suggests a focus on compile-time optimization for execution. The side-by-side presentation allows a technical viewer to quickly contrast the programming models, verbosity, and underlying philosophies of these systems for solving an identical, simple task. The choice of framework would depend on factors like the developer's preferred paradigm (logic vs. OO vs. declarative Python), the need for explicit type/range definitions, and the desired level of integration with existing Python codebases.

## 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.