🤖 AI

From Ontology Conformance to Admissible Reconfiguration: A RoSO/SMGI Adequacy Argument for Robotic Service Governance

This paper argues that the Structural Model of General Intelligence (SMGI) provides the necessary formal governance framework to extend the Robotic Service Ontology (RoSO) beyond static conformance, establishing criteria for admissible runtime reconfiguration that ensure service semantics remain preserved during dynamic changes.

Original authors: Aomar Osmani

Published 2026-05-12

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Aomar Osmani

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: The "Recipe" vs. The "Chef"

Imagine you have a very strict, official Recipe Book for making a specific type of cake. This book is called RoSO (Robotic Service Ontology).

What it does: It lists exactly what ingredients you need (flour, sugar), what tools to use (mixer, oven), and the rules for how they must be labeled. It ensures that if you buy "flour" in one store and "flour" in another, they are actually the same thing.
The Problem: The paper argues that having a perfect Recipe Book isn't enough. What happens if you run out of eggs halfway through? Or if you need to bake the cake in a different kitchen with a different oven? Or if you want to swap the mixer for a hand-whisk because the power went out?
The Risk: If you just swap things randomly, you might end up with a pancake instead of a cake, or a cake that is unsafe to eat. The Recipe Book tells you what the ingredients are, but it doesn't tell you if your changes are still a valid version of the original cake.

This paper introduces a new system called SMGI (Structural Model of General Intelligence). Think of SMGI as the Master Chef who stands next to you.

What it does: The Master Chef doesn't write the recipe; they watch you change the recipe. They ask: "If you swap the oven for a microwave, is it still a cake? Is it safe? Did you lose the 'cake-ness'?"
The Goal: The paper argues that you need both the Recipe Book (RoSO) and the Master Chef (SMGI) to make sure your robot can change its plans on the fly without breaking the rules or becoming something it's not supposed to be.

The Core Argument: From "Well-Formed" to "Admissible"

The paper makes a distinction between two types of rules:

Well-Formed (The Grammar Check):
- Analogy: You write a sentence. "The cat sat on the mat." It follows the rules of grammar. It is "well-formed."
- In the paper: A robot service is "well-formed" if it uses the correct words from the RoSO dictionary. If a robot says, "I will deliver medicine," and "medicine" is a valid word in the dictionary, the sentence is correct.
Admissible (The Safety & Identity Check):
- Analogy: Now, imagine you are in a library. You say, "The cat sat on the mat." Grammatically, it's perfect. But in a library, you aren't allowed to have a cat. The sentence is "well-formed" but not "admissible" for that specific place.
- In the paper: Just because a robot's new plan uses the right words doesn't mean it's a safe or valid plan. The paper argues that when a robot changes its plan (reconfigures), it must pass a stricter test called Admissibility. It must prove that the change is safe, stable, and still counts as the same service.

How SMGI Works: The Four Rules of the Master Chef

The paper says SMGI acts like a Master Chef who enforces four specific rules whenever the robot wants to change its plan:

Closure (Staying in the Kitchen):
- Analogy: You can't suddenly decide to bake a cake using a car engine. You must stay within the realm of "kitchen tools."
- The Rule: Any change the robot makes must still be describable using the official vocabulary. You can't invent a new, undefined part.
Stability (Don't Make a Mess):
- Analogy: If you swap your oven for a toaster, the cake might take 10 minutes instead of 40. That's a big change. But if you swap it for a slightly different oven that takes 42 minutes, that's a small, stable change.
- The Rule: The change shouldn't cause the service to crash, degrade too much, or become unpredictable. The "drift" must be small and controlled.
Bounded Capacity (Don't Overthink):
- Analogy: If you try to think of every possible way to bake a cake (using a volcano, a laser, a cloud), you will never finish. You need to limit your options.
- The Rule: The robot shouldn't try to search through infinite possibilities. It must stick to a manageable list of options so it can make a decision quickly.
Evaluative Invariance (Keep the Soul of the Cake):
- Analogy: Whether you are baking for a birthday party or a quick snack, the "cake" must still be a cake. It can't turn into a soup just because the situation changed.
- The Rule: No matter how the robot changes its plan (e.g., switching from "fast delivery" to "safe delivery"), the core promise (e.g., "deliver the medicine safely") must never be broken.

The "Adequacy" Argument

The paper claims that RoSO + SMGI = A Perfect System.

RoSO provides the vocabulary (the words and definitions).
SMGI provides the logic (the rules for changing plans safely).

The authors prove mathematically that if you take a service defined by RoSO and run it through the SMGI rules, you get a system that is dynamically admissible. This means the robot can fix itself, swap parts, or move to a new environment, and you can be mathematically sure it is still doing the same job correctly.

Real-World Examples from the Paper

The paper uses two examples to show why this matters:

1. The Hospital Delivery Robot

Scenario: A robot is delivering medicine. Its battery dies, or the hallway is blocked.
Without SMGI: The robot might just pick a new path or a new robot to help, but it might accidentally drop the medicine or forget to tell the nurse. It's "grammatically correct" but unsafe.
With SMGI: The system checks: "If we switch to Robot B, does it still have the right tools? Is the medicine still safe? Did we remember to tell the nurse?" If the answer is yes, the change is admissible.

2. The Retail Guide Robot

Scenario: A robot is guiding a customer in a store. It gets too noisy to hear the customer's voice.
Without SMGI: The robot might just stop talking and do nothing, or switch to a mode that ignores the customer.
With SMGI: The system checks: "We can't hear, so let's switch to a screen. Does this still count as 'guiding' the customer? Is the customer still safe? Yes." The change is admissible.

What the Paper Does NOT Claim

It is important to know the limits of this paper:

It does not say that SMGI replaces the need for low-level safety checks (like "don't hit a wall").
It does not claim that every robot using RoSO is automatically safe. The robot must actually use the SMGI rules.
It does not promise that this will work perfectly in every single future scenario without testing. It provides the theory and the math to prove it can work.

Summary

Think of RoSO as the Dictionary and SMGI as the Grammar Police.

The Dictionary tells you what words exist.
The Grammar Police tells you if you are using those words correctly to say what you mean, especially when you are in a hurry or changing your sentence structure.

This paper argues that for robots to be truly smart and safe, they need both. They need the dictionary to understand the world, and the Grammar Police to make sure their changes don't turn a helpful service into a broken mess.

Technical Summary: From Ontology Conformance to Admissible Reconfiguration

Problem Statement
The Robotic Service Ontology (RoSO) provides a typed semantic vocabulary for service robotics, addressing interoperability, service composition, and deployment constraints. However, the paper identifies a critical gap: while RoSO ensures semantic well-formedness and logical consistency, it does not provide a formal framework for determining the admissibility of runtime changes. When a service is rebound to a different robot, repaired, recomposed, or redeployed under new constraints, semantic consistency alone cannot guarantee that the resulting configuration remains a valid realization of the same protected service. The central problem is distinguishing between an "admissible transformation" that preserves service identity and an "uncontrolled drift" that alters the service fundamentally. Existing standards (ISO, IEEE, OMG) and ontology-enabled systems (KnowRob, CORA) stabilize vocabularies and task representations but lack a general law for governed, admissible structural change across semantic layers, regimes, and memory conditions.

Methodology
The paper proposes embedding RoSO into the Structural Model of General Intelligence (SMGI) [29] to create a "RoSO–SMGI adequacy argument." The methodology involves:

Formal Embedding: Defining a typed structural interface $\theta_{RoSO}$ where RoSO ontologies induce a meta-model. This maps raw service states to typed semantic states ( $r_{RoSO}$ ), defines an ontology-admissible service hypothesis space ( $H_{RoSO}$ ), and establishes families of evaluators ( $L_{RoSO}$ ) and deployment regimes ( $E_{RoSO}$ ).
Governance Discipline: Applying four SMGI governance obligations to RoSO-conformant transformations:
- Closure: Transformations must remain within the space of typed service transformations authorized by the ontologies.
- Stability: Updates must preserve a service-level stability certificate (e.g., bounded switching cost or safety envelope).
- Bounded Capacity: Reconfiguration must not explode into an unconstrained search; complexity is controlled via priors and budgets.
- Evaluative Invariance: While evaluators may shift with regimes (e.g., emergency vs. routine), a protected service core (identity and hard safety constraints) must remain invariant.
Theoretical Derivation: Proving that RoSO-conformant services induce well-typed SMGI objects and that satisfying the four obligations constitutes a sufficient condition for dynamic admissibility.
Case Analysis: Analyzing public RoSO revision trails (1.0 to 1.1 beta) and two scenarios (hospital delivery and retail guidance) to demonstrate how the framework resolves issues of parameter grounding, concept boundary repair, and regime-sensitive adaptation that ontology conformance alone cannot.

Key Contributions
The paper makes five integrated contributions:

Reformulation of Needs: It translates RoSO's scope, module structure, and public revision history into structural requirements for adaptive robotic service systems.
Explicit Embedding: It defines a formal mapping where RoSO imports induce a typed representation, an admissible service graph space, evaluator families, and structured memory within the SMGI meta-model.
Adequacy Theorems:
- Dynamic Adequacy Theorem: Proves that if a RoSO-governed transformation satisfies closure, stability, capacity control, and evaluative invariance, it is SMGI-admissible.
- Strict Extension: Demonstrates that SMGI decides reconfiguration problems (e.g., choosing between two ontology-consistent components based on memory, cost, or regime) that logical consistency alone cannot settle.
- Identity Preservation: Shows that if the invariant evaluator core includes a service identity functional, admissible transformations preserve service identity.
- Compositional Admissibility: Proves that locally admissible updates to interface-compatible subservices compose into a globally admissible service graph.
Structural Consequences: Derives conditions for service-identity preservation, memory-aware reuse of certified configurations, and the handling of memory-conditioned adaptation.
Operational Blueprint: Provides a clause-wise adequacy map aligning RoSO requirements with SMGI obligations and outlines an algorithmic contract for a RoSO–SMGI orchestrator (semantic lift, candidate generation, certificate screening, memory-aware ranking, and certified deployment).

Results

Theoretical: The paper establishes that RoSO provides the semantic scaffolding, while SMGI provides the dynamic governance required for norm-respecting change. The "RoSO-to-SMGI" bridge transforms service descriptions from merely "well-formed" to "dynamically governable."
Empirical/Analytical: The analysis of RoSO's public revision trail (e.g., repairs to "Avatar/AvatarRobot" boundaries, parameter naming, and cross-ontology synchronization) is presented as evidence that the standardization process itself generates transport and substitution problems that require a framework like SMGI.
Case Studies: In the hospital delivery scenario, the framework distinguishes between ontology-consistent but inadmissible handoffs (e.g., violating traceability) and admissible ones. In the retail guidance scenario, it formalizes regime-switching (speech to visual) based on evaluator invariance and memory of past failures.

Significance and Claims
The paper claims that SMGI is not a replacement for RoSO or other standards, but a necessary formal layer that explains what respecting the standard requires once change becomes unavoidable.

From Annotation to Assurance: The framework upgrades ontology use from static annotation to runtime assurance by coupling typed structure with induced behavioral semantics ( $T_\theta$ ).
Falsifiability: It renders claims of valid reconfiguration falsifiable through explicit structural obligations (closure, stability, capacity, invariance) rather than informal narratives.
Modesty: The authors explicitly state they do not claim that RoSO itself proves dynamic correctness, nor that every RoSO platform automatically satisfies SMGI obligations. The theorems are conditional: they hold if the platform instantiates the specific certificates, monitors, and transition laws defined. The paper does not claim to replace low-level control theory or domain-specific safety assurance but adds a cross-regime structural governance layer.

The core argument is that the "public revision trail" of RoSO reveals that service-ontology standardization inherently generates problems of transport, substitution, and controlled revision. The RoSO–SMGI adequacy argument provides the formal law to manage these problems, ensuring that service semantics survive revision, recomposition, and redeployment while preserving protected commitments.