top of page

Semantic Web Services

Chapter 6.0
The Semantic Web
In this chapter, we provide an introduction to the Semantic Web and discuss its background and potential. By laying out a road map for its likely development, we describe the essential stepping stones including: knowledge representation, inference, ontology, search and search engines. We also discuss several supporting semantic layers of the Markup Language Pyramid Resource Description Framework (RDF) and Web Ontology Language (OWL).
In addition, we discuss using RDF and OWL for supporting software agents, Semantic Web Services, and semantic searches.
Tim Berners-Lee invented the World Wide Web in 1989 and built the World Wide Web Consortium (W3C) team in 1992 to develop, extend, and standardize the Web. But he didn’t stop there. He continued his research at MIT through Project Oxygen[1] and began conceptual development of the Semantic Web. The Semantic Web is intended to be a paradigm shift just as powerful as the original Web.
The goal of the Semantic Web is to provide a machine-readable intelligence that would come from hyperlinked vocabularies that Web authors would use to explicitly define their words and concepts. The idea allows software agents to analyze the Web on our behalf, making smart inferences that go beyond the simple linguistic analyses performed by today's search engines.
Why do we need such a system? Today, the data available within HTML Web pages is difficult to use on a large scale because there is no global schema. As a result, there is no system for publishing data in such a way to make it easily processed by machines. For example, just think of the data available on airplane schedules, baseball statistics, and consumer products. This information is presently available at numerous sites, but it is all in HTML format which means that using it has significant limitations.
The Semantic Web will bring structure and defined content to the Web, creating an environment where software agents can carry out sophisticated tasks for users. The first steps in weaving the Semantic Web on top of the existing Web are already underway. In the near future, these developments will provide new functionality as machines become better able to "understand" and process the data.
This presumes, however, that developers will annotate their Web data in advanced markup languages. To this point, the language-development process isn't finished. There is also ongoing debate about the logic and rules that will govern the complex syntax. The W3C is attempting to set new standards while leading a collaborative effort among scientists around the world. Berners-Lee has stated his vision that today’s Web Services in conjunction with developing the Semantic Web, should become interoperable.
Skeptics, however, have called the Semantic Web a Utopian vision of academia. Some doubt it will take root within the commercial community. Despite these doubts, research and development projects are burgeoning throughout the world. And even though Semantic Web technologies are still developing, they have already shown tremendous potential in the areas of semantic groupware (see Chapter 13) and semantic search (see Chapter 15). Enough so, that the future of both the Semantic Web and Semantic Web Services (see Chapter 11) appears technically attractive.
The Semantic Web
The current Web is built on HTML, which describes how information is to be displayed and laid out on a Web page for humans to read. In effect, the Web has developed as a medium for humans without a focus on data that could be processed automatically. In addition, HTML is not capable of being directly exploited by information retrieval techniques. As a result, the Web is restricted to manual keyword searches. For example, if we want to buy a product over the Internet, we must sit at a computer and search for most popular online stores containing appropriate categories of products.
We recognize that while computers are able to adeptly parse Web pages for layout and routine processing, they are unable to process the meaning of their content. XML may have enabled the exchange of data across the Web, but it says nothing about the meaning of that data. The Semantic Web will bring structure to the meaningful content of Web pages, where software agents roaming from page-to-page can readily carry out automated tasks.
We can say that the Semantic Web will become the abstract representation of data on the Web. And that it will be constructed over the Resource Description Framework (RDF) (see Chapter 7) and Web Ontology Language (OWL) (see Chapter 8). These languages are being developed by the W3C, with participations from academic researchers and industrial partners. Data can be defined and linked using RDF and OWL so that there is more effective discovery, automation, integration, and reuse across different applications.
These languages are conceptually richer than HTML and allow representation of the meaning and structure of content (interrelationships between concepts). This makes Web content understandable by software agents, opening the way to a whole new generation of technologies for information processing, retrieval, and analysis.
Two important technologies for developing the Semantic Web are already in place: XML and RDF. XML lets everyone create their own tags. Scripts, or programs, can make use of these tags in sophisticated ways, but the script writer has to know how the page writer uses each tag. In short, XML allows users to add arbitrary structure to their documents, but says nothing about what the structure means.
If a developer publishes data in XML on the Web, it doesn’t require much more effort to take the extra step and publish the data in RDF. By creating ontologies to describe data, intelligent applications won’t have to spend time translating various XML schemas.

In a closed environment, Semantic Web specifications have already been used to accomplish many tasks, such as data interoperability for business-to-business (B2B) transactions. Many companies have expended resources to translate their internal data syntax for their partners. As everyone migrates towards RDF and ontologies, interoperability will become more flexible to new demands.

Another example of applicability is that of digital asset management. Photography archives, digital music, and video are all applications that are looking to rely to a greater degree on metadata. The ability to see relationships between separate media resources as well as the composition of individual media resources is well served by increased metadata descriptions and enhanced vocabularies.

The concept of metadata has been around for years and has been employed in many software applications. The push to adopt a common specification will be widely welcomed.
For the Semantic Web to function, computers must have access to structured collections of information and sets of inference rules that they can use to conduct automated reasoning. AI researchers have studied such systems and produced today’s Knowledge Representation (KR). KR is currently in a state comparable to that of hypertext before the advent of the Web. Knowledge representation contains the seeds of important applications, but to fully realize its potential, it must be linked into a comprehensive global system.
The objective of the Semantic Web, therefore, is to provide a language that expresses both data and rules for reasoning as a Web-based knowledge representation.
Adding logic to the Web means using rules to make inferences and choosing a course of action. A combination of mathematical and engineering issues complicates this task (see Chapter 9). The logic must be powerful enough to describe complex properties of objects, but not so powerful that agents can be tricked by a paradox.
Intelligence Concepts
The concept of Machine Intelligence (MI) is fundamental to the Semantic Web. Machine Intelligence is often referred to in conjunction with the terms Machine Learning, Computational Intelligence, Soft-Computing, and Artificial Intelligence. Although these terms are often used interchangeably, they are different branches of study.
For example, Artificial Intelligence involves symbolic computation while Soft-Computing involves intensive numeric computation.
We can identify the following sub-branches of Machine Intelligence that relate to the Semantic Web:
  • Knowledge Acquisition and Representation.
  • Agent Systems.
  • Ontology.
Although symbolic Artificial Intelligence is currently built and developed into Semantic Web data representation, there is no doubt that software tool vendors and software developers will incorporate the Soft-Computing paradigm as well. The benefit is creating adaptive software applications. This means that Soft-Computing applications may adapt to unforeseen input.
Knowledge Acquisition is the extraction of knowledge from various sources, while Knowledge Representation is the expression of knowledge in computer-tractable form that is used to help software-agents perform. A Knowledge Representation language includes Language Syntax (describes configurations that can constitute sentences) and Semantics (determines the facts and meaning based upon the sentences).
For the Semantic Web to function, computers must have access to structured collections of information. But, traditional knowledge-representation systems typically have been centralized, requiring everyone to share exactly the same definition of common concepts. As a result, central control is stifling, and increasing the size and scope of such a system rapidly becomes unmanageable. In an attempt to avoid problems, traditional knowledge-representation systems narrow their focus and use a limited set of rules for making inferences. These system limitations restrict the questions that can be asked reliably.
XML and the RDF are important technologies for developing the Semantic Web; they provide languages that express both data and rules for reasoning about the data from a knowledge-representation system. The meaning is expressed by RDF, which encodes it in sets of triples, each triple acting as a sentence with a subject, predicate, and object. These triples can be written using XML tags. As a result, an RDF document makes assertions about specific things.
Subject and object are each identified by a Universal Resource Identifier (URI), just as those used in a link on a Web page. The predicate is also identified by URIs, which enables anyone to define a new concept just by defining a URI for it somewhere on the Web. The triples of RDF form webs of information about related things. Because RDF uses URIs to encode this information in a document, the URIs ensure that concepts are not just words in a document, but are tied to a unique definition that everyone can find on the Web.
Search Algorithms
The basic technique of search (or state space search) refers to a broad class of methods that are encountered in many different AI applications; the technique is sometimes considered a universal problem-solving mechanism in AI. To solve a search problem, it is necessary to prescribe a set of possible or allowable states, a set of operators to change from one state to another, an initial state, a set of goal states, and additional information to help distinguish states according to their likeliness to lead to a target or goal state. The problem then becomes one of finding a sequence of operators leading from the initial state to one of the goal states.
Search algorithms can range from brute force methods (which use no prior knowledge of the problem domain, and are sometimes referred to as blind searches) to knowledge-intensive heuristic searches that use knowledge to guide the search toward a more efficient path to the goal state (see Chapters 9 and 15).
Search techniques include:
  • Brute force
  1. Breadth-first
  2. Depth-first
  3. Depth-first iterative-deepening
  4. Bi-directional
  • Heuristic
  1. Hill-climbing
  2. Best-first
  3. A*
  4. Beam
  5. Iterative-deepening-A*
Brute force searches entail the systematic and complete search of the state space to identify and evaluate all possible paths from the initial state to the goal states. These searches can be breadth-first or depth-first. In a breadth-first search, each branch at each node in a search tree is evaluated, and the search works its way from the initial state to the final state considering all possibilities at each branch, a level at a time. In the depth-first search, a particular branch is followed all the way to a dead end (or to a successful goal state). Upon reaching the end of a path, the algorithm backs up and tries the next alternative path in a process called backtracking.
The depth-first iterative-deepening algorithm is a variation of the depth-first technique in which the depth-first method is implemented with a gradually increasing limit on the depth. This allows a search to be completed with a reduced memory requirement, and improves the performance where the objective is to find the shortest path to the target state.
The bi-directional search starts from both the initial and target states and performs a breadth-first search in both directions until a common state is found in the middle. The solution is found by combining the path from the initial state with the inverse of the path from the target state.
These brute force methods are useful for relatively simple problems, but as the complexity of the problem rises, the number of states to be considered can become prohibitive. For this reason, heuristic approaches are more appropriate to complex search problems where prior knowledge can be used to direct the search.
Heuristic approaches use knowledge of the domain to guide the choice of which nodes to expand next and thus avoid the need for a blind search of all possible states.
The hill-climbing approach is the simplest heuristic search; this method works by always moving in the direction of the locally steepest ascent toward the goal state. The biggest drawback of this approach is that the local maximum is not always the global maximum and the algorithm can get stuck at a local maximum thus failing to achieve the best results.
To overcome this drawback, the best-first approach maintains an open list of nodes that have been identified but not expanded. If a local maximum is encountered, the algorithm moves to the next best node from the open list for expansion. This approach, however, evaluates the next best node purely on the basis of its evaluation of ascent toward the goal without regard to the distance it lies from the initial state.
The A* technique goes one step further by evaluating the overall path from the initial state to the goal using the path to the present node combined with the ascent rates to the potential successor nodes.  This technique tries to find the optimal path to the goal. A variation on this approach is the beam search in which the open list of nodes is limited to retain only the best nodes, and thereby reduce the memory requirement for the search. The iterative-deepening-A* approach is a further variation in which depth-first searches are completed, a branch at a time, until some threshold measure is exceeded for the branch, at which time it is truncated and the search backtracks to the most recently generated node.
A classic example of an AI-search application is computer chess.  Over the years, computer chess-playing software has received considerable attention, and such programs are a commercial success for home PCs. In addition, most are aware of the highly visible contest between IBM’s Deep Blue Supercomputer and the reigning World Chess Champion, Garry Kasparov in May 1997.  Millions of chess and computing fans observed this event in real-time where, in a dramatic sixth game victory, Deep Blue beat Kasparov. This was the first time a computer has won a match with a current world champion under tournament conditions.
Computer chess programs generally make use of standardized opening sequences, and end game databases as a knowledge base to simplify these phases of the game. For the middle game, they examine large trees and perform deep searches with pruning to eliminate branches that are evaluated as clearly inferior and to select the most highly evaluated move.
We will explore semantic search in more detail in Chapter 15.
The goal of the Semantic Web is to provide a machine-readable intelligence. But, whether AI programs actually think is a relatively unimportant question, because whether or not "smart" programs "think," they are already becoming useful.
Consider, for example, IBM’s Deep Blue. In May 1997, IBM's Deep Blue Supercomputer played a defining match with the reigning World Chess Champion, Garry Kasparov. This was the first time a computer had won a complete match against the world’s best human chess player. For almost 50 years, researchers in the field of AI had pursued just this milestone.
Playing chess has long been considered an intellectual activity, requiring skill and intelligence of a specialized form. As a result, chess attracted AI researchers.
The basic mechanism of Deep Blue is that the computer decides on a chess move by assessing all possible moves and responses. It can identify up to a depth of about 14 moves and value-rank the resulting game positions using an algorithm prepared in advance by a team of grand masters.
Did Deep Blue demonstrate intelligence or was it merely an example of computational brute force? Our understanding of how the mind of a brilliant player like Kasparov works is limited. But indubitably, his "thought" process was something very different than Deep Blue’s. Arguably, Kasparov’s brain works through the operation of each of its billions of neurons carrying out hundreds of tiny operations per second, none of which, in isolation, demonstrates intelligence.
One approach to AI is to implement methods using ideas of computer science and logic algebras.  The algebra would establish the rules between functional relationships and sets of data structures. A fundamental set of instructions would allow operations including sequencing, branching and recursion within an accepted hierarchy. The preference of computer science has been to develop hierarchies that resolve recursive looping through logical methods. One of the great computer science controversies of the past five decades has been the role of GOTO-like statements. This has risen again in the context of Hyperlinking. Hyperlinking, like GOTO statements, can lead to unresolved conflict loops (see Chapter 12). Nevertheless, logic structures have always appealed to AI researchers as a natural entry point to demonstrate machine intelligence.
An alternative to logic methods is to use introspection methods, which observe and mimic human brains and behavior. In particular, pattern recognition seems intimately related to a sequence of unique images with a special linkage relationship. While Introspection, or heuristics, is an unreliable way of determining how humans think, when they work, Introspective methods can form effective and useful AI.
The success of Deep Blue and chess programming is important because it employs both logic and introspection AI methods. When the opinion is expressed that human grandmasters do not examine 200,000,000 move sequences per second, we should ask, “How do they know?'' The answer is usually that human grandmasters are not aware of searching this number of positions, or that they are aware of searching a smaller number of sequences. But then again, as individuals, we are generally unaware of what actually does go on in our minds.
Much of the mental computation done by a chess player is invisible to both the player and to outside observers. Patterns in the position suggest what lines of play to look at, and the pattern recognition processes in the human mind seem to be invisible to that mind. However, the parts of the move tree that are examined are consciously accessible.
Suppose most of the chess player’s skill actually comes from an ability to compare the current position against images of 10,000 positions already studied. (There is some evidence that this is at least partly true.) We would call selecting the best position (or image) among the 10,000, insightful. Still, if the unconscious human version yields intelligent results, and the explicit algorithmic Deep Blue version yields essentially the same results, then couldn’t the computer and its programming be called intelligent too?
For now, the Web consists primarily of huge number of data nodes (containing texts, pictures, movies, sounds). The data nodes are connected through hyperlinks to form `hyper-networks' can collectively represent complex ideas and concepts above the level of the individual data. However, the Web does not currently perform many sophisticated tasks with this data. The Web merely stores and retrieves information even after considering some of the “intelligent applications” in use today (including intelligent agents, EIP, and Web Services). So far, the Web does not have some of the vital ingredients it needs, such as a global database scheme, a global error-correcting feedback mechanism, a logic layer protocol, or universally accepted knowledge bases with inference engines. As a result, we may say that the Web continues to grow and evolve, but it does not learn.
If the jury is still out on defining the Web as intelligent, (and may be for some time) we can still consider ways to change the Web to give it the capabilities to improve and become more useful (see Chapter 9).
Knowledge Representation and Inference
An important element of AI is the principle that intelligent behavior can be achieved through processing of symbol structures representing increments of knowledge. This has given rise to the development of knowledge-representation languages that permit the representation and manipulation of knowledge to deduce new facts. Thus, knowledge-representation languages must have a well-defined syntax and semantics system, while supporting inference.
First let’s define the fundamental terms “data,” “information,” and “knowledge.” An item of data is a fundamental element of an application. Data can be represented by population and labels. Information is an explicit association between data things. Associations are often functional in that they represent a function relating one set of things to another set of things. A rule is an explicit functional association from a set of information things to a resultant information thing. So, in this sense, a rule is knowledge.
Knowledge-based systems contain knowledge as well as information and data. The information and data can be modeled and implemented in a database. Knowledge-engineering methodologies address design and maintenance knowledge, as well as the data and information.
Logic is used as the formalism for programming languages and databases. It can also be used as a formalism to implement knowledge methodology. Any formalism that admits a declarative semantics and can be interpreted both as a programming language and database language is a knowledge language.
Three well-established techniques have been used for knowledge representation and inference: frames and semantic networks, logic based approaches, and rule based systems.
Frames and semantic networks also referred to as slot and filler structures, capture declarative information about related objects and concepts where there is a clear class hierarchy and where the principle of inheritance can be used to infer the characteristics of members of a subclass from those of the higher level class. The two forms of reasoning in this technique are matching (i.e., identification of objects having common properties), and property inheritance in which properties are inferred for a subclass. Because of limitations, frames and semantic networks are generally limited to representation and inference of relatively simple systems.
Logic-based approaches use logical formulas to represent more complex relationships among objects and attributes. Such approaches have well-defined syntax, semantics and proof theory. When knowledge is represented with logic formulas, the formal power of a logical theorem proof can be applied to derive new knowledge. However, the approach is inflexible and requires great precision in stating the logical relationships.
In some cases, common-sense inferences and conclusions cannot be derived, and the approach may be inefficient, especially when dealing with issues that result in large combinations of objects or concepts.
Rule-based approaches are more flexible. They allow the representation of knowledge using sets of IF-THEN or other condition action rules. This approach is more procedural and less formal in its logic and as a result, reasoning can be controlled in a forward or backward chaining interpreter.
In each of these approaches, the knowledge-representation component (i.e., problem-specific rules and facts) is separate from the problem-solving and inference procedures.
Resource Description Framework (RDF)
The Semantic Web is built on syntaxes which use the Universal Resource Identifier (URI) to represent data in triples-based structures using Resource Description Framework (RDF) (see Chapter 7). A URI is a Web identifier, such as "http:" or "ftp:.” The syntax of URIs is governed by the IETF, publishers of the general URI specification the W3C maintains a list of URI schemes.
In an RDF document, assertions are made about particular things having properties with certain values. This structure turns out to be a natural way to describe the vast majority of the data processed by machines. Subject, predicate, and object are each identified by a URI.
The RDF triplets form webs of information about related things. Because RDF uses URIs to encode this information in a document the URIs ensure that concepts are not just words in a document, but are tied to a unique definition. All the triples result in a directed graph whose nodes and arcs are all labeled with qualified URIs.
The RDF model is very simple and uniform. The only vocabulary is URIs which allow the use of the same URI as a node and as an arc label. This makes self-reference and reification possible, just as in natural languages. This is appreciable in a user-oriented context (like the Web), but is difficult to cope with in knowledge-based systems and inference engines.
Once information is in RDF form, data becomes easier to process. We illustrate an RDF document in Example 6-1. This piece of RDF basically says that a book has the title "e-Video: Producing Internet Video," and was written by "H. Peter Alesso."
Example 6-1
Listing 6-1 Sample RDF /XML
<rdf:RDF xmlns:rdf=""
    xmlns:foaf="" >
    <rdf:Description rdf:about="">
        <dc:creator rdf:parseType="Resource">
            <foaf:name>H. Peter Alesso</foaf:name>
        <dc:title>e-Video: Producing Internet Video</dc:title>
The benefit of RDF is that the information maps directly and unambiguously to a decentralized model that differentiates the semantics of the application from any additional syntax. In addition, XML Schema restricts the syntax of XML applications and using it in conjunction with RDF may be useful for creating some datatypes.
The goal of RDF is to define a mechanism for describing resources that makes no assumptions about a particular application domain, nor defines the semantics of any application.
RDF models may be used to address and reuse components (software engineering), to handle problems of schema evolution (database), and to represent knowledge (Artificial Intelligence).
However, modeling metadata in a completely domain independent fashion is difficult to handle. How successful RDF will be in automating activities over the Web is an open question. However, if RDF could provide a standardized framework for most major Web sites and applications, it could bring significant improvements in automating Web-related activities and services (see Chapter 11). If some of the major sites on the Web incorporate semantic modeling through RDF, it could provide more sophisticated searching capabilities over these sites (see Chapter 15).
We will return to a detailed presentation of RDF in Chapter 7.
RDF Schema
The first "layer" of the Semantic Web is the simple data-typing model called a schema. A schema is simply a document that defines another document. It is a master checklist or grammar definition. The RDF Schema was designed to be a simple data-typing model for RDF. Using RDF Schema, we can say that "Desktop" is a type of "Computer," and that "Computer" is a sub class of “Machine”. We can also create properties and classes, as well as, creating ranges and domains for properties.
All of the terms for RDF Schema start with namespace
The three most important RDF concepts are "Resource" (rdfs:Resource), "Class" (rdfs:Class), and "Property" (rdf:Property). These are all "classes," in that terms may belong to these classes. For example, all terms in RDF are types of resource. To declare that something is a "type" of something else, we just use the rdf:type property:
rdfs:Resource rdf:type rdfs:Class .
rdfs:Class rdf:type rdfs:Class .
rdf:Property rdf:type rdfs:Class .
rdf:type rdf:type rdf:Property .
This means "Resource is a type of Class, Class is a type of Class, Property is a type of Class, and type is a type of Property."
We will return to a detailed presentation of RDF Schema in Chapter 7.
A program that wants to compare information across two databases has to know that two terms are being used to mean the same thing. Ideally, the program must have a way to discover common meanings for whatever databases it encounters. A solution to this problem is provided by the Semantic Web in the form of collections of information called ontologies. Artificial-intelligence and Web researchers use the term ontology for a document that defines the relations among terms. A typical ontology for the Web includes a taxonomy with a set of inference rules.
 Ontology and Taxonomy
We can express an Ontology as:
Ontology = < taxonomy, inference rules>
And we can express a taxonomy as:
Taxonomy = < {classes}, {relations}>
The taxonomy defines classes of objects and relations among them. For example, an address may be defined as a type of location, and city codes may be defined to apply only to locations, and so on. Classes, subclasses, and relations among entities are important tools. We can express a large number of relations among entities by assigning properties to classes and allowing subclasses to inherit such properties.
Inference rules in ontologies supply further power. An ontology may express the rule "If a city code is associated with a state code, and an address uses that city code, then that address has the associated state code." A program could then readily deduce, for instance, that an MIT address, being in Cambridge, must be in Massachusetts, which is in the U.S., and therefore should be formatted to U.S. standards. The computer doesn't actually "understand" this, but it can manipulate the terms in a meaningful way.
The real power of the Semantic Web will be realized when people create many programs that collect Web content from diverse sources, process the information and exchange the results. The effectiveness of software agents will increase exponentially as more machine-readable Web content and automated services become available. The Semantic Web promotes this synergy — even agents that were not expressly designed to work together can transfer semantic data.
The Semantic Web will provide the foundations and the framework to make such technologies more feasible.
Web Ontology Language (OWL)
In 2003, the W3C began final unification of the disparate ontology efforts into a standardizing ontology called the Web Ontology Language (OWL). OWL is a vocabulary extension of RDF. OWL is currently evolving into the semantic markup language for publishing and sharing ontologies on the World Wide Web.
OWL facilitates greater machine readability of Web content than that supported by XML, RDF, and RDFS by providing additional vocabulary along with formal semantics.
OWL comes in several flavors as three increasingly-expressive sublanguages: OWL Lite, OWL DL, and OWL Full. By offering three flavors, OWL hopes to attract a broad following.
We will return to detailed presentation of OWL in Chapter 8.
A rule may describe a conclusion that one draws from a premise. A rule can be a statement processed by an engine or a machine that can make an inference from a given generic rule. The principle of "inference" derives new knowledge from knowledge that we already know. In a mathematical sense, querying is a form of inference and inference is one of the supporting principles of the Semantic Web.
For two applications to talk together and process XML data, they require that the two parties must first agree on a common syntax for their documents. After reengineering their documents with new syntax, the exchange can happen. However, using the RDF/XML model, two parties may communicate with different syntax using the concept of equivalencies. For example, in RDF/XML we could say “car” and specify that it is equivalent to “automobile.”
We can see how the system could scale. Merging databases becomes recording in RDF that "car" in one database is equivalent to "automobile" in a second database.
Indeed, this is already possible with Semantic Web tools, such as a Python program called "Closed World Machine” or CWM.
Unfortunately, great levels of inference can only be provided using "First Order Predicate Logic," FOPL languages, and OWL is not entirely a FOPL language.
First-order Logic (FOL) is defined as a general-purpose representation language that is based on an ontological commitment to the existence of objects and relations. FOL makes it easy to state facts about categories, either by relating objects to the categories or by quantifying.
For FOPL languages, a predicate is a feature of the language which can make a statement about something, or to attribute a property to that thing.
Unlike propositional logics, in which specific propositional operators are identified and treated, predicate logic uses arbitrary names for predicates and relations which have no specific meaning until the logic is applied.
Though predicates are one of the features which distinguish first-order predicate logic from propositional logic, these are really the extra structure necessary to permit the study of quantifiers. The two important features of natural languages whose logic is captured in the predicate calculus are the terms "every" and "some" and their synonyms. Analogues in formal logic are referred to as the universal and existential quantifiers. These features of language refer to one or more individuals or things, which are not propositions and therefore force some kind of analysis of the structure of "atomic" propositions.
The simplest logic is classical or boolean, first-order logic. The "classical" or "boolean" signifies that propositions are either true or false.
First-order logic permits reasoning about the propositional and also about quantification ("all" or "some"). An elementary example of the inference is as follows:
All men are mortal.
John is a man.
The conclusion:
 John is mortal.
Application of inference rules provides powerful logical deductions. With ontology pages on the Web, solutions to terminology problems begin to emerge. The definitions of terms and vocabularies or XML codes used on a Web page can be defined by pointers from a page to an ontology. Different ontologies need to provide equivalence relations (defining the same meaning for all vocabularies), otherwise there would be a conflict and confusion.
Software Agents
Many automated Web Services already exist without semantics, but other programs, such as agents have no way to locate one that will perform a specific function. This process, called service discovery, can happen only when there is a common language to describe a service in a way that lets other agents understand both the function offered and the way to take advantage of it. Services and agents can advertise their function by depositing descriptions in directories similar to the Yellow Pages.
There are some low-level, service-discovery schemes which are currently available. The Semantic Web is more flexible by comparison. The consumer and producer agents can reach a shared understanding by exchanging ontologies which provide the vocabulary needed for discussion. Agents can even bootstrap new reasoning capabilities when they discover new ontologies. Semantics also make it easier to take advantage of a service that only partially matches a request.
An intelligent agent is a computer system that is situated in some environment, that is capable of autonomous action and learning in its environment in order to meet its design objectives. Intelligent agents can have the following characteristics: reactivity — they perceive their environment, and respond, pro-active — they exhibit goal-directed behavior and social — they interact with other agents.
Real-time intelligent agent technology offers a powerful Web tool. Agents are able to act without the intervention of humans or other systems: they have control both over their own internal state and over their behavior. In complexity domains, agents must be prepared for the possibility of failure. This situation is called non-deterministic.
Normally, an agent will have a repertoire of actions available to it. This set of possible actions represents the agent’s capability to modify its environments. Similarly, the action "purchase a house" will fail if insufficient funds are available to do so. Actions therefore have pre-conditions associated with them, which define the possible situations in which they can be applied.
The key problem facing an agent is that of deciding which of its actions it should perform to satisfy its design objectives. Agent architectures are really software architectures for decision-making systems that are embedded in an environment. The complexity of the decision-making process can be affected by a number of different environmental properties, such as:
  • Accessible vs inaccessible.
  • Deterministic vs non- deterministic.
  • Episodic vs non-episodic.
  • Static vs dynamic.
  • Discrete vs continuous.
The most complex general class of environment is inaccessible, non-deterministic, non-episodic, dynamic, and continuous.
Trust and Proof
The next step in the architecture of the Semantic Web is trust and proof. If one person says that x is blue, and another says that x is not blue, will the Semantic Web face logical contradiction?
The answer is no, because applications on the Semantic Web generally depend upon context, and applications in the future will contain proof-checking mechanisms and digital signatures.
Semantic Web Capabilities and Limitations
The Semantic Web promises to make Web content machine understandable, allowing agents and applications to access a variety of heterogeneous resources, processing and integrating the content, and producing added value for the user. The Semantic Web aims to provide an extra machine understandable layer, which will considerably simplify programming and maintenance effort for knowledge-based Web Services.
Current technology at research centers allow many of the functionalities the Semantic Web promises: software agents accessing and integrating content from distributed heterogeneous Web resources. However, these applications are really ad-hoc solutions using wrapper technology. A wrapper is a program that accesses an existing Website and extracts the needed information. Wrappers are screen scrapers in the sense that they parse the HTML source of a page, using heuristics to localize and extract the relevant information. Not surprisingly, wrappers have high construction and maintenance costs since much testing is needed to guarantee robust extraction and each time the Website changes, the wrapper has to be updated accordingly.
The main power of Semantic Web languages is that anyone can create one, simply by publishing RDF triplets with URIs. We have already seen that RDF Schema and OWL are very powerful languages.
One of the main challenges the Semantic Web community faces for the construction of innovative and knowledge-based Web Services is to reduce the programming effort while keeping the Web preparation task as small as possible.
The Semantic Web’s success or failure will be determined by solving the following:
• The availability of content.
• Ontology availability, development, and evolution.
• Scalability – Semantic Web content, storage, and search are scalable.
• Multilinguality – information in several languages.
• Visualization – Intuitive visualization of Semantic Web content.
• Stability of Semantic Web languages.
In this chapter, we provided an introduction to the Semantic Web and discussed its background and potential.
By laying out a roadmap for its likely development, we described the essential stepping stones including: knowledge representation, inference, ontology, and search. We also discussed several supporting semantic layers of the Markup Language Pyramid Resource Description Framework (RDF) and Web Ontology Language (OWL).
In addition, we discussed using RDF and OWL for supporting software agents, Semantic Web Services, and semantic search.
[1] MIT's Project Oxygen is developing technologies to enable pervasive, human-centered computing and information-technology services. Oxygen's user technologies include speech and vision technologies to enable communication with Oxygen as if interacting directly with another person, saving much time and effort. Automaton, individualized knowledge access, and collaboration technologies will be used to perform a wide variety of automated, cutting-edge tasks.
bottom of page