Mike's Notes
This is part of a series of thoughtful opinions about using Ontology in software information systems.
Pipi has an existing BORO Engine (bor) (inspired by Chris Partridge's book "Business Objects: Re-engineering for Re-use"), but it runs in reverse: it imports triples to extract entities and relationships, then uses them to build reference relational databases for back-end industry workspaces.
Part seven: A post by Simon Polovina on the Ontolog Forum in response to the original post by James Lee Stakelum.
A nicely formatted PDF of the same post is in the resources below.
Resources
- https://groups.google.com/g/ontolog-forum/c/VimON_gBBjk/m/wco9x287CgAJ
- https://www.linkedin.com/in/simonpolovina/
- https://www.igi-global.com/affiliate/simon-polovina/77733
- https://scholar.google.com/citations?user=gAE3qP0AAAAJ&hl=en
- https://doi.org/10.1007/978-3-540-73681-3_1
- https://groups.google.com/group/ontolog-forum/attach/a3cb1a6f1083c/Why_CGs.pdf?part=0.1 (PDF)
References
- Enterprise Knowledge Representation: Conceptual Graphs, ISO Common Logic, and SAP Graph Foundations, Simon Polovina. August 12, 2026
Repository
- Home > Ajabbi Research > Library > Subscriptions > Ontolog Forum
- Home > Handbook >
Last Updated
24/08/2026
Enterprise Knowledge Representation: Conceptual Graphs, ISO Common Logic, and SAP Graph Foundations
I bring Computer Productivity to Business Creativity by engaging in roles that draw upon my leadership and expertise in Enterprise Architecture and Conceptual Structures, which harmonise computer productivity with human and business creativity. My experience draws on Knowledge Representation and Reasoning, Artificial Intelligence, The Intelligent Enterprise, User Experience (UX), Design Thinking, Cloud, Data Infrastructures, SAP, Web, Service-oriented Architecture (SOA), Object-oriented Analysis and Design, and more. As well as NextGen industrial practice and education, I've published widely, with over 110 learned publications to date.
Abstract
This document presents a comprehensive discussion of the theoretical and practical role of Conceptual Graphs (CGs) in enterprise architectures, their comparative expressivity relative to First-Order Logic (FOL), Description Logics (OWL), and RDF, and their alignment with the ISO/IEC 24707 Common Logic. Additionally, it highlights recent perspectives on trustworthy AI, open vs. closed predicate grammars, and evaluates the comparative landscape of SAP Graph, SAP HANA Knowledge Graph, and SAP Business Data Cloud (BDC) Knowledge Graph across CGIF and CLIF representations.
1 Introduction & Conceptual Graphs Overview
Conceptual Graphs (CGs), developed by John F. Sowa (Sowa 1984), bridge human-readable visual semantics with formal mathematical logic. As introduced in previous foundational work (Polovina 2007), CGs provide a versatile environment for knowledge representation and automated reasoning that directly aligns with enterprise object models.
Key structural advantages of CGs over alternative formalisms include:
- Visual Syntax with FOL Rigour: CGs use an intuitive visual bipartite graph syntax (concepts and conceptual relations) while maintaining an exact mapping via the -operator to First-Order Logic.
- Native -ary Relations: Unlike RDF triples (), CGs support -ary relations without artificial reification.
- Nested Contexts: CGs support nested propositional contexts, allowing clean modal, temporal, and belief representations.
- Graph-Based Reasoning: Operations such as graph projection, join, and restriction enable sound structural reasoning without requiring resolution theorem provers.
This paper evaluates these theoretical properties within modern enterprise architectures. Specifically, we analyse the trade-offs of RDF-based knowledge foundations in SAP Business Data Cloud (BDC) and demonstrate how ISO/IEC 24707 Common Logic representations (CGIF and CLIF) provide a more robust substrate for neuro-symbolic AI.
2 Trustworthy AI, Common Logic, and Closed Grammars
Recent discussions surrounding multi-agent systems and local-first AI architectures highlight the crucial distinction between open-predicate systems and closed relational grammars (Stakelum 2026). Unconstrained open predicates (found in RDF, OWL, and raw Common Logic) incur an integration bottleneck (the “Babel Tax”) when federating across independent domains.
By leveraging standardised specifications under ISO/IEC 24707 Common Logic (ISO/IEC 2018), architectures can combine bounded relational primitives with rich, open concept lattices (e.g., via Formal Concept Analysis), enabling sound neuro-symbolic reasoning without hallucination.
3 Comparing SAP Graph Architectures
Enterprise data foundations often combine multiple distinct graph paradigms. Table 1 outlines three core SAP graph technologies.
Comparison of SAP Graph Technologies
| Feature/Aspect | SAP Graph | SAP HANA Knowledge Graph | SAP BDC Knowledge Graph |
|---|---|---|---|
| Primary Purpose | Unified API graph for cross-SAP integration | In-memory graph engine for HANA Cloud analytics | Business-context-aware semantic graph for AI |
| Scope | Cross-SAP application data | Technical graph database | Business processes, roles, and policies |
| Data Sources | S/4HANA, SuccessFactors, etc. | Relational, spatial, and vector data in HANA | SAP and non-SAP data with embedded context |
| Deployment | SAP BTP | SAP HANA Cloud | SAP BTP (BDC Architecture) |
| Query Languages | SPARQL, SQL | SPARQL, Cypher, SQL | SPARQL, SQL |
| AI Enablement | High | Medium | Very High |
Among these paradigms, the SAP BDC Knowledge Graph represents the most context-aware layer for enterprise AI. However, as evaluated in the following section, its technical implementation on an RDF triple-store foundation introduces structural friction that could be mitigated by a Conceptual Graph architecture.
4 Replacing RDF with Conceptual Graphs in Enterprise Data Foundations
Replacing Resource Description Framework (RDF) with Conceptual Graphs (CGs) in enterprise data foundations—such as the SAP Knowledge Graph capability and its technical implementation in SAP Business Data Cloud (BDC)—would fundamentally transform how enterprise AI, multi-agent systems, and business process models interact with underlying ERP data.
While SAP chose RDF for the SAP Knowledge Graph engine in SAP BDC primarily to leverage established SPARQL standards and existing triple-store tech, opting for a Conceptual Graph foundation would have solved several structural challenges inherent to large-scale ERP semantic layers.
4.1 Architectural Impact: RDF vs.
Conceptual Graphs in Enterprise Systems
4.1.1 Eliminating -ary Reification in Complex Business
Transactions
The RDF Reality: Standard ERP business entities rarely fit neat binary triples (). An SAP purchase order line item involves a vendor, material, quantity, plant, currency, pricing condition, and tax code. In RDF, representing this -ary transaction requires extensive reification or artificial intermediate nodes, bloating the number of triples into the billions and degrading SPARQL join performance.
The CG Advantage: CGs natively support -ary relation nodes linked directly to concept nodes. A multi-party sales order or supply chain movement remains a single, unfragmented hypergraph node. This drastically reduces graph size, avoids join overhead, and makes the schema mirror actual SAP business objects (BAPIs/IDocs) directly.
4.1.2 Built-in Modal Logic for SAP Business Contexts
The RDF Reality: Enterprise data is deeply contextual. A price isn’t just “100 EUR”; it is valid from date to , under condition type , within company code , and subject to a pending workflow approval. RDF lacks a native concept of contexts, forcing developers to resort to Named Graphs or annotations—which break standard triple semantics and fragment reasoning engines.
The CG Advantage: Conceptual Graphs feature nested contexts as a core primitive. A belief state, a temporal validity window, a hypothetical “what-if” planning scenario, or an unapproved workflow step can be cleanly enclosed within a context box. Reasoning rules apply precisely inside specified contexts without leaking state into the broader knowledge base.
4.1.3 Direct Neuro-Symbolic Grounding for AI Agents (Joule & LLM Orchestration)
The RDF Reality: Modern enterprise architectures (like SAP’s Business AI Hub and SAP Knowledge Graph) use Knowledge Graphs to ground LLM agents and prevent hallucinations. However, converting LLM outputs into SPARQL triple patterns is notoriously fragile due to predicate drift, URI matching issues, and rigid triple structures.
The CG Advantage: CGs support graph projection—a sound and complete mechanism for pattern matching. An LLM acting as an abductive engine can propose a tentative solution in Conceptual Graph Linear Form (CGLF/CGIF). The engine uses projection to test if the proposed structure is a valid specialisation of an existing business rule or schema. If the projection fails, the logic engine rejects the hypothesis or pinpoints the exact ungrounded concept.
4.1.4 Convergence with ISO Standards
While RDF is a W3C web recommendation optimised for web-scale linking, CGs align directly with ISO/IEC 24707 Common Logic (ISO/IEC 2018). In enterprise ERP systems where auditability, compliance, and deterministic business rules are non-negotiable, having an underlying representation that translates losslessly into First-Order Logic provides a stronger governance guarantee than triple-store heuristics.
| Structural Dimension | SAP Knowledge Graph on RDF (in BDC) | Conceptual Graph Alternative |
|---|---|---|
| Transaction Modelling | Fragmented into binary triples via reification | Native -ary structures preserving event unity |
| Business Contexts & Rules | Named Graphs / Annotations (Ad-hoc) | First-class Nested Contexts |
| Reasoning Mechanism | Tableau-based subsumption / RDFS rules | Graph Projection, Join, and Restriction |
| Agent AI Grounding | SPARQL translation (prone to join complexity) | Structural graph projection & unification |
| Schema Complexity | Quadratic expansion of edge types (Babel Tax risk) | Compact type hierarchies mapped to business objects |
4.2 Why Didn’t SAP Do It?
The barrier has never been theoretical superiority—it has been ecosystem momentum. The RDF/SPARQL stack offered off-the-shelf open-source parsers, mature triple-store database engines, and an established developer base familiar with Semantic Web tooling. Implementing CGs natively would have required SAP to build and maintain a commercial-grade ISO Common Logic graph engine from scratch.
However, as enterprise systems pivot toward neuro-symbolic AI and local multi-agent orchestration, the architectural overhead of triple stores is becoming a bottleneck. Systems designed around -ary events, nested contexts, and graph projection are proving far better suited for grounding autonomous agents than legacy triple stores.
5 Formal Logic Representations: CGIF and CLIF
5.1 Conceptual Graph Interchange Format (CGIF)
Below is the linear CG serialisation of the comparison among the three SAP technologies, adhering, through CGIF, to ISO/IEC 24707 standards (ISO/IEC 2018).
5.2 Common Logic Interchange Format (CLIF)
The corresponding ISO 24707 CLIF representation provides a direct Lisp-style S-expression syntax suitable for first-order logic provers.
6 Conclusion
While modern enterprise platforms such as SAP Business Data Cloud have successfully adopted RDF triple stores to build context-aware Knowledge Graphs, standard binary triple models introduce significant overhead when representing complex -ary business transactions and nested modal contexts. As demonstrated in this analysis, adopting Conceptual Graphs (CGs) directly resolves these structural bottlenecks through native -ary relations, first-class nested contexts, and graph-projection reasoning.
Furthermore, grounding enterprise architectures in ISO/IEC 24707 Common Logic provides the deterministic First-Order Logic rigour required for trustworthy neuro-symbolic AI and autonomous agent orchestration. By formalising enterprise semantic layers in standardised serialisations like CGIF and CLIF, enterprise architectures can bypass the combinatorial integration challenges of unconstrained open predicates while guaranteeing verifiable, hallucination-free decision support across complex business domains.
References
- ISO/IEC. 2018. ISO/IEC 24707:2018 Information technology — Common Logic (CL): A framework for a family of logic-based languages. International Organization for Standardization.
- Polovina, Simon. 2007. “An Introduction to Conceptual Graphs.” In Conceptual Structures: Knowledge Architectures for Smart Applications. Proceedings of the 15th International Conference on Conceptual Structures (ICCS 2007), edited by Uta Priss, Simon Polovina, and Richard Hill, vol. 4604. Lecture Notes in Artificial Intelligence. Springer-Verlag. https://doi.org/10.1007/978-3-540-73681-3_1.
- Sowa, John F. 1984. Conceptual Structures: Information Processing in Mind and Machine. Addison-Wesley.
- Stakelum, James Lee. 2026. The Architecture That Makes AI Trustworthy Wasn’t Invented. It Was Discovered. Review of the Ontology Summit 2026 Presentation by Arun Majumdar and John F. Sowa.
No comments:
Post a Comment