PowerLoom® Features

PowerLoom is a full-function, logic-based knowledge representation and reasoning system, that supports all aspects of knowledge-based applications. It allows the representation of complex knowledge in a declarative, logic-based language, supports a variety of reasoning mechanisms to make implicit knowledge explicit, has a powerful query engine to retrieve what has been asserted and logically follows from the KB, provides file-based and RDBMS-based storage of knowledge bases, has a context and module system to effectively partition and organize large knowledge bases, and has an extensive API in multiple language to allow easy and effective integration into knowledge-based applications.

PowerLoom's focus is on expressivity of its representation language while still providing good scalability to large ontologies and knowledge bases. In general, PowerLoom takes a pragmatic stance where usability is more important than theoretical "neatness" and expressivity is more important than inferential completeness. From our point of view, there is nothing magical about logic, it is just another programming language (with difficult to understand semantics), so it should help you to solve the task at hand as best as possible and not hinder you by forcing you to work around restrictions of the logic. Of course, PowerLoom cannot completely escape the straight-jacket of logic, but it tries to push the boundaries as much as possible.

Representation language
PowerLoom uses the language of predicate logic to represent knowledge. The syntax is KIF (the Knowledge Interchange Format) which is one of the supported syntaxes of the upcoming Common Logic standard. PowerLoom adds a variety of convenient definitional constructs as well as extensions beyond traditional first-order logic such as type-level predicates, relation variables in holds sentences, modal assertions (sentences about sentences), cross-context assertions via ist to represent lifting axioms, defaults (still experimental), and others. The goal is to provide a highly expressive representation language, since KR failures or awkward models are often due to "we could not express X in language L". The theoretical undecidability and intractability of such an expressive language is counteracted by providing limited, "pragmatic" reasoning services that cover commonly encountered situations. For example, reasoning with second-order sentences that quantify over relations is undecidable and leads to very unfocused search; however, such sentences are very useful to describe axiom schemata that can be cheaply run in forward direction to create regular first-order rules (in a process not unlike macro expansion).
The primary reasoning mechanism is logical deduction which infers statements that logically follow from the asserted statements and rules. Such statements can be asked about using PowerLoom's query commands ask (for true/false questions) and retrieve (for Wh-questions). PowerLoom uses a natural deduction system to answer queries but also has a large number of specialized reasoning procedures to efficiently handle concept and relation hierarchies, sets, frame predicates, search control, etc. The specialist architecture is extensible to allow users to plug-in their own reasoners or computed predicates. PowerLoom also supports hypothetical reasoning, equality reasoning, arithmetic and reasoning with inequalities. While PowerLoom is not a description logic, it does have a classifier that can classify concept and relation hierarchies and instances defined using the full expressive power of first-order logic. The classifier does not provide any additional inferences, but allows PowerLoom to eagerly pre-compute and cache subsumption relationships which can then be utilized over and over without having to re-derive them. PowerLoom also provides some experimental abductive and partial-match reasoning to handle incomplete knowledge bases.
Meta-representation and reasoning
Concepts, relations, contexts, rules, queries, etc. are all first-class citizens in the domain of discourse. Therefore, they can have assertions made about them as well as reasoned about. This mechanism is commonly used by the system itself, e.g., to assert that a relation is single valued or transitive, that a concept is closed, etc.
PowerLoom can explain its reasoning by recording inference trees and then rendering those into human-understandable explanations. PowerLoom also has an experimental "WhyNot" facility to explain inference failures where no successful proof tree was found.
Contexts and modules
Contexts and modules provide separate name and assertion spaces with inheritance which implement a powerful structuring mechanism for KBs. Contexts allow encapsulation and organization of knowledge, efficient inference (by separating irrelevant knowledge or by separating ontologies and assertion spaces from volatile inference worlds), truth maintenance (via inference cache contexts), scenarios and hypothetical reasoning, non-monotonic overrides in sub-contexts, etc. PowerLoom's context mechanism is built-in at a very low level using a very efficient and light-weight implementation for maximum performance.
Open and closed-world
By default, PowerLoom makes an open-world assumption and returns unknown if it cannot prove or disprove a question. However, concepts and relations can be selectively marked as closed to support selective closed-world reasoning. PowerLoom also has a fail predicate (in addition to true negation via not) to implement closed-world negation-as-failure which can be useful in certain situations.
Knowledge base management
PowerLoom supports incremental monotonic and non-monotonic updates that extend or non-monotonically change the assertion base. In PowerLoom one can effectively interleave definitions, re-definitions, assertions and retractions with retrieval and inference without having to reload large knowledge bases from scratch after every change. Truth maintenance of cached inference results that might have been invalidated by updates is done via inference cache contexts. After a knowledge base has been loaded and changed by some updates, the changed state can be saved out to a file or an (experimental) persistent store built on top of a relational database.
Despite its emphasis on expressive representation which usually has to be paid for with intractable and expensive reasoning procedures, PowerLoom is very scalable and comes with a variety of mechanisms to control search and handle large ontologies and knowledge bases. For example, PowerLoom's reasoning specialists handle a wide variety of inferencing very effectively without having to go through any rule chaining. Search control annotations can be used to help the inference engine use rules more effectively. For example, depending on fan-out, certain rules are run more effectively forwards than backwards (or vice versa), and a KB developer can tell the system when that's the case. PowerLoom has resource-bounded depth-first or iterative deepening search which provides an any-time inference scheme for situations where resources are limited. A "just-in-time" forward inference engine elaborates the assertion neighborhood of objects touched upon by inference. This allows focused forward inference relevant to current inference goals, without having to run forward inference over a potentially very large KB to completion. PowerLoom has a static and dynamic query optimizer, that, similar to optimizers used in database systems, orders conjunctive goals based on relation extension sizes and rule fan-out to minimize intermediate result sets and chaining. The dynamic optimizer does this for each conjunctive subgoal based on actual bindings. Given this mechanism it is possible to run PowerLoom queries that return 100,000's of solutions. PowerLoom also has a powerful relational database interface that allows it to utilize the power of databases for handling large assertion bases (soon to be released). One application of this PowerLoom/RDBMS integration is used with ISI's Omega ontology . It is also a crucial part of our KOJAK Link Discovery System .
Tools and APIs
PowerLoom has a host of associated tools and APIs (not all of which have been released yet). It comes with an interactive command-line interface which is useful for developing ontologies and knowledge bases, an extensive programmatic interface called PLI with Lisp, C++ and Java bindings, and a Lisp-based Loom API to load legacy Loom KBs. Ontosaurus is a Web-based KB browser that dynamically generates HTML pages viewable in a standard Web browser. A Protégé plug-in allows export of Protégé ontologies into PowerLoom format. A Java-based GUI provides a browse/edit/query environment for developing KBs. The GUI uses a client/server architecture and is deployable stand-alone or via Java WebStart in a standard browser. OntoMorph is a translation system that supports writing of KB translators and importers, e.g., to import ontologies written in other languages (for example, Flogic).
Initial Semantic Web support
Given PowerLoom's emphasis on expressive representation, we have not yet focused much on Semantic Web languages such as OWL, which restricts expressivity to gain decidability. OWL also has other limitations such as restriction to binary relations and lack of support for arithmetic and inequalities which limits its usefulness for practical applications. Nevertheless, given that people are starting to use these languages more and more, we've developed some initial import translators for RDF/RDFS and OWL which once they mature we will release as part of PowerLoom.
Portability and integration
Since PowerLoom is implemented in STELLA , it is available in Lisp, C++ and Java implementations and highly portable. PowerLoom can be run in each of these languages under Unix (such as Linux, SunOS or MacOS X) as well as Windows 2000 and XP. Due to the availability in three main-stream languages, it can easily be integrated programmatically with most application software without having to use some complex integration framework. The C++ and Java libraries for PowerLoom are also quite small and light-weight, for example, the necessary STELLA and PowerLoom jar files of the Java implementation are less than 2.5 Meg in size.

Information Sciences Institute PowerLoom Home Page
PowerLoom is a registered trademark of the University of Southern California.
Last modified: Oct 19, 2010