1. A Knowledge Representation Language for Internet Applications
SHOE
A Knowledge Representation Language for Internet Applications

2. The Problem
HTML was never meant for computer consumption; its function is for displaying data for humans to read.
The "knowledge" on a web page is in a human-readable language (usually English), laid out with tables and graphics and frames in ways that we as humans comprehend visually.

3. Even with state-of-the-art natural language technology, getting a computer to read and understand web documents is very difficult.
This makes it very difficult to create an intelligent agent that can wander the web on its own, reading and comprehending web pages as it goes.

4. The Solution SHOE! Simple HTML Ontology Extensions
SHOE eliminates this problem by making it possible for web pages to include knowledge that intelligent agents can actually read.

5. SHOE eliminates this problem by making it possible for web pages to include knowledge that intelligent agents can actually read.

6. The Internet changes things
The Web is a Knowledge Base.
A massive source of information for agents to make intelligent queries on.
Requires a shift in our view of what a KB is and what a KR language should be designed for.

7. The Web as Knowledge Base
The Web is massive
Most KR systems have semantics too rich to scale well
Many KR languages have NP-hard complexity
KR for Web must make complexity/expressivity tradeoffs

8. Web as KB (cont’d) The Web is an “Open World”
A Web agent is not free to assume it has gathered all available information.
Many KR systems assume a “closed world.”
Unlikely, on the Web, that any KB describing it could ever be complete.

9. The Web is Dynamic
Web changes faster than any bot or agent could keep up with.
A KR system must assume that data can be, and often will be, out of date.
Without a unifying ontological framework web agents will struggle to cross-map comflicting knowledge structures

10. The Web’s KR framework must be flexible yet general to handle the on-line economy of ideas.

11. Web as KB redux
Viewing the Web as a Knowledge Base changes the way we must look at KR and KR languages.
Web systems cannot assume that all of the information is correct and consistent.
Authority on the Internet is distributed.

12. No Central Control Each page’s reliability must be questioned.
No guarantee on the availability of information.
Information from different sources can be in disagreement, leading to inconsistency.
Web Hoaxes
On the Web no one knows you’re a dog.

13. Ontology Modern KR systems designed around concept of categorization.
Allows reasoning about the generality of a concept
allows specification of relationships between these concepts.
Such ontologies allow one to define what is relevant and what is to be ignored

14. Ontologies on the Web
Ontologies on the Web can be used to structure information if we take into account the properties discussed earlier.
Let’s look at some of the problems that may be solved with the use of ontologies

15. Heterogeneity Many file formats and protocols:
images, music, movies, VR files
HTTP, FTP, Telnet, Gopher
Automated indexing is difficult.
All of these resources are potentially useful to someone.
Need method to specify what information is contained in these sources.

16. Lack of Structure
Structure of HTML used primarily for presentation, instead of information retrieval.
Difficult to infer semantic meaning from them despite limited support for semantic information (META tags, etc.)
XML will allow semi-structured documents, but will need some form of Ontology.
No structures for classification or reasoning.

17. Contextual Dependency
Reading documents, people draw on contextual knowledge (domain, language) to interpret statements.
Context required to disambiguate terms and provide framework for understanding
Ontologies provide mechanism by which context can be encoded on web pages or other repositories of web-based information.

18. The SHOE Language

19. Basic Structure Ontologies Instances
define rules guiding what kinds of assertions may be made and what kinds of inferences may be drawn on ground assertions
Instances
entities which make assertions based on those rules

20. Basic Structure
SHOE treats assertions as claims being made by specific instances (instead of facts to gather as generally-recognized truth.)
SHOE syntax is an application extension of HTML
also available in XML syntax
SHOE also designed for more general distributed knowledge and agent issues.

21. SHOE Ontologies
SHOE has flexible facilities for ontologies to be derived from one or more superontologies in a multiple-inheritance scheme, or for later versions to modify earlier versions.
Four basic data types
strings, numbers, dates and boolean values

22. SHOE Ontologies An additional URL type is under consideration.
An ontology can define additional arbitrary types
An ontology can make category definitions which specify the categories under which instances can be classified.

23. SHOE Ontologies Relational Definitions Inferential Declarations
<RELATION> tags specify the format of n-ary relational claims made by instances regarding other instances and data
Inferential Declarations
<DEF-INFERENCE> tags can specify additional inferences agents may freely make on ground information.

24. SHOE Instances Fill two functions: Each instance has unique ID
LKite:
URL as id to give agents ability to determine is instance is really what it claims to be.
SHOE Instances
Fill two functions:
instances are arbitrary objects, like those in an object-oriented database system.
Instances are elements responsible for making claims.
Each instance has unique ID
SHOE proposes, not requires, that the id be based on the URL of the page where instance found.

25. SHOE Instances Instances may specify delegate instances.
Within an instance may be found category claims and relation claims made by that instance:
category claim: instance x should be categorized under category y.
relational claim: instance claims that an n-ary relation exists.

26. Formal Definition We’ll skip the details today, but say:
SHOE’s semantic knowledge consists of a set of claims, made by instances, about relationships between ground atomic elements (numbers, strings, instances, etc.)
Claims are either ground claims explicitly stated in instances or claims SHOE has inferred via the simple rules defined in an ontology.

27. Language Features Compatibility with HTML/XML application of SGML
HTML compatible syntax defined in an SGML DTD derived from the HTML DTD.
XML version:
has familiar format
can be analyzed and processed through DOM
With XSL, SHOE markup can be machine and human-readable.

28. Language Features Prevention of Contradiction
assertions permitted, not retractions
no negation
no single-valued relations (relational sets having only one value or a fixed number of values)
includes claimant as part of a claimed assertion.

29. Language Features Extensibility and Versioning
Shared Ontologies - two ontologies referring to a common concept should both extend an ontology in which that concept defined.
Each version of an ontology is a separate file with a unique version number
All versions of an ontology are accessible
Ontologies can specify backward-compatibility
Depends on compliance of onto-designers

30. Related Work HTML Wrappers Ontobroker
Web Analysis and Visualization Environment (WAVE)
Ontology Markup Language (OML)
Conceptual Knowledge Markup Language (CKML)

31. SHOE vs. RDF RDF drawbacks:
RDF is a semantic network without inheritance; just nodes connected with named links
RDF has no mechanism for defining general inferences
no way to map between different representations of the same concept.
RDF schema can’t rename properties to a local vocabulary (no equivalence)

32. SHOE vs. RDF RDF Drawbacks (cont’d):
no way to track revision of a schema unless schema maintainer uses a consistent naming scheme for the URIs.
Use of XML namespaces leads to difficulty in distinguishing RDF from a different DTD.

33. Language Features Other features:
LKite:
ensuring that two object references are matched when they conceptually refer to the same object is an open problem.
Language Features
Other features:
Separation of ontologies and instances (unlike RDF)
N-ary relations
Uniqueness of identification
the system will only interpret two objects as equivalent when they are truly equivalent

34. Final Notes
Concerns:
versioning compliance depends on cooperation of ontology designers
reliance on “market forces” to weed out bad ontologies
relies on central repository of ontologies
Scalability yet to be proved
Ditto usability (simple tools needed)
Language issues (instance vs. category)