Real Logic is a recently introduced first-order language where formulas have fuzzy truth values in the interval [0, 1] and semantics are defined concretely with real domains. The Logic Tensor Networks (LTN) framework has applied Real Logic to many important AI tasks through querying, learning, and reasoning. Motivated by real-life relational database applications, we study adding aggregate functions, such as averaging elements of a relation table, to Real Logic. The key contribution of this paper is the formalization of such functions within Real Logic. This extension is straightforward and fits coherently in the end-to-end diferentiable language that Real Logic is. We illustrate it on FooDB, a food chemistry database, and query foods and their nutrients. The resulting framework combines strengths of descriptive statistics modeled by fuzzy predicates, FOL to write complex queries and formulas, and SQL-like expressiveness to aggregate insights from data tables.
Real Logic is introduced in Logic Tensor Networks (LTN) [
Querying, however, remains limited by syntactic limitations of First-Order Logic (FOL).
Despite being a powerful query language on knowledge graphs, FOL cannot express many
useful queries written in the most popular database applications such as SQL. These databases
organize relations in tables defined with rows and columns. We commonly apply
aggregate
functions to extract insight features over sets of row values. For example, the following query
proposed in [
Comparable queries are not adequately captured by traditional logical languages, as their semantics are not naturally equipped with aggregate functions such as S U M or A V G .
In this paper, we study adding aggregate functions to Real Logic. Real Logic can naturally support aggregate functions for two reasons: 1) individuals and domains are grounded with real features, 2) variables are interpreted as finite sequences of individuals. These sequences and real features are reminiscent of the rows in SQL-like tables and constitute ranges over which the aggregate functions can straightforwardly operate.
The paper starts with an overview of Real Logic in Section 2. In Section 3, we formalize aggregate functions as mathematical operators and as part of a Real Logic signature, the latter being the key contribution of this paper. In Section 4, we illustrate the functions with simple queries on FooDB, a food chemistry dataset.
In [
Perhaps the closest fit to this paper are fuzzy querying systems for relational databases
[11, 12, 13]. Real Logic similarly grounds the semantics of formulas with fuzzy truth-values. Let
be a variable that denotes people. To represent is_tall() , rather than using a crisp boolean
condition height() > 180 , one can use a continuous truth-value in [
Real Logic [
Contrarily to the abstract semantics of FOL, the elements of the signature are grounded to data, mathematical functions, and neural computational graphs. The connectives are grounded to fuzzy semantics. To emphasize that symbols are grounded using real-valued features, we use the (x, y) ↦ ||x||||y||
x⋅y
term grounding, denoted by . Individuals are grounded as tensors 1 of real features. Functions
are grounded as real functions, and predicates as real functions that specifically project onto a
value in the interval [
Individuals are typed and belong to domains. Logical domains are grounded to real domains that shape the individuals. For example, alice, bob are individuals of the domain people, and ( people) = ℝ . ℒ-functions and predicates are defined with an arity and a domain for each argument. For functions, we also define an output domain. For example, the function best_friend() takes an argument from people and returns an individual from people.
A variable is grounded as an explicit sequence of individuals from a domain, with 0 < < ∞. 2 This difers from a FOL variable, which is a placeholder for any individual from the universe. Consequently, a term () or a formula () variable , will be grounded to a sequence of values too.
Terms and formulas are constructed recursively in the usual way, given that functional and predicate symbols are applied to an appropriate number of terms with appropriate domains.
Complex formulas are constructed using the usual logical connectives, ∧, ∨, →, ¬, and the quantifiers
∀, ∃. Real Logic interprets connectives using fuzzy semantics, and quantifiers using
special aggregator functions. In particular, [
IR(, ) = 1 − +
NS() = 1 − M ( 1, … , ) = (
1
∑ times in . However, the order of the values in the sequence does not matter. ∑(1 − ) ) 1
In [
∀ (∃ ∶ age() > age( ) (is_parent(, ) )) the boolean condition age() > age( ) restricts the quantification over .
We do not use diagonal quantification in this paper, but the interested reader will find more
information in [
Knowledge is represented not only by logical formulas but also by the grounding which explicitly connects symbols occurring in formulas and what concretely holds in the domain. For example, the grounding of alice in real features that describe her height, age, etc., is knowledge. This grounding definition can be parametric if ( alice)is a set of embedded features to learn. In that case, we write ( alice ∣ ), where is the set of trainable parameters. Similarly, is_friend(alice, bob) can be grounded using an explicit cosine similarity function or can be grounded using a trainable neural network. Consequently, learning knowledge in Real Logic is not limited to inferring new formulas, but also concerns the parameters of a grounding.
We define the satisfaction of a formula as its grounding. Querying a formula is therefore
equivalent to evaluating () , which returns a truth-value in [
3https://docs.python.org/3/library/functions.html#zip (6) (7)
Let define a collection of formulas, as represented in traditional logical knowledge bases. The satisfaction of under a parametric grounding (⋅ ∣ )is defined as the aggregation of the satisfactions of each ∈ . The result depends on the choice of aggregate operator, denoted by SatAgg. Often, SatAgg is defined as ME , also used to ground the ∀ operator. In LTN, one can search the optimal grounding, that is the optimal set of parameters, to satisfy a theory according to the following objective: ∗ = argmax SatAgg ( ∣ ) ∈ (8) Because Real Logic grounds expressions in real and continuous domains, LTN attaches gradients to every sub-expression and consequently learns through gradient-descent optimization.
An aggregate function is a mathematical operation involving a range of values that results in a
single representative value. Existing literature usually defines aggregate functions on (sub)sets
of real or rational numbers [
In many cases, in = out. For example, if in = ℝ, then mean, min, max are all operators that return objects in the same domain. On the other hand, if in = ℝ3, a function count will output results in ℝ (more precisely, ℕ) and therefore in ≠ out.
Notice that, for an application in Real Logic, the behavior of A(∞) does not have to be specified as variables cannot be sequences of infinite length for practical reasons.
Notice also that the aggregators used to approximate ∀, ∃ are a special case of aggregate
functions with in = out = [
Incorporate such aggregate functions into ℒ is straightforward. The concrete, real domains of Real Logic can be mapped to the ones in Definition 1, Additionally, ℒ-variables are sequences, and any term recursively constructed from a variable is a sequence too. Aggregate functions can operate over these sequences.
Definition 2. An ℒ-aggregate function symbol with input domain in and output domain out, is grounded using an aggregate function A (Definition 1) such that ( in) = in and ( out) = out. Let be a variable symbol, and | ()| = , that is is grounded as a sequence of individuals. For any term () with free variable , such that (()) ∈ ( in), we have: ( ()) =
A=1,…, ( (()) () ) (9) where (()) () is the evaluation of (()) using the -th individual of .
The syntax is similar to that of quantifiers, e.g. ∀ () . Here, ∀ is replaced by an ℒ-aggregate function symbol , and the formula () is replaced by a term () . For ease of notation, and if no confusion can arise, we simply write A to denote both the ℒ-symbol and its grounding A. Example 1. Let be a variable that denotes people. In particular, let () = ⟨alice, bob, charlie⟩ denote a sequence of three individuals. We can query the average height of , using an aggregate function mean, with: ( mean height()) = mean3=1 ( height())()
( height(alice)) + ( height(bob)) + ( height(charlie)) = 3 (10) (11) The output is a new term, embedding the average height in the population, which can be used as an input to other formulas.
Notice that we can combine aggregate functions with guarded quantification (see Equation 7) by re-using the same syntax and functionality.
Example 2. Following the Example in 1, let us consider that alice and bob are Italian, but charlie is not. Let Italian() be a boolean predicate that returns either 1 (true) or 0 (false). One can query the average height of Italians with: ( mean∶ () height()) = mean3 = 1 .. ( Italian()) () = 1 ( height(alice)) + ( height(bob)) = 2 ( height())() (12) (13)
Most of the common aggregate functions (except count) are diferentiable. Consequently, they still integrate nicely with the end-to-end diferentiability of Real Logic and LTN. In the following experiments, we only explore querying with aggregate functions. However, aggregate functions could also be integrated with optimization in LTN.
FooDB 4 is a database that provides information on food chemistry and food constituents, including macronutrients, micronutrients, and many of the constituents that give foods their lfavor, color, taste, texture, and aroma. The data is compiled from existing literature and databases, in order to provide the most comprehensive food chemical database.
We focus on querying macronutrient data from FooDB. In total, FooDB lists macronutrient information for 797 ingredients. We average the information sourced from the USDA5 and from the Technical University of Denmark6. We also use some of the simple ontologies about food groups defined in FooDB.
Ingredients are grounded using their macronutrient attributes and their food groups, the latter being encoded as integer labels. Functional symbols are mostly getters of these attributes. We use explicit vocabulary for most of the terms. For example, let be a variable for ingredients. The function symbol prot( ) gives the protein level of ingredients, kcal( ) gives their energy level, and so forth.
For the aggregate functions, we use traditional operators such as mean, max, or std. Predicates such as is_cereal( ) assert if the ingredient belongs to the corresponding food group. In this experiment, such ontology predicates evaluate to 0 (false) or 1 (true).
For grounding the connectives of the language, we use the product configuration presented in Section 2. ME (∀) is implemented with = 20 , making it relatively close to the min operator.
We use two fuzzy predicates is_high and is_low to describe values on a scale. Let be a real value sampled from a distribution . To define how high is compared to the other values in the distribution, we use the concept of Cumulative Distribution Functions (CDF). is_high ( ) = ( ≤ ) (14) 5U.S. Department of Agriculture, Agricultural Research Service. FoodData Central, 2019. https://fdc.nal.usda.gov/ 6Food data (frida.fooddata.dk), version 4, 2019, National Food Institute, Technical University of Denmark Intuitively, we use the probability that another sample will take a value less than or equal to as a truth degree that defines how high the value of is.
In this experiment, we assume that logistic distributions approximately fit the nutrient data. 7 Let be the mean value of the distribution and be its standard deviation. Using the formula of the CDF of a logistic distribution, the model for is_high computes: is_high(, , ) =
S(
) − (15) 1 where S( ) = 1+ − is a sigmoid function. and standard deviation in Equation 15.
is_low is computed by querying ¬is_high. Aggregate functions are used to compute the mean We illustrate using queries about food nutrients in ingredients, that mix descriptive statistics and complex logical queries. In particular, we ask:
Q 1. What cereal product is not high in calories? Q 2. What cereal product is high in protein? Q 3. What cereal product is high in protein and not high in calories? Q 4. For every ingredient, being high in protein implies being high in calories? Q 5. For every ingredient, being high in fats implies being high in calories?
The detailed formulas are in Table 2. We evaluate if a cereal is high in, for example, calories, using other cereals as a scale (notice the guarded quantifier with condition is_cereal() ). When querying about free variables (Q 1 , Q 2 , Q 3 ), we present the top 3 ranking results.
Using a similar approach, we could integrate information on price, seasonability, etc., to rank alternatives on continuous scales. Virtually, there is no limitation to the complexity of queries.
In this paper, primarily motived by commercial database applications, we studied adding aggregate functions to Real Logic. As a querying system, it combines strengths of 1) descriptive statistics, modeled through fuzzy predicates, 2) FOL syntax to write complex queries, and 3) SQL-like expressiveness to aggregate and collect insights from data tables.
As many common aggregate functions are diferentiable, Real Logic with aggregate functions can still be end-to-end diferentiable. If the knowledge graph entries are associated with embeddings, one can use continuous optimization techniques to eficiently answer queries [17, 18, 19]. In particular, in [17], authors propose an approach based on gradient-descent that uses a logical language akin to Real Logic, where fuzzy semantics approximate connectives. The same approach could incorporate aggregate functions and support a wider range of queries.
7In real-life applications, adequate statistical tests should validate the choice of distribution. In this paper, we do not conduct such tests as our results are illustrative and not part of our contribution. j . i n s . 2 0 1 0 . 0 8 . 0 4 3 , publisher: Elsevier. [10] A. Van Gelder, The well-founded semantics of aggregation, in: Proceedings of the eleventh ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems, PODS ’92, Association for Computing Machinery, New York, NY, USA, 1992, pp. 127–138. URL: https://doi.org/10.1145/137097.137854. doi:1 0 . 1 1 4 5 / 1 3 7 0 9 7 . 1 3 7 8 5 4 . [11] S.-M. Chen, W.-T. Jong, Fuzzy query translation for relational database systems, IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics) 27 (1997) 714–721. doi:1 0 . 1 1 0 9 / 3 4 7 7 . 6 0 4 1 1 7 , conference Name: IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics). [12] J. Galindo, A. Urrutia, M. Piattini, Fuzzy Databases: Modeling, Design and Implementation, IGI Global, 2006. URL: http://services.igi-global.com/resolvedoi/resolve.aspx?doi=10.4018/ 978-1-59140-324-1. doi:1 0 . 4 0 1 8 / 9 7 8 - 1 - 5 9 1 4 0 - 3 2 4 - 1 . [13] R. Mama, M. Machkour, A study of fuzzy query systems for relational databases, in: Proceedings of the 4th International Conference on Smart City Applications, SCA ’19, Association for Computing Machinery, New York, NY, USA, 2019, pp. 1–5. URL: https: //doi.org/10.1145/3368756.3369105. doi:1 0 . 1 1 4 5 / 3 3 6 8 7 5 6 . 3 3 6 9 1 0 5 . [14] D. Suciu, D. Olteanu, C. Ré, C. Koch, Probabilistic Databases, Synthesis Lectures on Data Management 3 (2011) 1–180. URL: https://www.morganclaypool.com/doi/abs/10. 2200/S00362ED1V01Y201105DTM016. doi:1 0 . 2 2 0 0 / S 0 0 3 6 2 E D 1 V 0 1 Y 2 0 1 1 0 5 D T M 0 1 6 , publisher: Morgan & Claypool Publishers. [15] E. van Krieken, E. Acar, F. van Harmelen, Analyzing Diferentiable Fuzzy Logic Operators, arXiv:2002.06100 [cs] (2020). URL: http://arxiv.org/abs/2002.06100, arXiv: 2002.06100. [16] E. Grädel, Y. Gurevich, Metafinite Model Theory, Information and Computation 140 (1998) 26–81. URL: https://www.sciencedirect.com/science/article/pii/S0890540197926754. doi:1 0 . 1 0 0 6 / i n c o . 1 9 9 7 . 2 6 7 5 . [17] E. Arakelyan, D. Daza, P. Minervini, M. Cochez, Complex Query Answering with Neural Link Predictors, arXiv:2011.03459 [cs] (2021). URL: http://arxiv.org/abs/2011.03459, arXiv: 2011.03459. [18] T. Friedman, G. V. d. Broeck, Symbolic Querying of Vector Spaces: Probabilistic Databases Meets Relational Embeddings, arXiv:2002.10029 [cs] (2020). URL: http://arxiv.org/abs/2002. 10029, arXiv: 2002.10029. [19] M. Wang, R. Wang, J. Liu, Y. Chen, L. Zhang, G. Qi, Towards Empty Answers in SPARQL: Approximating Querying with RDF Embedding, in: D. Vrandečić, K. Bontcheva, M. C. Suárez-Figueroa, V. Presutti, I. Celino, M. Sabou, L.-A. Kafee, E. Simperl (Eds.), The Semantic Web – ISWC 2018, Lecture Notes in Computer Science, Springer International Publishing, Cham, 2018, pp. 513–529. doi:1 0 . 1 0 0 7 / 9 7 8 - 3 - 0 3 0 - 0 0 6 7 1 - 6 _ 3 0 . As LTN implements Real Logic using Tensorflow computational graphs 8, it inherits from Tensorflow’s built-in optimizations. For example, on a local portable machine, we measure the computation time of two queries averaged on 10000 runs:
Q 6. is_high(kcal(orange),mean kcal(), std kcal()) which takes 2.58 ms to execute, Q 7. is_high(kcal( ), mean kcal(), std kcal()) which takes 3.57ms to execute. Q 6 returns a single result for orange, whereas Q 7 returns results for each ingredient, that is 797 results. One could expect Q 7 to be approximately 797 slower than Q 6 if LTN would need to recompute the terms mean kcal() and std kcal() as many times. Instead, we find that Q 6 is executed in 2.58ms and Q 7 is executed in 3.57ms. Using Tensorflow built-in optimization, LTN can eficiently re-use common parts of the computational graph for optimal complexity.