The Scone Knowledge-Base project

“If a machine is expected to be infallible, it cannot also be intelligent.”- Alan Turing

In this article, I am trying to summarize valuable content on the Scone project by Professor Emeritus Scott E. Fahlman ( famously accredited for inventing Emoticons) and his research team at Carnegie Mellon University. Please find the content and published papers in the reference section below to learn more. I have summarized the paper by referring to various papers published and the official website.

A language can be defined as a set of rules or a set of symbols. Symbols are combined and used for conveying information or broadcasting the information. Rules are used to govern symbols. Together they form Knowledge and data. The knowledge base is used as a tool to store, retrieve and perform other ETL functions.

Before we start discussing the Scone knowledge-based project, let’s understand what a knowledge base is.

Knowledge base (KB) is a technology used to store complex structured and unstructured information used by a computer system. The first use of the term was in conjunction with expert systems, which were the first knowledge-based systems. The data in your knowledge base can come from anywhere. Typically, patrons who are well versed in the relevant subjects add to and expand the knowledge base. Many knowledge bases are structured around artificial intelligence that can communicate and respond to user input. Others are indexed encyclopedias. There are also machine-readable knowledge bases that store content in system-readable forms. Solutions are based on what we call automatic deductive reasoning. When a user enters a query, the software helps slim down a solution. Click here to learn more about the Knowledgebase.

Scone

Scone is a knowledge base system developed specifically to support human-like common-sense reasoning and the understanding of human language. It is a knowledgebase system explicitly designed to support human-like common-sense reasoning and the knowledge of the human language.

Scone is a knowledge representation and reasoning system –a knowledge base system or KB system–that has been developed over the last few years by the beloved Scott E. Fahlman (accredited as Father of Emoticons) and his research group at Carnegie Mellon University. Scone is written in Common Lisp. The primary vehicle for Scone development is Steel Bank Common Lisp (SBCL), which is a derivative of CMU Common Lisp (CMUCL). SBCL is a free, high-performance implementation of Common Lisp running on Linux and some other operating systems.

Before we get ahead to understand Scone in its depth, let us see some salient features of Scone.

1. Not a complete AI or decision-making mechanism — Scone, by itself, is not a perfect AI or decision-making system, and does not aspire to be; instead, it is a software component –a sort of smart active memory system, that is designed to be used in a wide range of software applications, both in AI and in other areas.
2. Primary emphasis: The primary focus of Scone is on expressiveness, ease of use, and scalability. The goal has been to support common-sense reasoning and natural-language understanding, not theorem-proving and logic puzzles. It is also to find efficient inference algorithms, and that remains usable even as the knowledge base grows to millions of entities and statements.
3. Speed and scalability: Benchmark tests have shown that Scone can deliver real-time performance on a standard (~$1000) workstation, even as the KB grows to several million elements and statements. Scone’s core search and inference capabilities (Fahlman, 2006) are based on marker-passing algorithms initially designed for a hypothetical massively parallel machine, the NETL machine (Fahlman, 1979)
4. Frame-like representation with virtual-copy semantics: Scone’s type hierarchy allows multiple inheritance and exceptions. Upon creating a subtype or instance, all of the structure of the prototype description is efficiently inherited. In effect, the new subtype or instance becomes a virtual copy of the parent description; it can then be specialized by adding further information or by subtracting information that would otherwise be inherited.

5. Default reasoning with exceptions: The ability to create exceptions and to explicitly over-ride some inherited information is a core capability of Scone and is efficiently implemented in Scone’s inference algorithms.

6.Higher-order logic and meta-information: First-order logic cannot make statements about statements, to reason about this meta-information, and to use that to control which statements will participate in the system’s reasoning.

7. Supports multiple contexts in the knowledge base: Multiple context approach makes Scone stand apart from other knowledge bases. Various contexts can be used to implement some aspects of human thought that are awkward or impossible for other knowledge-representation multiple contexts can be used to implement some elements of rational thought that are awkward or impossible for different knowledge-representation formalisms. I will be discussing my understanding of various contexts in the Scone in detail below.

8. Uses marker-passing algorithms: Scone uses marker-passing algorithms initially designed for a hypothetical massively parallel machine (the NETL machine). These marker-passing algorithms cannot perform every kind of search and inference that can be handled by a general theorem-prover. However, the Scone algorithms are high-speed, and they can handle most types of searches and conclusions that are needed for common-sense reasoning.

9.Requirements: Scone has been run successfully on CMU Common Lisp and several Windows-based Common Lisp systems, including CLISP, LispWorks, and Allegro Common Lisp. Scone can be run as a server process on an Intel/Linux system, communicating with other software applications via character-stream I/O using the TCP/IP socket mechanism.

Scone elements

The Scone knowledge base is best thought of as a collection of interconnected elements. Each component is represented in the Scone software as a data structure — a Common Lisp “defstruct.”An element in Scone can be a node, a link, or a relation.

1. Node-A node represents a conceptual entity such as “George Washington” or “the typical elephant” or “the mother of Clyde.” Note that the node represents a specific concept or meaning in each case, not a word or word-definition. The connection between Scone elements and natural-language words or phrases is a many-to-many association. It is the job of external software (an English language front-end to Scone — under construction) to resolve any ambiguity.
2. Link -A link represents a relation or statement of some kind, such as “Clyde is an elephant” or “The wife of George is Martha” or “Every elephant hates P. T. Barnum.”
3. Split-A split is a special kind of link with an unusual structure: it connects to any number of elements rather than just two or three. It is used to state that these connected elements — types and individuals — are mutually distinct and disjoint.
4. Relation-A relation is an element that represents the definition of a relation in Scone. The set of relations is open-ended. Once it has been created, the relation can be instantiated for specific cases by creating statement links. A relation is in some respects like a type-node: it can have other relations below it in the is-a hierarchy — effectively these are sub-types of the relation — and statement-links serve as the instance.

In general, nodes are connected by links. Each link has a few distinct wires by which it can be connected to other elements in the knowledge base. These are designated A-wire, B-wire, C-wire, parent-wire, context-wire, and (for split-links only) any number of split-wires. The A and B wires are used by links to indicate the two elements that the link is saying something about. For example, if a link L represents the statement “Clyde hates Jumbo,” the A wire of element L would go to {Clyde}, the B wire to {Jumbo}, the parent wire to {hates}, and the context wire to the currently-active context, which is always held in the Lisp variable.

In general, the parent wire of a link is used to indicate one superior class of this link in the type hierarchy. In other words, the parent wire tells us what kind of link this is. (A few particularly essential link types, such as is-a, eq, and cancel, are represented as particular built-in element types, and are directly recognizable by the software.) The context wire is used for links to indicate the context (represented by a node) in which a given statement is considered to be true. Every element has a terminal point to which any number of incoming wires from other elements may be attached.

5. Property list:- Every Scone element has a property list, storing attribute-value pairs. The set of attributes is open-ended. A Common Lisp keyword represents each attribute. Some properties are defined and used by the Scone implementation, while others may be determined by users or by (Copyright 2003–2014 by Scott E. Fahlman) software external to Scone. These properties provide an inexpensive way to store metainformation about an element in situations where the information is static and where high-speed access is not required, information that may be canceled or altered, or that may change from one context to another, is better represented using full-fledged Scone elements.

6. Markers-Every Scone element has a set of bits representing permanent state information about that element. These bits are known as the element’s flag bits. Some of the flag bits are used to encode the type of the node or link: individual vs. type node, “is a” versus “eq” link, and so on. Other flag bits encode properties of the element, such as whether a statement link is an instance of a transitive relation. Every Scone element also has storage for several marker bits, which are set and cleared by the Scone engine as part of various search and inference operations.

7. Contexts — Every Scone element has a context-wire. This is used to tie a node to the context in which it exists, and it is used to tie a link to the context in which it is true. A context is simply a Scone node. When a new context-node is first created, it inherits the contents (nodes and links) of its superior nodes in the is-a hierarchy. You can then add an additional KB structure in the new context. You can also cancel or negate nodes and links that would otherwise be inherited.

8.indv-node- An individual node (or indv-node) represents an individual entity rather than a type. It is not necessarily a physical object: it can be something more abstract, such as a number or a specific date. Individuals are normally the leaf-nodes of Scone’s is-a hierarchy.

9.type-node- A type-node represents the typical member of some class or set: {elephant}, {rainbow}, {weekday}, and so on. You can attach properties and class-memberships to a type-node just as if it were an individual: “The typical elephant is a mammal”, “the color of the typical elephant is gray”, and so on. In the way they are used, type-nodes and indv-nodes are very similar, except that individual nodes are normally leaf-nodes in the is-a hierarchy, while type nodes are intended to have subtypes and instances.

10. Map Nodes- Map Nodes A map-node represents, by definition, “the x of y” — for example, the {mother} of {Clyde}. Users do not normally deal with map-nodes directly — they are created and accessed by the functions.

11. IS-A Links — IS-A Links says that element A “is a” B in the specified context and that A should (by default) inherit all the properties and type-memberships of B. We speak of B as being “above” A in the is-a hierarchy.

12. EQ Links — An eq link says that A and B are equivalent — they represent the same entity — in the specified context. A inherits all the properties of B and B inherits all the properties of A. It is common to equate a proper individual with a generic individual, or two generic individuals to one another.

13. Has Links — There is a possibility that it can be deprecated or changed later. please refer to the Scone guide for further details.

14. Cancel Links- Suppose the knowledge base has a {hates} statement from {elephant} to {snake}, indicating that elephants hate snakes — or, more precisely, that the typical elephant hates the typical snake. Suppose that Clyde is an elephant, but an atypical one: he doesn’t hate snakes. We can represent this kind of exception using a cancel link from {Clyde} to the {hates} statement inherited from {elephant}. The effect of the cancel link is to turn off the {hates} statement — to render it inoperative — when Scone is considering the properties of {Clyde}. The statement is still effective for other elephants.

15. Split and Complete-Split Links -A split is a special kind of link: it can have any number of split-wires instead of individual A, B, and C wires. The meaning is that the type nodes connected by the split wires are mutually disjoint: no individual can be an instance of more than one of these types. If some of the connected nodes are individuals, they are disjoint from one another and are not instances of any type in the split. Scone has efficient machinery for determining whether a new or proposed link causes a split to be violated.

Current and Potential Applications of Scone

1)Online catalogs: It is straightforward in Scone to represent hierarchies of products, their characteristics, their intended application, which components work together, information on prices, vendors, and availability, and so on.

2)Help-desk support: Just as products can be described and searched in Scone, so too can families of problems, their symptoms, and their causes.

3)Autonomic computing: Companies that develop or manage complex hardware/software installations face a serious problem in configuring these systems correctly, recognizing vulnerabilities and attacks, and diagnosing and repairing problems. The first step in managing this complexity is to create a symbolic description of the installation: its components, tasks, personnel and permissions, and the external environment. This is a job for a KB.

4)Federated databases: Suppose two companies merge. Company A has a database of employees, but it does not cover temporary or part-time employees. Company B has a database, also labeled employees, which does contain their part-time and temporary employees, but it does not include salespeople who get commission rather than a salary. If we can represent the different types and subtypes of employees in a knowledge base, then we can begin to combine these two ontologies and to resolve the differences between them.

One possible solution is to send all database queries first to Scone, which will pick off and answer any odd or exceptional queries; Scone can then send the straightforward questions (perhaps in modified form) on to the appropriate DB.

5)Computational biology: The literature in this field is vast and is growing at an alarming rate. Representing and organizing all this diverse knowledge, so that connections can be noticed and so that researchers can find the information that they need, is another job well-suited for a knowledge base, perhaps backed up by multiple databases for low-level data.

References —

1. The Scone project site:)- http://www.cs.cmu.edu/~sef/scone/
2. The Scone user guide:)-http://www.cs.cmu.edu/~sef/scone/Scone-User.pdf
3. Marker-Passing Inference in the Scone Knowledge-Base System by Scott E. Fahlman :)-http://www.cs.cmu.edu/~sef/scone/publications/MarkerPaper.pdf
4. Eris: Episodic Representation and Reasoning in Scone by Scott E. Fahlman http://www.cs.cmu.edu/~sef/scone/publications/SconeTR2014-1.pdf
5. Using Scone’s Multiple-Context Mechanismto Emulate Human-Like Reasoning by Scott E. Fahlman :)-http://www.cs.cmu.edu/~sef/scone/publications/ACS-2011.pdf
6. Natural Language: Itís All About Meaning by Scott E. Fahlman :)-http://www.cs.cmu.edu/~sef/scone/publications/AAAIFellows2006.pdf