Trusted Ontology: Bridging the Gap Between Semantic Web Services and Reliable Execution
On the Trusted Ontology model for evaluating the Semantic Web Services
The paper introduces a "Trusted Ontology" (TO) model and a reasoning framework designed to evaluate the trustworthiness of Semantic Web Services. By defining structured semantic descriptions and axiom-based reasoning rules, the authors provide a formal mechanism to represent and verify service reliability beyond simple functional descriptions.
TL;DR
To address the lack of trust-related meta-data in Semantic Web Services, this paper proposes a Trusted Ontology (TO) model. By categorizing trust into objective evidence (ATO) and subjective evaluation (NATS), and applying a set of formal axioms (TOX), the authors enable computers to autonomously reason whether a service is "trustee" or not.
Background: The Trust Deficit in Automation
In the world of Semantic Web Services, we are great at describing what a service does (Functional) and how fast it does it (Non-functional). However, in a distributed cooperative environment, a critical question remains: Can we trust it? Traditional descriptions lack the semantic "hooks" required for a machine to judge the integrity and reliability of a service provider before execution.
The "Trusted Domain" Insight
The authors' core insight is that trust isn't a single attribute but a hierarchy. They break the Trusted Domain into two pillars:
- Atomic Trustworthy Objects (ATO): Objective metrics including Requirement, Capability, Commitment, Performance, and Existence.
- Non-Atomic Trust Subjects (NATS): Subjective reasoning concepts like Reliability, Honesty, and Anticipation.
By separating these, the model can look at "hard facts" (e.g., did the service finish on time?) and translate them into "subjective conclusions" (e.g., is this service honest?).
Methodology: Formalizing Trust through Axioms
The paper defines the Trusted Ontology mathematically to ensure it is machine-readable.
Figure 1: The architecture demonstrates how the Trusted Ontology Constructor and Reasoner work together within the Eclipse framework to evaluate services.
The heart of the system is the TOX (Trusted Ontology Axioms). These are Boolean logic rules that define the conditions for trust. For instance, Reasoning Rule 1 (TOX1) dictates that a service is only "capable and committed" if its attributes for performance and capability are strictly verified as 'Performable' and 'Capable'.
The logic flows from Step 1 (Parsing) to Step 5 (Republishing/Composition), creating a "Trust-Aware" service lifecycle.
Experimental Validation
To prove the efficacy of the framework, the authors compared two hypothetical services.
| Feature | Service A | Service B |
|---|---|---|
| Capability | Capable | Capable |
| Commitment | Committed | InCommitted |
| Performance | Performable | UnPerformable |
| Conclusion | Trusted | UnReliable |
Table 1: The framework identifies that Service B fails the reliability check despite appearing functionally capable.
As shown above, the reasoning engine correctly identifies that while Service B claims to handle the task, its "InCommitted" and "UnPerformable" statuses trigger an "UnReliable" verdict, protecting the requester from a potential service failure.
Critical Insight & Conclusion
This work moves beyond simple QoS (Quality of Service) by treating trust as a semantic reasoning problem. By using OWL-S and SWRL (Semantic Web Rule Language), the authors make trust verification as programmable as the service logic itself.
Takeaway: Future distributed systems won't just match services by input/output types; they will negotiate based on a "Trust Score" derived from standardized ontologies.
Limitations: The paper currently relies on domain-dependent instances. Scaling this to a universal "General Trust" model without ambiguous semantic meanings remains a challenge for future study.