Angelos Charalambidis
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Previous Organizations / Institutes
The organizations / institutes from the scholar's other articles in the past ten years
Angelos Charalambidis has a total of 40 co-authors. Here are the top co-authors by number of shared publications:
- Panos Rondogiannis
Informatics and Telecommunications, National and Kapodistrian University of Athens, Greece
15 shared publications Panos Rondogiannis
National and Kapodistrian University of Athens
7 shared publicationsStasinos Konstantopoulos
NCSR “Demokritos
6 shared publications- Stasinos Konstantopoulos
Institute of Informatics and Telecommunications, National Center for Scientific Research (NCSR) Demokritos, Ag. Paraskevi, 15341, Greece
4 shared publications - Alexander Artikis
NCSR “Demokritos
3 shared publications - Anastasios Nentidis
National Center for Scientific Research “Demokritos
3 shared publications
Latest Publications
- 5 November 2026
- Published by Springer Nature
- p. 50-64
lxp-SPARQL: Expressing Lexicographic Preferences for Knowledge Graphs
- 5 November 2026
- Published by Springer Nature
- p. 50-64
lxp-SPARQL: Expressing Lexicographic Preferences for Knowledge Graphs
- Open Access
- 1 March 2026
- Published by Cambridge University Press (CUP) in Theory and Practice of Logic Programming
- Vol. 26 (1-2) , 80-94
Equilibrium Semantics and Strong Equivalence for Higher-Order Logic Programs
One of the most significant achievements of equilibrium logic was the characterization of strong equivalence, a property crucial for program transformation and optimization in answer set programming (ASP). While ASP has recently been extended to a higher-order setting to enhance its expressive power, the lack of a comparable purely logical foundation has made verifying strong equivalence for higher-order programs or even proving the correctness of simple program transformations, a difficult challenge. This paper addresses this gap by developing a logical semantics for higher-order ASP by extending the equilibrium logic framework. Within this extended framework, we demonstrate that every stratified higher-order logic program possesses a unique equilibrium model. Moreover, we establish definability results demonstrating that the syntax of our higher-order language is sufficiently expressive to capture its semantic domains. Finally, and most importantly, we generalize the classical theorem of strong equivalence to the higher-order setting: we prove that two programs are strongly equivalent if and only if they share the same higher-order models.
- 1 March 2026
- Published by Cambridge University Press (CUP) in Theory and Practice of Logic Programming
- Vol. 26 (1-2) , 80-94
Open AccessEquilibrium Semantics and Strong Equivalence for Higher-Order Logic Programs
One of the most significant achievements of equilibrium logic was the characterization of strong equivalence, a property crucial for program transformation and optimization in answer set programming (ASP). While ASP has recently been extended to a higher-order setting to enhance its expressive power, the lack of a comparable purely logical foundation has made verifying strong equivalence for higher-order programs or even proving the correctness of simple program transformations, a difficult challenge. This paper addresses this gap by developing a logical semantics for higher-order ASP by extending the equilibrium logic framework. Within this extended framework, we demonstrate that every stratified higher-order logic program possesses a unique equilibrium model. Moreover, we establish definability results demonstrating that the syntax of our higher-order language is sufficiently expressive to capture its semantic domains. Finally, and most importantly, we generalize the classical theorem of strong equivalence to the higher-order setting: we prove that two programs are strongly equivalent if and only if they share the same higher-order models.
- Open Access
- 1 March 2026
- Published by Cambridge University Press (CUP) in Theory and Practice of Logic Programming
- Vol. 26 (1-2) , 95-111
From Time to Space: The Impact of Linearity in Higher-Order Datalog
We consider a fragment of Higher-Order Datalog with negation and argue that it generalizes the familiar and important fragment of Linear Datalog . We investigate the expressive power of this fragment, establishing a tight connection with the hierarchy of space complexity classes. In particular, we demonstrate that for all k greater than or equals 1 $k \ge 1$ , the left parenthesis k plus 1 right parenthesis $(k+1)$ -order fragment of Stratified Linear Higher-Order Datalog Superscript normal not sign $^\neg$ captures left parenthesis k minus 1 right parenthesis minus sans serif EXPSPACE $(k-1)-\textsf {EXPSPACE}$ . This result suggests that restricting programs to linear recursion shifts the expressive power of the corresponding fragments from time to space, generalizing the classical result that (Stratified) Linear Datalog captures NL . Unlike the first-order setting where an ordering assumption is required to capture sans serif upper N sans serif upper L $\mathsf{NL}$ , our results hold without any such assumption on the input database. The proof relies on simulating space-bounded Turing machines using Stratified Linear Higher-Order Datalog Superscript normal not sign $^\neg$ programs and providing a space-efficient evaluation of the query program. We argue that identifying such computationally well-behaved fragments is a crucial step toward paving the way for practical implementations of Higher-Order Datalog.- 1 March 2026
- Published by Cambridge University Press (CUP) in Theory and Practice of Logic Programming
- Vol. 26 (1-2) , 95-111
Open AccessFrom Time to Space: The Impact of Linearity in Higher-Order Datalog
We consider a fragment of Higher-Order Datalog with negation and argue that it generalizes the familiar and important fragment of Linear Datalog . We investigate the expressive power of this fragment, establishing a tight connection with the hierarchy of space complexity classes. In particular, we demonstrate that for all k greater than or equals 1 $k \ge 1$ , the left parenthesis k plus 1 right parenthesis $(k+1)$ -order fragment of Stratified Linear Higher-Order Datalog Superscript normal not sign $^\neg$ captures left parenthesis k minus 1 right parenthesis minus sans serif EXPSPACE $(k-1)-\textsf {EXPSPACE}$ . This result suggests that restricting programs to linear recursion shifts the expressive power of the corresponding fragments from time to space, generalizing the classical result that (Stratified) Linear Datalog captures NL . Unlike the first-order setting where an ordering assumption is required to capture sans serif upper N sans serif upper L $\mathsf{NL}$ , our results hold without any such assumption on the input database. The proof relies on simulating space-bounded Turing machines using Stratified Linear Higher-Order Datalog Superscript normal not sign $^\neg$ programs and providing a space-efficient evaluation of the query program. We argue that identifying such computationally well-behaved fragments is a crucial step toward paving the way for practical implementations of Higher-Order Datalog. - 9 September 2025
- Published by Springer Nature
- p. 40-56
Implementing a Many-Valued Semantics for Logic Programs with Ordered Disjunction Using ASP
- 9 September 2025
- Published by Springer Nature
- p. 40-56
Implementing a Many-Valued Semantics for Logic Programs with Ordered Disjunction Using ASP
- 8 July 2025
- Published by SAGE Publications in The European Journal on Artificial Intelligence
- Vol. 39 (2) , 251-269
Detecting and Fixing Inconsistencies in Large Knowledge Graphs*
Lately, the availability of massive amounts of data necessitates the adoption of modern representation techniques, such as knowledge graphs (KGs). KGs are typically constructed via automated procedures and by utilizing heterogeneous data sources. This nevertheless hinders the quality of these large resulting KGs, as they might contain contradictions, that is a set of assertions that conflict with some axioms often set by human experts. In turn, classical description logics reasoners cannot be applied as no useful inference results can be generated in the face of inconsistencies. Meanwhile, classical reasoners can be used in order to retrieve the inconsistency explanations, but as the KG size grows larger the required time for this task increases significantly. To address the problem of reasoning with large and inconsistent KGs, we propose an open-source system that detects and fixes inconsistencies by splitting the KG into modules and then processing them in parallel to speed up the process. An empirical evaluation of two datasets illustrates the potential for effective inconsistency detection and fixing of large KGs.
- 8 July 2025
- Published by SAGE Publications in The European Journal on Artificial Intelligence
- Vol. 39 (2) , 251-269
Detecting and Fixing Inconsistencies in Large Knowledge Graphs*
Lately, the availability of massive amounts of data necessitates the adoption of modern representation techniques, such as knowledge graphs (KGs). KGs are typically constructed via automated procedures and by utilizing heterogeneous data sources. This nevertheless hinders the quality of these large resulting KGs, as they might contain contradictions, that is a set of assertions that conflict with some axioms often set by human experts. In turn, classical description logics reasoners cannot be applied as no useful inference results can be generated in the face of inconsistencies. Meanwhile, classical reasoners can be used in order to retrieve the inconsistency explanations, but as the KG size grows larger the required time for this task increases significantly. To address the problem of reasoning with large and inconsistent KGs, we propose an open-source system that detects and fixes inconsistencies by splitting the KG into modules and then processing them in parallel to speed up the process. An empirical evaluation of two datasets illustrates the potential for effective inconsistency detection and fixing of large KGs.
- Open Access
- 1 July 2025
- Published by Cambridge University Press (CUP) in Theory and Practice of Logic Programming
- Vol. 25 (4) , 595-611
The Power of Negation in Higher-Order Datalog
We investigate the expressive power of Higher-Order $Datalog^\neg$ under both the well-founded and the stable model semantics, establishing tight connections with complexity classes. We prove that under the well-founded semantics, for all $k\geq 1$ , $(k+1)$ -Order $Datalog^\neg$ captures $k-\textsf {EXP}$ , a result that holds without explicit ordering of the input database. The proof of this fact can be performed either by using the powerful existential predicate variables of the language or by using partially applied relations and relation enumeration. Furthermore, we demonstrate that this expressive power is retained within a stratified fragment of the language. Under the stable model semantics, we show that $(k+1)$ -Order $Datalog^\neg$ captures $\textsf {co}-(k-\textsf {NEXP})$ using cautious reasoning and $k-\textsf {NEXP}$ using brave reasoning, again with analogous results for the stratified fragment augmented with choice rules. Our results establish a hierarchy of expressive power, highlighting an interesting trade-off between order and non-determinism in the context of higher-order logic programing: increasing the order of programs under the well-founded semantics can surpass the expressive power of lower-order programs under the stable model semantics.- 1 July 2025
- Published by Cambridge University Press (CUP) in Theory and Practice of Logic Programming
- Vol. 25 (4) , 595-611
Open AccessThe Power of Negation in Higher-Order Datalog
We investigate the expressive power of Higher-Order $Datalog^\neg$ under both the well-founded and the stable model semantics, establishing tight connections with complexity classes. We prove that under the well-founded semantics, for all $k\geq 1$ , $(k+1)$ -Order $Datalog^\neg$ captures $k-\textsf {EXP}$ , a result that holds without explicit ordering of the input database. The proof of this fact can be performed either by using the powerful existential predicate variables of the language or by using partially applied relations and relation enumeration. Furthermore, we demonstrate that this expressive power is retained within a stratified fragment of the language. Under the stable model semantics, we show that $(k+1)$ -Order $Datalog^\neg$ captures $\textsf {co}-(k-\textsf {NEXP})$ using cautious reasoning and $k-\textsf {NEXP}$ using brave reasoning, again with analogous results for the stratified fragment augmented with choice rules. Our results establish a hierarchy of expressive power, highlighting an interesting trade-off between order and non-determinism in the context of higher-order logic programing: increasing the order of programs under the well-founded semantics can surpass the expressive power of lower-order programs under the stable model semantics. - Open Access
Dealing with Inconsistency for Reasoning over Knowledge Graphs: A Survey
In Knowledge Graphs (KGs), where the schema of the data is usually defined by particular ontologies, reasoning is a necessity to perform a range of tasks, such as retrieval of information, question answering, and the derivation of new knowledge. However, information to populate KGs is often extracted (semi-) automatically from natural language resources, or by integrating datasets that follow different semantic schemas, resulting in KG inconsistency. This, however, hinders the process of reasoning. In this survey, we focus on how to perform reasoning on inconsistent KGs, by analyzing the state of the art towards three complementary directions: a) the detection of the parts of the KG that cause the inconsistency, b) the fixing of an inconsistent KG to render it consistent, and c) the inconsistency-tolerant reasoning. We discuss existing work from a range of relevant fields focusing on how, and in which cases they are related to the above directions. We also highlight persisting challenges and future directions.
Open AccessDealing with Inconsistency for Reasoning over Knowledge Graphs: A Survey
In Knowledge Graphs (KGs), where the schema of the data is usually defined by particular ontologies, reasoning is a necessity to perform a range of tasks, such as retrieval of information, question answering, and the derivation of new knowledge. However, information to populate KGs is often extracted (semi-) automatically from natural language resources, or by integrating datasets that follow different semantic schemas, resulting in KG inconsistency. This, however, hinders the process of reasoning. In this survey, we focus on how to perform reasoning on inconsistent KGs, by analyzing the state of the art towards three complementary directions: a) the detection of the parts of the KG that cause the inconsistency, b) the fixing of an inconsistent KG to render it consistent, and c) the inconsistency-tolerant reasoning. We discuss existing work from a range of relevant fields focusing on how, and in which cases they are related to the above directions. We also highlight persisting challenges and future directions.
- Open Access
Recursive Function Definitions in Static Dataflow Graphs and their Implementation in TensorFlow
Modern machine learning systems represent their computations as dataflow graphs. The increasingly complex neural network architectures crave for more powerful yet efficient programming abstractions. In this paper we propose an efficient technique for supporting recursive function definitions in dataflow-based systems such as TensorFlow. The proposed approach transforms the given recursive definitions into a static dataflow graph that is enriched with two simple yet powerful dataflow operations. Since static graphs do not change during execution, they can be easily partitioned and executed efficiently in distributed and heterogeneous environments. The proposed technique makes heavy use of the idea of tagging, which was one of the cornerstones of dataflow systems since their inception. We demonstrate that our technique is compatible with the idea of automatic differentiation, a notion that is crucial for dataflow systems that focus on deep learning applications. We describe the principles of an actual implementation of the technique in the TensorFlow framework, and present experimental results that demonstrate that the use of tagging is of paramount importance for developing efficient high-level abstractions for modern dataflow systems.
Open AccessRecursive Function Definitions in Static Dataflow Graphs and their Implementation in TensorFlow
Modern machine learning systems represent their computations as dataflow graphs. The increasingly complex neural network architectures crave for more powerful yet efficient programming abstractions. In this paper we propose an efficient technique for supporting recursive function definitions in dataflow-based systems such as TensorFlow. The proposed approach transforms the given recursive definitions into a static dataflow graph that is enriched with two simple yet powerful dataflow operations. Since static graphs do not change during execution, they can be easily partitioned and executed efficiently in distributed and heterogeneous environments. The proposed technique makes heavy use of the idea of tagging, which was one of the cornerstones of dataflow systems since their inception. We demonstrate that our technique is compatible with the idea of automatic differentiation, a notion that is crucial for dataflow systems that focus on deep learning applications. We describe the principles of an actual implementation of the technique in the TensorFlow framework, and present experimental results that demonstrate that the use of tagging is of paramount importance for developing efficient high-level abstractions for modern dataflow systems.
- Open Access
- 11 September 2024
- Published by Association for Computing Machinery (ACM)
- p. 1-8
Detecting and Fixing Inconsistency of Large Knowledge Graphs
- 11 September 2024
- Published by Association for Computing Machinery (ACM)
- p. 1-8
Open AccessDetecting and Fixing Inconsistency of Large Knowledge Graphs
- Open Access
- 1 July 2024
- Published by Cambridge University Press (CUP) in Theory and Practice of Logic Programming
- Vol. 24 (4) , 737-754
The Stable Model Semantics for Higher-Order Logic Programming
We propose a stable model semantics for higher-order logic programs. Our semantics is developed using Approximation Fixpoint Theory (AFT), a powerful formalism that has successfully been used to give meaning to diverse non-monotonic formalisms. The proposed semantics generalizes the classical two-valued stable model semantics of Gelfond and Lifschitz as well as the three-valued one of Przymusinski, retaining their desirable properties. Due to the use of AFT, we also get for free alternative semantics for higher-order logic programs, namely supported model, Kripke-Kleene, and well-founded. Additionally, we define a broad class of stratified higher-order logic programs and demonstrate that they have a unique two-valued higher-order stable model which coincides with the well-founded semantics of such programs. We provide a number of examples in different application domains, which demonstrate that higher-order logic programming under the stable model semantics is a powerful and versatile formalism, which can potentially form the basis of novel ASP systems.
- 1 July 2024
- Published by Cambridge University Press (CUP) in Theory and Practice of Logic Programming
- Vol. 24 (4) , 737-754
Open AccessThe Stable Model Semantics for Higher-Order Logic Programming
We propose a stable model semantics for higher-order logic programs. Our semantics is developed using Approximation Fixpoint Theory (AFT), a powerful formalism that has successfully been used to give meaning to diverse non-monotonic formalisms. The proposed semantics generalizes the classical two-valued stable model semantics of Gelfond and Lifschitz as well as the three-valued one of Przymusinski, retaining their desirable properties. Due to the use of AFT, we also get for free alternative semantics for higher-order logic programs, namely supported model, Kripke-Kleene, and well-founded. Additionally, we define a broad class of stratified higher-order logic programs and demonstrate that they have a unique two-valued higher-order stable model which coincides with the well-founded semantics of such programs. We provide a number of examples in different application domains, which demonstrate that higher-order logic programming under the stable model semantics is a powerful and versatile formalism, which can potentially form the basis of novel ASP systems.