A working RDF-Turtle and SPARQL rebuttal of Simon Polovina's CGIF/CLIF-versus-RDF paper, second in a series answering triple-store critiques with running standards, not just prose.
Simon Polovina's ontolog-forum paper argues that Conceptual Graphs — serialized as CGIF and CLIF under ISO/IEC 24707 Common Logic — should replace RDF in enterprise systems such as the SAP BDC Knowledge Graph.
The case rests on six structural claims: that RDF forces reification for n-ary business transactions, has no native concept of context, produces fragile LLM-to-SPARQL translation, offers only ‘triple-store heuristics’ rather than a lossless mapping to first-order logic, reasons through tableau subsumption and RDFS rules alone, and suffers a quadratic Babel Tax that CG's closed type hierarchies are said to avoid.
Each claim is answered below with working RDF-Turtle and SPARQL — not prose alone. The throughline: every capability the paper credits uniquely to CGIF/CLIF — n-ary relation nodes, context boxes, sound-and-complete projection, lossless first-order logic, projection/join/restriction, and a closed predicate vocabulary — already exists in standard RDF 1.1/1.2 tooling: n-ary resources, Named Graphs, RDF-star, SHACL, OWL2 entailment, and the SPARQL algebra itself.
The sharpest claim cuts the other way. John Sowa's own cover note, posted in the very same thread, states that Common Logic is itself an open-predicate system — just like RDF and OWL — so CGIF inherits the identical Babel Tax cost it is credited with escaping.
Polovina's own worked comparisons and direct quotations for each of the six claims made against RDF/SPARQL in favor of Conceptual Graphs/CGIF/CLIF, reproduced verbatim for accurate critique.
For each claim, a working RDF-Turtle and SPARQL correction using Named Graphs, RDF 1.2 quoted triples, SHACL, and SPARQL CONSTRUCT used explicitly as a deterministic rules language, demonstrating each alleged deficiency is a gap in the paper's assumptions about RDF/SPARQL tooling, not a structural limit of RDF as a data model.
The W3C's own n-ary relations pattern (in production use across schema.org Actions and PROV-O Activities since before 2010) models the whole line item as a single subject IRI; every property attaches directly to that one resource. Seven properties on one resource produce exactly seven triples sharing one subject — not reification, not artificial intermediate nodes, and nowhere near 'billions.' Thi
SPARQL 1.1's dataset model (default graph plus a set of named graphs) has been a W3C Recommendation since 2013; it does not 'break' triple semantics, it extends the RDF abstract syntax with a fourth (graph) term precisely so context can be first-class. A price's validity window, condition type, company code, and pending workflow approval are properties inside that named-graph context box — structu
'Predicate drift' is exactly the failure mode SHACL shapes exist to catch: an sh:in constraint on the predicate vocabulary rejects any LLM-proposed triple whose predicate is not a recognized specialization of the schema, and pinpoints which triple failed — the identical behavior credited to CG projection ('the engine rejects the hypothesis or pinpoints the exact ungrounded concept'). Where the LLM
RDF's model-theoretic semantics has been a W3C Recommendation (RDF 1.1 Semantics) since 2014, and OWL 2's profiles (RL, QL, EL) are deliberately bounded, decidable fragments of first-order logic — SPARQL CONSTRUCT-chain reasoning over them is provably equivalent in expressive power to Datalog, meaning it always terminates and always produces the same answer. Full, unrestricted Common Logic/CLIF, b
SPARQL 1.1's formal algebra (W3C Recommendation) is defined in exactly relational-algebra terms: a SELECT clause is a projection over the variable set, sharing a variable across multiple triple patterns in the same WHERE clause is a join, and a FILTER clause is a restriction. A single SPARQL query below performs all three natively — the identical trio of operations the source paper credits uniquel
The self-contradiction is on the record in the same thread: Sowa's own cover note states 'Common Logic is an open-predicate system. So is RDF. So is OWL' before describing the same quadratic Babel Tax the paper credits CG with escaping — but CGIF/CLIF's predicate vocabulary is precisely as open as RDF's (any domain expert may define any relation; the paper's own SAP_Graph/SAP_HANA_Knowledge_Graph/
The six corrections above are instantiated as real instance data in a companion flat-Turtle file, loadable into a quad store (e.g. Virtuoso) the same way as the main TTL: a single resource landing in one named graph equal to its own URL. Every :correctedSparql/:demoQ query below is scoped to that one graph via FROM NAMED/GRAPH, distinguished internally by subject IRI and rdf:type. The illustrative GRAPH { ... }-wrapped Turtle shown in :cor1/:cor2's :correctedTurtle still demonstrates the general RDF Named Graph capability as notation. The SPARQL queries below run against this dataset in the SPARQL Workbench, not merely as documentation strings.
Companion flat-Turtle file with the actual corrected instance triples for the six RDF corrections (:cor1 through :cor6), landing in one named graph equal to its own URL, plus the RDF 1.2 quoted-triple hypothetical price scenario from :cor2. Load it and run the ten SPARQL queries below against live data.
Author of the 2007 ICCS foundational Conceptual Graphs paper (Polovina 2007) and the 2026 ontolog-forum CGIF/CLIF-versus-RDF paper this rebuttal answers.
Company demonstrating a twelve-agent, GPU-free local inference engine built on Definite Clause Grammars and Common Logic; winner of the G7 GovAI Grand Challenge.
Interactive graph visualization derived from the companion RDF. Click nodes to resolve, drag to explore. Graph data embedded from companion RDF at generation time.
Query this knowledge graph on URIBurner. The editor opens on the canonical SAMPLE entity-type summary (DAV named graph). Pick a recipe, edit freely, then run live or copy.
Reproduced verbatim from the companion RDF. Execute loads the query into the workbench below and runs it live.
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-claude_sonnet_5-1.ttl#>
CONSTRUCT { ?lineItem ?p ?o }
FROM NAMED <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl>
WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl> { ?lineItem a :PurchaseOrderLineItem ; ?p ?o } }Returns all seven line-item properties (schema:seller, schema:material, schema:orderQuantity, :plant, schema:priceCurrency, :pricingCondition, :taxCode) plus rdf:type from one query, one subject, zero reification — plus two more properties (:supplier, :hasVendor) this same subject also carries from the demo dataset's cor3/cor6 examples, since it is one shared subject IRI within the single loaded graph.
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-claude_sonnet_5-1.ttl#>
SELECT ?p ?o
FROM NAMED <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl>
WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl> { :poLineItem4711 ?p ?o } }Identical WHERE pattern to Q1, but SELECT ?p ?o instead of CONSTRUCT — returns the same match as a variable-bindings table rather than a serialized RDF graph, which most SPARQL clients (including Virtuoso's default HTML results view) render more directly than a CONSTRUCT result.
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-claude_sonnet_5-1.ttl#>
CONSTRUCT { ?price :effectiveIn :CompanyA ; :requiresApproval true }
FROM NAMED <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl>
WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl> { ?price :companyCode :CompanyA ; :approvalStatus :PendingApproval } }The rule never leaves the named-graph context box — no leaking into the broader knowledge base, matching CGIF's own context-scoping claim.
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-claude_sonnet_5-1.ttl#>
SELECT ?price ?companyCode ?approvalStatus
FROM NAMED <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl>
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl> {
?price :companyCode ?companyCode ; :approvalStatus ?approvalStatus .
FILTER(?companyCode = :CompanyA && ?approvalStatus = :PendingApproval)
}
}Same qualifying condition as Q2, returned as a bindings table (?price, ?companyCode, ?approvalStatus) rather than the CONSTRUCTed :effectiveIn/:requiresApproval triples.
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-claude_sonnet_5-1.ttl#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX schema: <http://schema.org/>
PREFIX prov: <http://www.w3.org/ns/prov#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
# Compact RDF 1.2 (RDF-star) form, resolved directly by Virtuoso's SPARQL Workbench:
# SELECT ?scenario ?assertedBy WHERE { << :price100 schema:price "120"^^xsd:decimal >> :scenario ?scenario ; prov:wasAttributedTo ?assertedBy . }
# Equivalent rdf:Statement-reified form, portable to any RDF 1.1 SPARQL engine (used in the demo dataset):
SELECT ?scenario ?assertedBy
FROM NAMED <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl>
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl> {
?stmt a rdf:Statement ; rdf:subject :price100 ; rdf:predicate schema:price ; rdf:object "120"^^xsd:decimal ;
:scenario ?scenario ; prov:wasAttributedTo ?assertedBy .
}
}The what-if price is a statement-level annotation, distinct from the asserted default price — finer-grained than a whole named graph. Shown in both RDF 1.2 quoted-triple form (as Virtuoso resolves it) and its rdf:Statement-reified equivalent (as the loadable demo dataset stores it, for portability across RDF 1.1-only engines).
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-claude_sonnet_5-1.ttl#>
PREFIX schema: <http://schema.org/>
CONSTRUCT { ?s schema:seller ?o }
FROM NAMED <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl>
WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl> { ?s :supplier ?o } }Normalizes an LLM-proposed 'supplier' predicate to the real shared vocabulary term schema:seller via owl:equivalentProperty — deterministic, not a discarded hypothesis.
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-claude_sonnet_5-1.ttl#>
SELECT ?s ?o
FROM NAMED <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl>
WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl> { ?s :supplier ?o } }Identical WHERE pattern to Q4, but SELECT ?s ?o instead of CONSTRUCT — shows the pre-normalization :supplier assertion directly as a bindings table, for comparison against Q4's normalized schema:seller output graph.
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-claude_sonnet_5-1.ttl#>
CONSTRUCT { ?tech a :BusinessContextAwareTechnology }
FROM NAMED <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl>
WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl> { ?tech a :Technology ; :deploymentEnvironment :SAP_BTP ; :aiEnablementLevel :VeryHigh . } }The RDF-native counterpart to the source paper's own CLIF (forall (x) (if (and ...) ...)) rule — bounded, decidable, always terminates.
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-claude_sonnet_5-1.ttl#>
SELECT ?tech
FROM NAMED <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl>
WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl> { ?tech a :Technology ; :deploymentEnvironment :SAP_BTP ; :aiEnablementLevel :VeryHigh . } }Identical WHERE pattern to Q5, but SELECT ?tech instead of CONSTRUCT — the same rule's conclusion (which technology qualifies) shown as a bindings table rather than the CONSTRUCTed rdf:type triple.
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-claude_sonnet_5-1.ttl#>
PREFIX schema: <http://schema.org/>
SELECT ?techName ?purpose
FROM NAMED <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl>
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/cgif-clif-rdf-rebuttal-demo-data-claude_sonnet_5-1.ttl> {
?tech schema:name ?techName ; :primaryPurpose ?purpose ; :aiEnablementLevel ?level .
FILTER(?level = :VeryHigh)
}
}SELECT = projection, shared ?tech variable across triple patterns = join, FILTER = restriction — the exact trio CGIF credits uniquely to graph projection.
No. The W3C's own n-ary relations pattern models the whole transaction as one resource with as many properties as the transaction has parties — no reification, no blank-node fragmentation, no triple bloat. Seven properties produce seven triples sharing one subject IRI, exactly as demonstrated in :cor1.
No. SPARQL 1.1's dataset model (default graph plus named graphs) is a W3C Recommendation since 2013, extending RDF's abstract syntax with a fourth graph term. It is standardized semantics, not a semantics-breaking bolt-on — see :cor2.
No — the fragility the paper describes (predicate drift, URI matching) is precisely what SHACL shape validation and owl:equivalentProperty-driven CONSTRUCT normalization are built to catch and correct, giving the same sound-and-complete specialization test credited to CG projection — see :cor3.
RDF has a W3C-standardized model-theoretic semantics, and OWL2's profiles are deliberately bounded, decidable FOL fragments — SPARQL CONSTRUCT reasoning over them is Datalog-equivalent and always terminates. Unrestricted CLIF has full FOL expressivity, which is undecidable in general; bounding to a decidable fragment is a stronger determinism guarantee for enterprise governance, not a weaker one — see :cor4.
No. SPARQL's own algebra performs projection, join, and restriction natively (SELECT, shared variables, FILTER), and RDF stacks additionally support RDFS++/OWL2-QL entailment and rule-based forward chaining (e.g. FuXi N3) beyond tableau — see :cor5.
Yes — this is definitional, not incidental. SPARQL 1.1's formal semantics (W3C Recommendation) define SELECT as projection over the variable set, multiple triple patterns sharing a variable as a join, and FILTER as restriction — the exact operations named in the source paper's own 'Graph Projection, Join, and Restriction' row — see :cor5, :demoQ6.
No — the same thread contains the rebuttal. Sowa's cover note states Common Logic is itself 'an open-predicate system. So is RDF. So is OWL,' meaning CGIF inherits the identical quadratic-mapping cost credited to it as an escape from — see :cor6, :babelTaxQuote.
Shared, dereferenceable Linked Data vocabularies — schema.org alone defines 800+ types reused unmodified by millions of independent web pages, avoiding pairwise predicate-mapping negotiation entirely. rdfs:subPropertyOf additionally bounds new relational predicates under small superproperty sets — see :cor6.
Yes, at two granularities: a named graph for a whole context (e.g. a company code's pricing scope), or an RDF 1.2 quoted triple for a single-statement hypothetical (e.g. one what-if price scenario) without needing a separate named graph — see :cor2.
Yes — CONSTRUCT-chain reasoning over RDF/OWL2-RL is provably Datalog-equivalent: bounded, terminating, and deterministic. It is the direct RDF counterpart to the paper's own CLIF forall/if rule for BusinessContextAware technologies — see :cor4, :demoQ5.
No. The claim under rebuttal is narrower: that RDF/SPARQL is structurally incapable of the six properties described, and must therefore be replaced. Each correction shows the property is already available in standard RDF 1.1/1.2 tooling — a comparative-fit argument, not a claim that Common Logic lacks value for other purposes.
No — this is the second entry in the series. The first, at https://linkeddata.uriburner.com/DAV/demos/daas/why-the-triple-is-the-wrong-grain-rebuttal-claude_code-1.html, answered James Stakelum's twelve alleged triple-grain failures the same way: reproducing the article's own examples and pairing each with a working named-graph, RDF-star, PROV-O, OWL2, SHACL, or FuXi correction — see the synopsis at the top of :analysis.
The bracket-notation linear serialization of a Conceptual Graph, standardized as one dialect under ISO/IEC 24707 Common Logic; used in Polovina's paper to represent the SAP graph comparison as concept and relation nodes.
The Lisp-style S-expression serialization of a Common Logic text, the second ISO/IEC 24707 dialect used in Polovina's paper, including a (forall (x) (if ... ...)) inference rule directly analogous to a SPARQL CONSTRUCT rule.
The ISO standard for a family of first-order-logic-based languages (of which CGIF and CLIF are dialects); per John Sowa's own cover note, an open-predicate system in the same sense as RDF and OWL, and therefore subject to the same Babel Tax argument leveled against them.
The CG operation testing whether a candidate graph is a valid specialization of an existing schema graph; this rebuttal's RDF-native equivalent is SHACL shape validation combined with owl:equivalentProperty/rdfs:subPropertyOf-driven CONSTRUCT normalization.
An IRI-identified set of triples, forming the fourth (graph) term of an RDF quad and the standardized SPARQL 1.1 dataset context mechanism; used here as the RDF-native equivalent of a CGIF context box.
The RDF 1.2 extension letting a whole triple be quoted and used as the subject of another triple, enabling statement-level (rather than whole-graph-level) context annotation — used here for the nested what-if price scenario.
The Shapes Constraint Language for validating RDF graphs against structural constraints; used here as the sound-and-complete specialization/rejection test answering the graph-projection claim.
A decidable, function-free subset of first-order logic used for deductive database rules; SPARQL CONSTRUCT reasoning over RDF/OWL2-RL is provably equivalent in expressive power to Datalog, giving guaranteed termination unlike unrestricted Common Logic/CLIF.
James Stakelum's term for the quadratic (O(n^2)) integration cost of pairwise-mapping predicates across independently defined open-predicate vocabularies; per Sowa's own cover note, a property shared by Common Logic, RDF, and OWL alike, not one RDF alone incurs.
The W3C's standard pattern for modeling a relation among more than two things in RDF: mint one resource IRI for the relation/event and attach every participant as a property of that resource — no reification required.
A deliberately bounded, decidable fragment of OWL 2 DL (itself a decidable fragment of first-order logic); trades some raw FOL expressivity for guaranteed reasoner termination — the enterprise-governance property this rebuttal argues RDF/OWL already provides more strongly than unrestricted CLIF.
OpenLink Virtuoso's storage model, in which every RDF triple is physically stored as a (subject, predicate, object, graph) quad, with built-in RDFS++/OWL2-QL entailment, SPARQL 1.1, RDF 1.2 (RDF-star), and SHACL validation — the engine running every correction demonstrated in this rebuttal.
Mint one IRI for the transaction (line item, sales order, movement) and attach every participant as a direct property of that resource, ideally inside a dedicated named graph. See :cor1.
Enclose validity windows, condition types, and approval states in a named graph; reach for an RDF-star quoted triple only when a hypothetical or belief needs to attach to one specific statement rather than the whole context. See :cor2.
Define an sh:in constraint on the accepted predicate set for agent-proposed triples, and declare owl:equivalentProperty mappings for known synonyms so a CONSTRUCT rule normalizes drift instead of discarding valid hypotheses. See :cor3.
Write inference as SPARQL CONSTRUCT rules over RDF/OWL2-RL; this stays Datalog-equivalent, decidable, and terminating — the property enterprise governance actually needs, unlike unrestricted Common Logic/CLIF. See :cor4.
Do not reach for an external formalism for these three operations — they are native SPARQL 1.1 algebra. Layer RDFS++/OWL2-QL entailment or FuXi N3 rules on top only when subsumption/derivation beyond a single query is needed. See :cor5.
Reuse an existing shared, dereferenceable vocabulary (schema.org, PROV-O, FOAF) wherever it fits, and declare rdfs:subPropertyOf to a small superproperty set for anything bespoke, so new predicates stay queryable under a bounded set without pairwise mapping negotiation. See :cor6.