The NVIDIA Auto-Ontology alternative with symbolic verification
SynaLemma compiles SQL from verified rules. The same question always gives the same query, and a symbolic verifier, not a model, checks the work.
SynaLemma vs NVIDIA Auto-Ontology at a glance
| Criterion | SynaLemma | NVIDIA Auto-Ontology |
|---|---|---|
| What the layer is | A Synalog program: rules compiled to SQL | A glossary of terms, column mappings and SQL snippets in Postgres and pgvector |
| Who writes the SQL | The engine compiles it from the rules | A language model, for every question |
| Same question, same query | Yes, compilation is deterministic | Not guaranteed: SQL is generated per question |
| What checks the work | A symbolic verifier proves every rule well-formed, safe and terminating | Model calls check and repair the SQL; people certify terms |
| Checks on the data | Assertions in first-order logic, with counterexamples | None documented |
| Hierarchies and multi-hop chains | Native recursion, verified to terminate | No rule engine: whatever SQL the model writes |
| Language model | A small open model, on a harness we optimized | Nemotron models, through NVIDIA's hosted API by default |
Why teams look for an Auto-Ontology alternative
-
A model writes SQL for every question
The glossary guides it; the query changes each time (README).
-
Model calls check the SQL
Checks and repairs are done by language models, so both can be wrong in the same way.
-
No rule engine
No recursion, no reasoning over time, no data assertions.
-
A glossary, not a program
Terms, column mappings and SQL snippets stored in Postgres and pgvector.
SynaLemma vs Auto-Ontology: key differences
-
Deterministic SQL
Rules compile to SQL. The same question always gives the same query, and every answer cites its rule.
-
Symbolic verification
A verifier proves every rule well-formed, safe and terminating. No model checks another model.
-
Assertions on the data
First-order statements are checked against your tables, with counterexamples when they fail.
-
A richer language
Rules build on other rules, with recursion, negation and reasoning over time.
-
Sovereign by construction, not by contract
SynaLemma runs on-premises: data, rules and model stay on your infrastructure. The engine compiles the SQL, so a small open model is enough.
Example: an assertion that catches a missing customer
Revenue per customer, with three assertions. Customer 12 is missing from the customers table; the engine names the row.
Order(order_id:, customer_id:, amount:, status:) :- orders(order_id:, customer_id:, amount:, status:);
Customer(customer_id:, country:) :- customers(customer_id:, country:);
@Assert(Revenue,
one_row_per_customer: "∀ c r s, Revenue c r → Revenue c s → r = s",
known_customer: "∀ c r, Revenue c r → ∃ k, Customer c k",
positive: "∀ c, Revenue c > 0");
Revenue(customer_id:, revenue? += amount) distinct :-
Order(customer_id:, amount:, status: "delivered");Auto-Ontology alternative: FAQ
What is the difference between SynaLemma and NVIDIA Auto-Ontology?
Auto-Ontology has a model write SQL for every question. SynaLemma compiles SQL from verified rules, checked by a symbolic verifier.
Is checking SQL with a second model enough?
No. Two probabilistic systems can be wrong in the same way. A symbolic verifier gives properties that always hold.
Does SynaLemma need frontier models?
No. A small open model on your own hardware is enough.
Sources
- NVIDIA Auto-Ontology on GitHub (README)
- Auto-Ontology deployment guide
- Auto-Ontology dependencies (pyproject.toml)
- Synalog on GitHub (Apache-2.0)
- Synalog documentation: assertions
Checked against each product's public documentation on the review date. To report an error: contact@synalinks.com.
Other comparisons
Bring a question your current stack can't answer.
In 30 minutes, we show SynaLemma answering it, with the rule behind the number and the checks it passed.