SEMANTIC WEB

Complete Unit-wise Study Notes

Based on: The Semantic Web — A Guide to the Future of XML, Web Services, and Knowledge Management

UNIT I: Introduction
1.1 Introduction to the Semantic Web
The Semantic Web is a machine-processable web of smart data. It represents the next evolution of the
World Wide Web, where data is not just human-readable but also understandable and processable by
machines. Tim Berners-Lee, inventor of the Web, originally proposed the concept as a way to give data
well-defined meaning so that both people and computers can cooperate more effectively.
Definition: The Semantic Web can be defined as a machine-processable web of smart data — data
that is application-independent, composeable, classified, and part of a larger information ecosystem
(ontology).
The path to machine-processable data is to make the data smarter. The key insight is that the shift of
power is moving from applications to data. The Semantic Web represents a systematic approach to
creating 'smart data,' using technologies such as XML, RDF, taxonomies, and ontologies.

The Smart Data Continuum

The Semantic Web's development can be understood through four stages of the smart data continuum:
Stage 1 — Text and Databases (pre-XML): The initial stage where most data is proprietary to an
application. The 'smarts' are in the application and not in the data.
Stage 2 — XML Documents for a Single Domain: Data achieves application independence within a
specific domain, enabling data to move between applications in a single domain (e.g., healthcare XML
standards).
Stage 3 — Taxonomies and Documents with Mixed Vocabularies: Data can be composed from
multiple domains and accurately classified in a hierarchical taxonomy. Simple relationships between
categories allow combining data from different sources.
Stage 4 — Ontologies and Rules: New data can be inferred from existing data by following logical
rules. Data is described with concrete relationships and sophisticated formalisms where logical
calculations can be made (the 'semantic algebra').

Why Do We Need the Semantic Web?

The Semantic Web addresses three fundamental problems facing current information technology:
Information Overload: The rapid growth in the amount of available information has created an
unmanageable volume. There is a growing mountain of research and data that investigators cannot
efficiently navigate. The Semantic Web provides tools to better filter, discover, and connect relevant
information.
Stovepipe Systems: A stovepipe system has all components hardwired to work only together, so
information only flows within the stovepipe and cannot be shared. Breaking down stovepipe systems
requires semantic technologies that allow data from different systems to be understood and combined
without manual intervention.
Poor Content Aggregation: Putting together information from disparate sources is a recurring
problem. The most common technique — screen scraping — is fragile and requires ongoing
maintenance. The Semantic Web enables intelligent, automatic aggregation of information across
diverse sources.

How XML Fits into the Semantic Web

XML is the syntactic foundation layer of the Semantic Web. All other Semantic Web technologies are
layered on top of XML, guaranteeing a base level of interoperability. However, XML alone is not enough
— it only provides syntactic interoperability. For example, if one system labels a field <price> and
another labels it <cost>, there is no way a machine will know they mean the same thing unless
Semantic Web technologies like ontologies are added.
The technologies that XML is built upon are Unicode characters and Uniform Resource Identifiers
(URIs). URIs are used as unique identifiers for concepts in the Semantic Web.

How Web Services Fit into the Semantic Web

Web services are software services identified by a URI that are described, discovered, and accessed
using Web protocols. Web services fit into the Semantic Web in three key ways: (1) they further the
adoption of XML and smart data; (2) Semantic Web technologies will solve the Web service discovery
problem; and (3) advanced Web service applications involving comparison, composition, or
orchestration of Web services require Semantic Web technologies for automation.

What Comes after Web Services?

After Web services complete a platform-neutral processing model for XML, the next step is to make
both the data and processing model smarter. This will evolve along five axes:
Logical Assertions: RDF captures associations between subjects and objects using a triple model
(subject–predicate–object). These assertions add logical statements to or about a resource.
Classification: Resources on intranets and the Internet are classified in hierarchical taxonomies,
enabling discovery and combination of data.
Formal Class Models: Ontologies represent formal class hierarchies with constrained properties and
relations. The W3C's Web Ontology Language (OWL) provides this capability.
Rules: With XML, RDF, and inference rules, the Web is transformed from a collection of documents
into a knowledge base. Inference rules like modus ponens allow machines to derive conclusions from
premises.
Trust: Digital signatures allow trust to be determined semantically. Verifying the source of statements is
a key part of the Semantic Web, creating a 'web of trust.'

Skepticism about the Semantic Web

Skepticism about the Semantic Web follows three paths: (1) Bad precedent — comparing it to failed AI
predictions of the 1960s (Berners-Lee clarifies the Semantic Web is NOT artificial intelligence but a
mechanism for well-defined machine operations on well-defined data); (2) FUD (Fear, Uncertainty,
Doubt) — citing high implementation costs (which are decreasing); (3) Status quo — arguing things
should remain the same, similar to early skeptics of the World Wide Web itself.

1.2 The Business Case for the Semantic Web

The business market for integration programs using Semantic Web technologies is huge. Organizations
that choose to exploit these technologies early will be the first to reap the rewards (James Hendler, Tim
Berners-Lee, and Eric Miller).
Key Maxim: The organization that has the best information, knows where to find it, and can utilize it the
quickest wins.
The Semantic Web can bring structure to information chaos. To get useful knowledge, organizations
must tag information with machine-understandable markup, know what information is authoritative,
prove that information can be trusted, correlate new information with existing information, and have
tools to take advantage of the new knowledge.

Decision Support
Having knowledge — not just data — at your fingertips allows better decisions. The Semantic Web
allows not only users but also software agents to find hidden relationships between data in databases.
The Virtual Knowledge Base (VKB) program in the Department of Defense demonstrates this: it
provides an interoperability framework for horizontally integrating producers and consumers of
information using a standards-based architecture. By exposing all information sources as Web
services, abstracting details into knowledge objects, providing an ontology for mining associations, and
providing a registry for information source discovery, the VKB utilizes key Semantic Web concepts.

Business Development
A corporate knowledge base enables salespeople to quickly access information during customer
meetings, find competitive intelligence, and make associations between past proposals and current
opportunities. The Semantic Web enables e-commerce matchmaking — automatically connecting
businesses with potential partners or customers — and supports Customer Relationship Management
(CRM) by enabling smarter, more personalized service.

Information Sharing and Knowledge Discovery

A corporate Semantic Web with a registry of project descriptions allows employees to discover relevant
information, avoid duplicating efforts, and share lessons learned. Semantic Web-enabled Web services
create a registry for information discovery across organizational boundaries.
Administration and Automation
Semantic Web-enabled Web services have the potential to automate menial and complex tasks. For
example, a travel booking application could use orchestrated Web services with a rule set derived from
personal preferences to automate complex travel arrangements automatically.

Is the Technology Ready?

The building blocks of the Semantic Web are being deployed in small domains and prototypes. The
W3C, IETF, and OASIS have widespread corporate and academic support for interoperability. SOAP-
based Web services provide interoperable interfaces; RDF associates information; XML Topic Maps
(XTM) present taxonomies; ontology languages (OWL, DAML+OIL) are ready for prime time; and
academic programs like TAP at Stanford are bridging gaps between disparate data sources. The
Gartner Group reported that by 2005, lightweight ontologies would be part of 75 percent of application
integration projects.

1.3 XML and Its Impact on the Enterprise

By 2003, more than 95% of the G2000 organizations were expected to deploy XML-based content
management infrastructures (META Group, 2000). XML has passed from the early-adopter phase to
mainstream acceptance and is the primary data exchange mechanism between internal and external
organizations.

Why Is XML a Success?

XML has four primary accomplishments:
(1) Application-Independent Documents and Data: XML is plain text in human-readable form. Unlike
binary formats (like Microsoft Word's proprietary .doc), any program can open and read an XML file.
This is critical for the Semantic Web, because machines of all kinds must be able to consume Web
data.
(2) Standard Syntax for Meta Data: XML provides a simple, standard, text-based method for encoding
the meaning of data values (meta data). Meta data is 'data about data.' XML bridges the gap between
documents and data fields.
(3) Standard Structure for Both Documents and Data: XML uses a hierarchy (tree structure) to
express semantic information. This structure allows content to be decomposed into component parts
recursively. A document is classified as a member of a type by dividing its parts (elements) into a
hierarchical tree.
(4) Not a New Technology: XML is a subset of SGML (Standardized Generalized Markup Language),
invented in 1969 by Charles Goldfarb. The concepts were perfected over 30 years. XML is essentially
'SGML for the Web.'

What Is XML?
XML is not a language; it is a set of syntax rules for creating semantically rich markup languages in a
particular domain. A markup language adds semantic information (marks) to a document's content. The
key principle of XML: markup is separate from content and may contain content.
Three types of XML tags exist: Start tags (<author>), End tags (</author>), and Empty tags (<img />).
An XML element is an XML container consisting of a start tag, content, and an end tag — except for
empty elements, which use a single self-closing tag.
Well-Formed and Valid XML
Well-Formed: A well-formed XML document complies with all W3C syntax rules (naming, nesting,
attribute quoting). An XML processor that encounters a well-formedness violation must stop and report
a fatal error.
Valid: A valid XML document references and satisfies a schema. A schema defines the legal elements,
attributes, and structure of an XML instance document. Validation is critical because XML is intended to
be shared and processed by a large number of diverse applications.

XML Schema
XML Schema is a definition language enabling you to constrain conforming XML documents to a
specific vocabulary and hierarchical structure. It defines element types, attribute types, and composite
types (complex types). XML Schema became a W3C Recommendation on May 5, 2001.
Simple types hold one value (e.g., <xsd:element name='author' type='xsd:string' />). Complex types are
composed of multiple simple types and may contain child elements and attributes. Common XML
Schema primitive data types include: string, boolean, integer, decimal, float, double, date, time, ID, and
IDREF.

XML Namespaces
Namespaces create globally unique names for elements and attributes of a markup language. They
resolve two problems: deconflicting identical names in different markup languages, and allowing
different markup languages to be mixed without ambiguity. A namespace is declared with an xmlns
attribute and identified by a URI. All new markup languages should declare one or more namespaces.

Document Object Model (DOM)

The DOM is a language-neutral data model and API for programmatic access and manipulation of XML
and HTML. It is an in-memory representation of a document — a set of classes that create a tree of
objects in memory representing a manipulable XML or HTML document. DOM Level 1 covers XML 1.0
and HTML 4.0. DOM Level 2 adds namespace support, cascading style sheets, user interface events,
and enhanced tree manipulation. DOM Level 3 adds mixed vocabulary support, XPath expressions,
load/save methods, and abstract schema representation.

Impact of XML on Enterprise IT

XML is pervading all areas of the enterprise. Its impact spans ten areas:
Data Exchange and Interoperability: XML has become the universal syntax for exchanging data
between organizations and has been called the next EDI system.
Ebusiness: B2B transactions have been revolutionized through XML. Web services and service
registries increase this trend.
Enterprise Application Integration (EAI): XML assembles legacy applications, databases, and
systems to support integrated Web views and e-commerce.
Enterprise IT Architectures: XML bridges the Java J2EE and Microsoft .NET platforms and influences
every tier of N-tier network development.
Content Management Systems (CMS): XML technologies separate raw content from presentation
and transform content on the fly via XSLT.
Knowledge Management and e-Learning: XML drives knowledge representation via RDF,
taxonomies, and ontologies, and enables e-learning with standard formats like IMS XML standards.
Portals and Data Integration: XML supports syndication (RSS), Web service integration, and content
transformation portlets.
Customer Relationship Management (CRM): XML ties CRM systems together to enable access
wherever and whenever needed.
Databases and Data Mining: XML has spawned native XML databases and led all major database
vendors to support XML translation and native data types.
Collaboration Technologies and P2P: XML underpins collaborative protocols at the protocol level, for
interoperable tools and capturing shared content.

Why Meta Data Is Not Enough — Semantic Levels

XML meta data is a starting point for semantic representation, but it is not enough to fulfill the goals of
the Semantic Web. The evolution of meta data expands into three levels:
Level 1 (Things): Modeling the properties of isolated data classes — purchase orders, products,
employees. This is represented by XML Schema.
Level 2 (Knowledge about Things): Knowledge modeling — modeling statements about relationships
between Level 1 objects. Represented by RDF and taxonomies.
Level 3 (Worlds): Sophisticated, 'closed-world' models of systems. Represented by ontologies.
Beyond semantic levels, rule languages standardize operations on semantic information (if X then Y),
and standard embeddable inference engines (like the open source Closed World Machine, CWM)
execute rules on ontologies.

UNIT II: Web Services

2.1 Uses of Web Services
Web services are software applications that can be discovered, described, and accessed based on
XML and standard Web protocols over intranets, extranets, and the Internet. They provide
interoperability solutions, making application integration and transacting business easier.
Web services separate business logic from presentation (the Model-View-Controller paradigm): the
view (user interface details) and model (business logic) are in different components, with the controller
facilitating communication. This allows developers to focus purely on business logic when designing
Web services.

Do Web Services Solve Real Problems?

Web services address the core problem of system integration: different database languages,
communication protocols, and data representations make integrating systems extremely difficult. Web
services provide a common language for integration — both within and between enterprises. One of the
major indicators of a successful technology is its ability to solve problems that help organizations do
business. Agreement on a technology that works is more important for business than debating which
technology works best.

Uses of Web Services

Enterprise Application Integration (EAI) is currently the 'killer app' for Web services. Organizations
adopting Web services internally — tying together ERP, CRM, project management, value chain
management, and accounting — will be prepared for the next boom in a B2B marketplace. If a
company develops server software, creating a SOAP interface is now necessary because of
widespread demand for Web service-enabled products.

2.2 Basics of Web Services

The basic layers of Web services (from bottom to top) are: XML (the foundation), HTTP
(communication layer), SOAP (access), WSDL (description), and UDDI/ebXML registries (discovery).
In a typical scenario: (1) A client discovers information about a Web service in a UDDI registry; (2) The
client retrieves the WSDL from the registry to determine the Web service's API; (3) The client
communicates with the Web service via SOAP messages.

2.3 SOAP (Simple Object Access Protocol)

SOAP is the envelope syntax for sending and receiving XML messages with Web services. As defined
by the W3C, SOAP is 'a lightweight protocol for exchange of information in a decentralized, distributed
environment.' It provides a standard language for tying applications and services together. An
application sends a SOAP request to a Web service, and the Web service returns a SOAP response.
SOAP is used with HTTP in practice.
Note: SOAP originally stood for 'Simple Object Access Protocol,' but with SOAP 1.2, the acronym
status was revoked. SOAP has nothing to do with object-oriented programming — a C or Pascal
SOAP-based Web service can be created.

Structure of a SOAP Message

A SOAP message contains: (1) A SOAP Envelope that wraps the message; (2) A description of how
data is encoded (encodingStyle); and (3) A SOAP Body containing the application-specific message.

WSDL (Web Service Definition Language)

WSDL is the way Web services are described. It is an XML grammar defining where the service is
located, what the service does, and how to invoke it. WSDL can be thought of as an XML form of
CORBA's Interface Definition Language (IDL). Developers create WSDL using developer tools that
inspect the Web service's SOAP interface, and clients generate SOAP message handlers by reading
the WSDL.

2.4 UDDI (Universal Description, Discovery, and Integration)

UDDI is a 'phone book for Web services.' Organizations register public information about their Web
services, and applications discover information about these Web services. UDDI was introduced in
2000 by Ariba, Microsoft, and IBM to facilitate the discovery of business processes.
A UDDI business registration consists of three components:
White Pages: Basic company information — description in different languages, contact points with
email and phone numbers, links to external documents.
Yellow Pages: Categorization of businesses by standard taxonomies — what kinds of information the
services provide.
Green Pages: Technical information — business rules for how to work with the service, specifying how
to invoke Web services (the WSDL).
UDDI private registries have significant value for EAI within large organizations. Once applications are
SOAP-enabled and described in WSDL and published in a private UDDI registry, programs can
dynamically connect and interoperate.

ebXML Registries
The ebXML standard was created by OASIS to link traditional data exchanges to business applications
using XML. ebXML provides a common way for businesses to quickly and dynamically perform
business transactions based on common business practices. Unlike UDDI, ebXML is a formal standard.
The ebXML registry stores business processes described in XML, capabilities of trading partners, and
trading partner agreements. ebXML could be described as the start of a domain-specific Semantic
Web.

2.5 Orchestrating Web Services

Orchestration is the process of combining simple Web services to create complex, sequence-driven
tasks. Also called flow composition or Web service choreography, it involves creating business logic to
maintain conversations between multiple Web services. Orchestration can occur between an
application and multiple Web services, or multiple Web services can be chained into a workflow.
Example orchestration scenario: A corporate travel booking application combines a hotel finder Web
service, driving directions finder, airline ticket booker, car rental service, and expense report creator to
automatically arrange a complete business trip. Each Web service is called in sequence; decisions are
made based on business logic; and the client application can 'discover' available services via UDDI,
download the WSDL, and dynamically construct SOAP messages on the fly.
Good orchestration requires good semantic understanding of services and their parameters. Microsoft's
BizTalk Server (using XLANG), IBM's Web Services Flow Language (WSFL), and BEA systems provide
orchestration products.

2.6 Securing Web Services

Security is one of the biggest concerns in Web services deployment. SOAP rides on HTTP, so firewalls
that accept HTTP allow communication — but this is a double-edged sword, as firewalls cannot analyze
SOAP requests for malicious content.

Key Security Concepts

Authentication: Validating identity. Mutual authentication proves the identity of both parties. Message
origin authentication ensures a message was sent by the expected sender.
Authorization: Determining a user's permissions once identity is validated. Access control lists and
directories provide this.
Single Sign-On (SSO): Allows a user to authenticate once and access multiple Web sites and services
without re-authenticating. Enabled by Kerberos, SAML, and other protocols.
Confidentiality: Keeping sensitive information secret, typically through encryption.
Integrity: Ensuring data has not been altered in transit, using hash codes and MAC (Message
Authentication Codes).
Nonrepudiation: Proving legally that a user performed a transaction, achieved through digital
signatures.

Security Technologies
XML Signature (XML-DSIG): A W3C Recommendation for validating message integrity and
nonrepudiation. Any part of an XML document can be digitally signed, even by multiple parties.
XML Encryption: A W3C Candidate Recommendation for confidentiality. Different parts of an XML
document can be encrypted while other parts remain readable.
XKMS (XML Key Management Specification): A W3C Note specifying protocols for registering and
distributing public keys, used with XML Signature and XML Encryption.
SAML (Security Assertion Markup Language): An OASIS standard for passing authentication and
authorization information between parties. Provides 'assertions' of trust and is key to achieving SSO in
Web services.
XACML (Extensible Access Control Markup Language): An OASIS initiative that expresses access
control policy for XML documents and data sources.
WS-Security: Released by Microsoft, IBM, and VeriSign, it combines SOAP with XML Encryption and
XML Signature to provide integrity, confidentiality, and message authentication.
Liberty Alliance Project: A group of corporations establishing an open standard for 'federated network
identity' SSO across multiple networks, domains, and organizations.

2.7 Grid-Enabled and Semantic Web of Web Services

Grid-Enabled Web Services
Grid computing achieves flexible, secure, coordinated resource sharing among dynamic collections of
individuals, institutions, and resources. Like an electrical utility grid, a user connects and obtains
resources without knowing where they come from. A computational grid is a collection of distributed
systems — when thousands or millions of systems work together, enormous computing power is
available.
In a Web services environment, grid computing brings distributed power to the network. When a Web
service shuts down, the grid can route requests to substitute services. The Globus Project
([Link]) adds tools to its Open Grid Services Architecture (OGSA) to integrate with Web
services technologies.

A Semantic Web of Web Services

The Semantic Web and Web services go hand in hand. XML and WSDL are not enough — automated
support is needed in dealing with numerous specialized data formats and ontologies will be the key
enabling concept.
DARPA Agent Markup Language Services (DAML-S) is built on the foundation of RDF, RDF Schema,
and DAML+OIL. It provides an upper ontology for describing properties and capabilities of Web
services in an unambiguous, computer-interpretable markup language — essentially an ontology for
Web services. SWWS (Semantic Web Enabled Web Services) provides a comprehensive Web service
description and discovery framework. As ontologies are built that describe how things work, they
provide a common language for describing Web services and their payloads in much more detail.

UNIT III: Resource Description Framework & XML Technologies

3.1 Resource Description Framework (RDF)
Features of RDF
The Resource Description Framework is an XML-based language to describe resources. While XML
documents attach meta data to parts of a document, RDF creates meta data about the document as a
standalone entity — capturing meta data about the 'externals' of a document (author, creation date,
type). RDF is also excellent for describing 'opaque' resources like images or audio files.
The RDF model is called a 'triple' because it has three parts corresponding to the grammatical parts of
a sentence:
Subject: The resource being described, denoted by a URI. In RDF, resources must be identified by
URIs (Uniform Resource Identifiers) to ensure global uniqueness. For example,
'[Link] uniquely identifies the concept 'company.'
Predicate: A relation between the subject and the object. In RDF, predicates are also denoted by URIs.
The predicate tells us something about the subject.
Object: Either a resource referred to by the predicate or a literal value. In the sentence 'The company
sells batteries,' the object is 'batteries.'
Statement: The combination of subject, predicate, and object as a single unit. A collection of RDF
statements forms a knowledge graph.
This is important because URIs provide globally unique identification for concepts. The syntactic
meaning of words is often ambiguous (e.g., 'bark' has multiple meanings), but a unique URI like
'[Link]/ontology/plant/#bark' always refers to a single definition.

Capturing Knowledge with RDF

RDF knowledge can be expressed in several ways: as natural language sentences, in N3 (Notation 3)
triple notation, in RDF/XML serialization format, and as a graph. The Jena Semantic Web toolkit from
Hewlett-Packard can automatically convert N3 to RDF/XML.
N3 Notation Example:
<#Buddy> <#owns> <#business>.
<#business> <#has-website> <[Link]
<#Buddy> <#father-of> <#Lynne>.

Other RDF Features

RDF provides two additional facilities to increase the composeability of statements:
Container Model: Allows groups of resources or values. Three container types: Bag (rdf:bag —
unordered collection, duplicates allowed), Sequence (rdf:seq — ordered collection, duplicates allowed),
and Alternate (rdf:alt — choice of multiple values). Containers are explicit in RDF, unlike the implicit
containers in XML.
Reification: Allows making statements about statements. A statement is modeled as a resource with
explicitly specified subject, predicate, object, and type. This is useful when trustworthiness of the
source must be tracked (e.g., human intelligence collection). Reification is not applicable to all data
modeling tasks.

Why Is RDF Not in the Mainstream?

Despite being a W3C Recommendation since 1999, RDF has not achieved mainstream adoption for
several reasons: (1) RDF does not yet play well with XML documents due to an open grammar; (2)
Parts of RDF are complex — mixing metaphors from linguistic, object-oriented, and relational
communities; (3) The striped RDF/XML serialization syntax is difficult to author by hand; (4) Early RDF
examples (Dublin Core, RSS) were weak and did not highlight RDF's unique characteristics.

RDF Schema (RDFS)

RDF Schema is layered on top of RDF to provide support for class modeling. It provides simple RDF
subjects (classes) and predicates (properties) for defining new RDF vocabularies. Using RDF Schema,
an ontology modeler can define classes, their properties, subclass hierarchies, and domain/range
constraints on properties. This moves RDF toward the Semantic Web's goal of enabling automated
inference.

3.2 XML Technologies

XPath
XPath (XML Path Language) provides an expression language for specifically addressing parts of an
XML document. It is important because it provides key semantics, syntax, and functionality for a variety
of standards, including XSLT, XPointer, and XQuery. XPath uses a path notation (similar to URL paths)
for navigating through the hierarchical structure of an XML document. XPath also provides basic
facilities for manipulation of strings, numbers, and booleans.
XPath expressions allow: selecting all elements with a specific attribute (//TaskItem[@id]), selecting all
ID attributes (//[@id]), and selecting specific child elements (/Task/Meeting). XPath 2.0 is an extension
that is intended to be embedded in host languages such as XQuery and XSLT. XQuery 1.0 is, in fact,
an extension of XPath 2.0.

The Style Sheet Family: XSL, XSLT, and XSLFO

Style sheets specify how an XML document can be transformed into new documents and presented in
different media formats. XSL (Extensible Stylesheet Language) consists of two parts: a transformation
mechanism (XSLT) and a formatting vocabulary (XSLFO).
XSLT (XSL Transformations): A markup language using template rules to specify how a style sheet
processor transforms a document. A style sheet engine takes an XML document, loads it into a DOM
source tree, and transforms it using XPath expressions in the style sheet, producing a result tree in any
format. XSLT is widely used for transforming XML to HTML, WML, PDF, SOAP messages, and other
formats.
XSLFO (XSL Formatting Objects): A pagination markup language and the formatting vocabulary of
XSL. It is used to produce PDF or RTF output through a post-processor.
Style sheets add presentation to XML data. By separating content from presentation (MVC paradigm),
data can be reused across multiple platforms — a wireless client, Web client, Java application, or .NET
application can each have different style sheets. Style sheets also support interoperability by
transforming one enterprise XML format to another.

XQuery
XQuery is a language designed for processing XML data, intended to make querying XML-based data
sources as easy as querying databases. It is an extension of XPath and is the first XML query language
to receive industry-wide attention. XQuery provides a human-readable query syntax (similar to Perl)
with programming language logic. An XML version, XQueryX, is also a W3C Working Draft.
XQuery expressions can load XML documents, assign path variables, and sort results. For example:
'let $project := document([Link])/project; let $day := $project/schedule/workday; return $day
sortby (description)' — this returns workdays sorted alphabetically by description.

XLink
XLink (XML Linking Language) from the W3C allows elements to be inserted into XML documents to
create and describe links between resources, associate meta data, and link external documents. A link
is 'an explicit relationship between resources or portions of resources.' XLink goes far beyond HTML's
hyperlinks by offering advanced behavior features. XLink supports: Simple links (similar to HTML <a>
tags), and Extended links (which connect relationships between multiple elements and remote
resources using arcs).

XPointer
XPointer (XML Pointer Language) is used as a fragment identifier for any URI reference that locates an
XML-based resource. It can 'point' to fragments of remote documents using XPath expressions and can
address ranges of data and points of data in documents. XPointer extends XPath with functions for
specifying ranges and points — e.g., xpointer(string-range(//*,'Truck')) points to every occurrence of
'Truck' in a document. XLink and XInclude can use XPointer expressions.

XInclude
XML Inclusions (XInclude) is a W3C Candidate Recommendation used for including documents,
elements, or other information in an XML document. It enables building large XML documents from
multiple fragmentary XML, well-formed XML, or non-XML text documents. A 'fallback' feature provides
alternative content if the external document is unavailable. XInclude supports both XML inclusion
(default) and text inclusion (parse='text' attribute).

XML Base
XML Base is a W3C Recommendation that allows authors to explicitly specify a document's base URI
for resolving relative URIs. It is very similar to HTML's base element. Using the xml:base attribute, all
href references in a document become relative to the specified base URL, simplifying document
management.

XHTML
XHTML (Extensible Hypertext Markup Language) is the reformulation of HTML into XML. It was created
to provide more structure for machine processing. HTML's loose structure is a stumbling block for the
Semantic Web — it is not well-formed and only a presentation language. XHTML is XML, providing
structure and extensibility through namespaces.
XHTML 1.0 (W3C Recommendation, January 2000) reformulates HTML 4.0 into XML. Key differences:
documents must be declared as XML (<?xml version='1.0'?>); documents must be both valid and well-
formed with a DOCTYPE; the root element must have the XHTML namespace; elements and attributes
must be lowercase; all tags must have end tags. XHTML 2.0 (Working Draft) is an evolution that
includes the XForms module and is not backward-compatible.

XForms
XForms is a W3C Candidate Recommendation dubbed 'the next generation of forms for the Web.' It
separates presentation from content, allows reuse, reduces server round-trips, offers device
independence, and reduces scripting. XForms separates the model, instance data, and user interface
into three parts.
XForms architecture: The XForms Model (stored in the <head> section) describes the purpose of the
form and contains submission information and data constraints. The XForms User Interface (stored in
the <body> section) describes how the form is presented. During user interaction, instance data is kept
in memory as XML using XML Events. When the user is done, the serialized XML instance data is sent
to the server. XForms also supports model item constraints using XML Schema types and XForms-
specific constraints for validation.

SVG (Scalable Vector Graphics)

SVG is a language for describing two-dimensional graphics in XML. A W3C Recommendation since
September 2001, it allows vector graphics, images, and text to be grouped, styled, and transformed.
Features include alpha masks, filter effects, nested transformations, and animations. SVG takes
advantage of XLink for hypertext references. Because SVG is XML, data content can be transformed
into SVG to create graphically intense programs. Web services can generate rich graphical SVG
content on the server side. SVG has significant product adoption: Adobe SVG Viewer, Apache Batik,
SVG-enabled Mozilla, W3C's Amaya, and Jasc's WebDraw all support it.

UNIT IV: Taxonomies and Ontologies

4.1 Overview of Taxonomies
A taxonomy is a way of classifying or categorizing a set of things — specifically, a classification in the
form of a hierarchy. A hierarchy is a tree-like structure with a root and branches; each branching point
is a node. The information technology definition: the classification of information entities in the form of a
hierarchy, according to the presumed relationships of the real-world entities they represent.
As you go up a taxonomy toward the root, entities become more general. As you go down toward the
leaves, entities become more specialized. A taxonomy based on the subclass of relation is a
generalization/specialization taxonomy. A taxonomy based on the part of relation is an aggregation
taxonomy (e.g., bills of materials, parts trees).

Why Use Taxonomies?

The most common use of taxonomies is browsing or navigating for information when you have only a
general idea of what you are looking for. Examples include: the Dewey Decimal System (10 root
categories spanning all book topics), the Linnaeus biological classification system, the Universal
Standard Products and Services Classification (UNSPSC) for e-commerce, UDDI's tModel taxonomies,
and Yahoo/Google directory categorizations.
Taxonomies help customers find products and services, improve search efficiency, and classify
information entities semantically. Forrester Research found that addressing content categorization
using taxonomies significantly improves search efficiency.
A key limitation of taxonomies: because they are trees, there is only one parent node for each child
node, which can result in redundant information. A more semantically richer model — an ontology —
uses a taxonomy as its backbone and adds additional relations, properties, and rules.

4.2 Defining the Ontology Spectrum

The Ontology Spectrum (Figure 7.5 in the textbook) is a framework for comparing the semantic
richness of classification and knowledge-based models. Going from lower-left to upper-right in the
spectrum, semantic richness increases from 'weak semantics' to 'strong semantics.'

Levels of the Ontology Spectrum

Taxonomy (Weak Semantics): The lower-left endpoint. The semantics of the relationship between
parent and child is relatively underspecified — it could be subclass of, part of, or simply undefined.
Represented by Relational Models. Relationship: 'is subclassification of.'
Thesaurus: A taxonomy plus term semantic relations. The ANSI/NISO standard defines it as 'a
controlled vocabulary arranged in a known order and structured so that equivalence, homographic,
hierarchical, and associative relationships among terms are displayed clearly.' Relationships:
equivalent, homographic, broader/narrower than, associated. Represented by the Entity-Relational
(ER) model. Relationship: 'has narrower meaning than.'
Conceptual Model: A model of a subject area representing primary entities, relationships among
entities, attributes and attribute values, and sometimes rules. Languages: UML (Unified Modeling
Language), Extended Entity-Relational (EER). Relationship: 'is subclass of.'
Logical Theory (Strong Semantics): The upper-right endpoint. Ontologies as logical theories are built
on axioms and inference rules that prove theorems about the domain. Languages: Description Logic,
DAML+OIL, OWL, First-Order Logic, Modal Logic. Relationship: 'is disjoint subclass of with transitivity
property.'

Key Concepts within the Spectrum

Thesaurus Details: A thesaurus ensures concepts are described consistently, experienced users can
refine searches, and users need not be familiar with technical terminology. WordNet (from Princeton) is
a well-known thesaurus structured by psycholinguistic theories, where words are organized by synsets
(synonym sets) and hypernymic (broader than) and hyponymic (narrower than) relations.
Ontology Definition (preliminary): An ontology defines the common words and concepts (meanings)
used to describe and represent an area of knowledge. Ontologies include classes, instances,
relationships, properties, functions, constraints, and rules. They make knowledge reusable across
people, databases, and applications that need to share domain information.

4.3 Topic Maps

Topic Maps (TM) is a technology for semantically characterizing and categorizing documents and
sections of documents on the Web with respect to their content. A Topic Map is a set of linked topics
that index a document collection. Multiple topic maps can index the same document collection in
different ways (like multiple indexes in a book). Topic maps act as information overlays enabling
content-based navigation irrespective of the document's form.
Topic Maps Standards
The ISO 13250 standard defines Topic Maps in two interchange syntaxes: a newer XML-based syntax
(XTM — XML Topic Maps) and an older SGML DTD-based syntax. The Standard Application Model
(SAM) defines the formal data model of Topic Maps. The Topic Map Query Language (TMQL) will be
an SQL-like language for querying topic maps. The Topic Map Constraint Language (TMCL) will give a
schema-like capability for defining constraints.

Topic Maps Concepts

Topic: Anything can be a topic — any distinct subject of interest for which assertions can be made. A
topic is a representation (proxy) for the subject. Topics can be identified by name (base name) and
have variant names (display name, sort name). Each topic is an instance of a topic type.
Occurrence: A resource specifying some information about a topic. Occurrences can be addressable
(using a URI via resourceRef) or have an inline data value (using resourceData). Occurrences can
have different types, specified by topicRef, and they act as attributes of a topic.
Association: The relationship between one or more topics. Associations are typed (e.g., located-in)
and members assume different roles in the association (e.g., Front Royal is in the 'city' role; Virginia is
in the 'state' role). Associations are similar to database relations or ontology predicates.
Subject Descriptor / Subject Indicator: A way of indicating subjects. If two topics use the same
resource, their subjects are identical. The XTM standard has default mandatory published subjects
(e.g., topic, association, occurrence, class-instance relationship, superclass-subclass relationship).
Scope: Similar to namespace in markup languages. Scope specifies the applicability or context of the
topic, its occurrences, and its associations. Subjects, topic names, occurrences, and associations all
have scope.

Topic Maps vs. RDF

Topic Maps and RDF share many similarities but have different origins and emphases. Both provide
mechanisms for mapping associations between resources. RDF uses an explicit triple model (subject-
predicate-object) with URIs, while Topic Maps uses topics, associations, and occurrences. RDF
focuses on describing resources with explicit relationships; Topic Maps focuses on providing an index
into a document collection with scope and multiple topic maps for the same collection.

4.4 Overview of Ontologies

Ontology Definitions
Definition 1: An ontology is a specification of a conceptualization — a description of concepts and
relationships that can exist for an agent or a community of agents (Gruber).
Definition 2: An ontology is a formal, explicit specification of a shared conceptualization.
In IT terms: An ontology models the vocabulary and meaning of domains of interest — the objects
(things) in domains, the relationships among those things, the properties, functions, and processes
involving those things, and constraints on and rules about those things.
Ontology tools include: Protégé (Stanford Medical Informatics), Ontolingua/Chimaera (Stanford
Knowledge Systems Laboratory), OntoEdit, OilEd, and Cyc/OpenCyc. Cyc is a repository of machine-
interpretable commonsense knowledge represented as first-order predicate logic-based ontologies.
4.5 Syntax, Structure, Semantics, and Pragmatics
Syntax: Concerned with form, format, and structure. Every language (Cobol, Java, XML, RDF, OWL,
English) has a syntax: an alphabet, rules for combining vocabulary into legitimate statements, and a
semantics. Syntax determines order and format. If a program is syntactically correct, the compiler will
not generate error messages. In XML, a document that follows XML rules is either syntactically correct
or not.
Structure: Syntax is also structure. Models require structure to organize and contain elements. A
database schema describes and prescribes structure; a DBMS enforces it. In conceptual models
(UML), structure appears in inheritance hierarchies, part-of relations, and arbitrary relations. Structure
is represented by directed acyclic graphs (DAGs) — most ontology and UML models use DAGs
because they avoid the implementation cost of cycles.
Semantics: Semantic interpretation is the mapping between structured data and a model of objects in
a domain with respect to intended meaning. The model typically lies in the human mind. To realize the
Semantic Web, this semantic interpretation must be at least partially automated. Ontologies provide this
capability — expressing formal vocabulary with an intended semantics so machines can infer
conclusions comparable to human reasoning. Ontologists want to shift semantic interpretive burden to
machines.
Pragmatics: Sits above semantics and concerns the intent of the semantics and actual usage. Agent
Communication Languages (like FIPA's ACL based on speech act theory) include pragmatic levels.
Agents can use a BDI (Belief, Desire, Intent) framework. When the Semantic Web evolves to deal with
the 'web of proof and trust,' pragmatic issues will become much more important (the 'Pragmatic Web').

4.6 Expressing Ontologies Logically

Ontologies are usually expressed in a logic-based knowledge representation language to make fine,
accurate, consistent, sound, and meaningful distinctions. Ontological engineering characterizes an
ontology in terms of an axiomatic system: a set of axioms (class-level assertions) and inference rules
that together characterize theorems. Axioms, inference rules, and theorems constitute a logical theory.

Knowledge Representation
Semantic Networks: The first knowledge representation systems, developed in the 1960s–70s.
Represented as directed acyclic graphs with nodes (concepts) and links (relationships). The problem:
they were ad hoc, with semantics dependent only on the researchers who developed them.
Frame-Based Knowledge Representation: A language representing knowledge based on frames
(data structures for concepts and relations). A class has superclasses, properties (slots), default values,
and facets (meta data). KL-ONE was the first frame-based language. Frame-based representations are
equivalent to logic-based representations.
Description Logics: Evolved from frame-based systems. A description logic is a language for
representing knowledge with a syntax and a semantics — a syntax for constructing descriptions and a
semantics that defines the meaning of each description. Also called terminological logics or
classification logics. They are based on a declarative formalism and a subsumption framework
(organizing classes in a generalization/specialization hierarchy via the subclass of relation). Description
logics try to balance expressivity with tractable reasoning.
Logic and Logics
Propositional Logic: The simplest kind of logic. Enables formally expressing simple semantic truths
(propositions) that are either true or false. The basic unit is the proposition. Key limitation: cannot speak
about individuals, as granularity is not fine enough.
First-Order Predicate Logic: Makes finer semantic distinctions. Predicates can refer to the same
individual (e.g., management_employee(john) and managing_organization(john)). Both properties and
individuals can be represented. Quantifiers: the universal quantifier (All/∀) and the existential quantifier
(Some/∃). High-end ontologies (DAML+OIL, OWL) use a logic close to first-order predicate logic.
Description logics are defined as function-free first-order logic with at most three variables, and are
designed to be sound, complete, decidable, and tractable.

Term vs. Concept: Thesaurus vs. Ontology

The triangle of signification has three angles: Terms (labels/symbols), Concepts (mental constructs
representing meaning), and Real-World Referents (the actual things in the world). A thesaurus
generally works with the left side of the triangle (terms and concepts), working at the syntactic/label
level. An ontology works more with the right side (concepts and referents), working at the
semantic/meaning level. A thesaurus is developed for navigation, search, and retrieval; an ontology
explicitly limits the possible formal models of interpretation to those intended.

Emerging Semantic Web Ontology Languages

RDF/S (RDF + RDF Schema): RDF expresses instance-level semantic relations as triples. RDFS
expresses class-level relations describing acceptable instance-level relations. Both use XML syntax.
DAML+OIL: DARPA Agent Markup Language + Ontology Inference Layer. A combination of US
DARPA-sponsored DAML and European EU-sponsored OIL. The most semantically expressive Web
ontology language before OWL. DAML+OIL provides classes, subclasses, properties, property
restrictions, class constructs (disjointWith, intersectionOf, unionOf, complementOf), and quantifier
forms.
OWL (Web Ontology Language): Developed by the W3C Web Ontology Working Group as the
successor to DAML+OIL. The most expressive ontology language for the Semantic Web. OWL has
three levels:
OWL Lite: A simpler language, more expressive than RDF/S. Supports class hierarchy, properties
(owl:objectProperty, owl:datatypeProperty), simple cardinality constraints (0 or 1), and quantifier
expressions (allValuesFrom, someValuesFrom).
OWL DL (Description Logic): Extends OWL Lite with more expressive cardinality constraints,
hasValue construct, and boolean class expressions (unionOf, intersectionOf, complementOf, oneOf,
disjointWith).
OWL Full: The complete OWL. Extends OWL DL by allowing classes to be treated simultaneously as
both collections and individuals. A valid conclusion in OWL Lite is valid in OWL DL and OWL Full, but
not vice versa.
The Semantic Web stack architecture (from bottom to top): XML (base syntax), XML Schema
(structural encodings), RDF (instances), RDF Schema (simple ontologies), DAML+OIL or OWL
(expressive ontologies), Reasoning/Proof Methods, Trust: Proof + Security + Identity, 'Intelligent'
Domain Applications.
Ontology Levels
Ontologies exist at three general levels: Upper Ontology (common generic knowledge spanning all
ontologies — distinctions between tangible/intangible objects, semantics of parthood, time/space),
Middle Ontology (knowledge spanning domains but not as general as the upper level — processes,
locations, organizations, products/services), and Lower Domain Ontology (knowledge about specific
subject areas — metal parts, art supplies, specific machine types).

4.7 Knowledge Representation

Knowledge representation (KR) is a branch of artificial intelligence focusing on the design and
implementation of languages and systems that represent knowledge about the world. A knowledge
representation is a stand-in for real objects in the world, and the events and relationships those things
participate in. KR is a means for both expressing and using semantic information — knowledge about
the world — with the qualification that the use of that knowledge should be for intelligent reasoning and
be computationally efficient.
The language used for knowledge representation determines the kind of reasoning that can take place.
A KR language with limited expressivity cannot be used for automatic reasoning methods that require
more complex expressiveness.
KR languages include: KIF (Knowledge Interchange Format — based on first-order predicate logic with
LISP-like syntax), Common Logic (ISO-KIF standard), Ontolingua (KIF-based, developed at Stanford),
OKBC (Open Knowledge Base Connectivity — an API for knowledge access), Protégé (OKBC-based
ontology management tool from Stanford), and Cyc/OpenCyc (commonsense knowledge base using
mostly first-order logic).

UNIT V: Semantic Web Applications & Semantic Search

Technology
5.1 Semantic Web Applications
Semantic Web Services
Semantic Web Services combine Semantic Web technologies with Web services to enable automated
discovery, composition, and orchestration of services. Current Web services described using WSDL are
syntactically specified — they describe how to invoke a service but not what the service does
semantically. Semantic Web services add ontological descriptions so that software agents can
automatically understand, select, and compose Web services.
DAML-S (DARPA Agent Markup Language Services) provides an upper ontology for describing
properties and capabilities of Web services in an unambiguous, computer-interpretable markup
language. Built on RDF, RDF Schema, and DAML+OIL, DAML-S provides three ontologies: a Service
Profile (what the service does — advertised capabilities for discovery), a Process Model (how the
service works — the internal structure of the service), and a Service Grounding (how to access the
service — mapping to WSDL, SOAP protocol details).
SWWS (Semantic Web Enabled Web Services, developed August 2002) provides a comprehensive
Web service description framework and discovery framework, and scalable Web service mediation.
Together, DAML-S and SWWS increase automated usability of Web services.
The integration of Semantic Web technologies with Web services enables: automated service discovery
(agents find services matching their semantic needs), automatic composition (combining services to
accomplish complex tasks), and intelligent orchestration (using ontologies to resolve ambiguous
parameters like 'near' or 'cheap').

e-Learning
Electronic learning (e-learning) is part of knowledge acquisition for employees through online training.
XML and the Semantic Web are fostering e-learning through standard formats. The Instructional
Management System (IMS) XML standards at [Link] provide a foundation for e-learning
content.
Semantic Web technologies enhance e-learning in multiple ways: XML separates learning content from
its presentation, enabling delivery to multiple devices and platforms. Ontologies enable personalized
learning paths by understanding learner profiles and course content relationships. RDF enables
machines to understand and categorize learning objects semantically. Taxonomies classify course
content for better discovery and recommendation. Semantic Web-enabled learning management
systems can automatically compose curricula based on learner needs and available content.
Knowledge management and e-learning are closely related in the enterprise: XML drives knowledge
management via RDF (knowledge representation), taxonomies (Chapter 7), and ontologies (Chapter 8).
Current knowledge management systems include intranet-based content management systems and
Web logs.

Semantic Bioinformatics
Bioinformatics involves applying computational and informational techniques to biological data. The
Semantic Web is particularly relevant to bioinformatics because: biological data is diverse, distributed,
and heterogeneous; multiple databases use different vocabularies for the same biological entities; and
manual integration is impossible at the scale needed.
Semantic Web technologies address these challenges through: ontologies for biological domain
knowledge (e.g., Gene Ontology — GO — which classifies gene products by biological process,
molecular function, and cellular component), RDF for linking biological datasets, and reasoning engines
for inferring new biological relationships. The Semantic Web enables integration of genomic, proteomic,
and clinical data across distributed databases, enabling discovery of hidden biological relationships that
manual curation cannot achieve. DAML+OIL and OWL provide the expressive power needed to
represent complex biological knowledge.

Enterprise Application Integration (EAI)

Enterprise Application Integration is the assembling of legacy applications, databases, and systems to
work together to support integrated Web views, e-commerce, and Enterprise Resource Planning. EAI is
currently the 'killer app' for Web services. The Semantic Web enhances EAI in significant ways.
Traditional EAI used proprietary middleware that was costly and brittle. Web services-based EAI using
SOAP provides platform-neutral, language-neutral integration. Adding Semantic Web technologies
creates 'Smart EAI': ontologies describe the meaning of data exchanged between applications
(reducing manual mapping work); RDF captures semantic associations between data elements from
different systems; and UDDI/ebXML registries with taxonomic classification enable dynamic discovery
of integration endpoints.
The VKB (Virtual Knowledge Base) program in the Department of Defense demonstrates Semantic
Web-based EAI: by exposing all information sources as Web services, abstracting details into
knowledge objects, providing an ontology for mining associations between data elements, and
providing a registry for discovery of information sources. The Semantic Web thus enables not just
integration of data but integration of meaning — moving from data exchange to knowledge exchange.

Knowledge Base
A knowledge base is a repository of machine-interpretable knowledge about a domain. Unlike a simple
database (which stores data), a knowledge base stores both data and the relationships, rules, and
constraints needed to reason about that data. Semantic Web technologies provide the foundation for
building corporate and enterprise knowledge bases.
A Semantic Web-based corporate knowledge base consists of: XML-marked-up documents (providing
syntax and structure), RDF statements linking documents and data to ontological concepts (providing
semantic associations), taxonomies for classifying knowledge objects (enabling navigation and search),
ontologies providing formal domain models (enabling automated reasoning), a Web service registry
(enabling discovery of knowledge sources), and digital signatures ensuring trust and nonrepudiation.
Capabilities enabled by a corporate Semantic Web knowledge base include: taxonomic searches ('find
all Web services classified as related to Coal Mining'), Web service-based data searches via SOAP,
search by association (mining hidden relationships using ontological connections), pattern-based
searches (discovering trends that traditional data mining misses), agent-based monitoring searches,
rule-based orchestration queries, and automated inference support.

5.2 Semantic Search Technology

Search Engines
Traditional search engines use keyword-based or boolean keyword queries to retrieve documents. Key
limitations: keyword searches return results based on word frequency without understanding meaning;
different terms can refer to the same concept (synonymy) and the same term can refer to different
concepts (polysemy); results contain many irrelevant documents (poor precision) and miss relevant
documents (poor recall).
Common search engine techniques: Keyword indexing (creating inverted indexes mapping words to
documents), Relevance ranking (ordering results by frequency, link analysis — e.g., Google's
PageRank), Stemming (reducing words to their root forms), Stop word removal (ignoring common
words like 'the', 'and').

Semantic Search
Semantic search moves beyond keyword matching to understand the meaning (semantics) of queries
and documents. Instead of matching words, semantic search matches concepts — using ontologies
and knowledge bases to understand what the user really wants.
Semantic search capabilities enabled by the Semantic Web: Search by concept (not just keyword) —
queries can be answered using ontological relationships; Inference-based retrieval — if a query asks
about 'mammals,' the system can infer that 'cats,' 'dogs,' and 'whales' are relevant even if those words
are not in the query; Association mining — finding documents related by semantic relationships (e.g.,
all researchers connected to a topic through co-authorship, citations, or shared ontological concepts);
Query expansion using synonyms and related terms from a thesaurus or ontology; Cross-language
retrieval — using ontological concept mappings to search across documents in different languages.
Semantic Search Technology
The technical infrastructure for semantic search includes: Ontology-based indexing — documents are
indexed not just by keywords but by the ontological concepts they mention; Semantic annotation —
marking up documents with RDF statements that explicitly state what concepts a document discusses;
Triple stores — databases optimized for storing and querying RDF triples; SPARQL (the SPARQL
Protocol and RDF Query Language) — an SQL-like query language for RDF data; and Inference
engines — reasoning systems that can infer new facts from existing ontological knowledge to answer
queries.
A semantic search process: (1) User submits a query; (2) The system expands the query using
ontological relationships (synonyms, hypernyms, related concepts); (3) The expanded query is matched
against semantically annotated documents or an RDF knowledge base; (4) Results are ranked
considering semantic relevance, not just keyword frequency; (5) Related concepts and associations are
presented alongside results.

Web Search Agents

Web search agents are autonomous software programs that navigate the Web and gather information
on behalf of users. In the Semantic Web context, agents can understand machine-readable content and
make sophisticated queries impossible with traditional search.
Characteristics of Semantic Web agents: They can read and process machine-readable ontologies and
RDF data; They can compose Web services to gather and combine information from multiple sources;
They use inference rules to derive new information from existing facts; They can evaluate the
trustworthiness of information sources using digital signatures; They can work autonomously over
extended periods, monitoring for new information.
The five directions (logical assertions, classification, formal class models, rules, and trust) discussed in
Chapter 1 enable agents to move corporate intranets and the Web into a semantically rich knowledge
base where smart software agents and Web services can process information and achieve complex
tasks.

Semantic Methods
Semantic methods for information retrieval and processing include: Concept-based retrieval (matching
by ontological concept, not keyword); Semantic similarity measures (computing similarity between
concepts based on their position in an ontology hierarchy); Semantic annotation (automatically or
manually annotating documents with ontological concepts using tools like SMORE — Semantic
Markup, Ontology, and RDF Editor); Ontology-based information extraction (automatically extracting
structured information from unstructured text using ontological background knowledge); and Knowledge
graph construction (building a graph of entities and their relationships from multiple data sources).

Latent Semantic Index (LSI) Search

Latent Semantic Indexing (LSI), also called Latent Semantic Analysis (LSA), is a statistical technique
that identifies patterns in the relationships between terms and concepts in a large corpus of text. LSI is
a bridge between keyword-based and fully semantic search.
How LSI works: (1) A term-document matrix is constructed where each row is a term and each column
is a document, with cell values reflecting term frequency; (2) Singular Value Decomposition (SVD) is
applied to reduce the dimensionality of the matrix; (3) The reduced representation captures the
underlying 'latent semantic structure' — the conceptual relationships among terms that co-occur in
similar contexts; (4) Queries and documents are compared in this reduced semantic space using
cosine similarity rather than exact keyword matching.
Benefits of LSI: It addresses synonymy (different words with similar meaning appear near each other in
semantic space) and polysemy (the same word in different contexts appears in different parts of
semantic space). It can retrieve conceptually relevant documents even if they share no keywords with
the query. Key limitation: LSI is purely statistical — it has no true understanding of meaning and cannot
use ontological relationships or inference rules.

TAP
TAP is a Semantic Web project from Stanford University (Stanford Knowledge Systems Lab, led by
R.V. Guha and Rob McCool). TAP bridges the gap between disparate Web service-based data sources
and 'creates a coherent Semantic Web from disparate chunks.' TAP enables semantic search
capabilities using ontology-based knowledge bases.
TAP provides: A knowledge base of structured information about common topics (people, places,
things, organizations); An API for querying and accessing this knowledge base; Integration of
knowledge from multiple Web sources; Structured navigation between related concepts; and Semantic
search capabilities. The TAPache subproject is a module for the Apache HTTP server that enables
publishing RDF data via a standard Web service called getData(), allowing easy integration of
distributed RDF data.
Adobe, for example, used TAP-related concepts to reorganize its software meta data around RDF,
enabling PDF file information to be understood by other software even without knowing what a PDF is.
IBM's Institute of Search and Text Analysis in California made significant investments in TAP-like
semantic research.

Swoogle
Swoogle is a search engine for Semantic Web documents — specifically, for OWL ontologies, RDF
documents, and other Semantic Web artifacts on the Web. Developed at the University of Maryland,
Baltimore County, Swoogle addresses the problem of finding existing ontologies and reusing them
rather than building ontologies from scratch.
Swoogle's features: It crawls the Web to discover and index Semantic Web documents (RDF, OWL,
DAML+OIL files); It computes importance rankings for ontologies similar to PageRank but adapted for
the Semantic Web (based on how many other ontologies import or reference a given ontology); It
provides search by term, namespace, or semantic content; It enables ontology reuse by making it easy
to find ontologies that define a particular concept or domain.
Significance of Swoogle: As the number of ontologies and Semantic Web documents on the Web
grows, search tools like Swoogle become essential infrastructure. Just as Google made the Web's
HTML documents discoverable, Swoogle makes the Semantic Web's machine-readable documents
discoverable. Swoogle promotes the core Semantic Web value of reuse — finding and building on
existing ontological work rather than creating new ontologies from scratch.

— End of Notes —