Products and Services Overview
Amzi! specializes in products and services for developing and deploying integrated application components that apply logical knowledge, such as pricing rules, configuration logic, insurance regulations, diagnostic and advisory knowledge, grammar rules, message translation rules, and semantic relationships.
Unlike factual and procedural knowledge that are naturally deployed using conventional software tools, logical knowledge is difficult to deploy without specialize tools.
Traditional software tools provide two ways of encoding knowledge: one is as facts, or data, in memory; the other is as sequences of instructions coded in a procedural programming language such as Java, C++, Visual Basic, Delphi or C#.
These two types of knowledge, factual and procedural, are natural for a computer because a computer is engineered from memory (facts/data) and a processing unit that executes a sequence of instructions (procedures). It is no accident that database tools and procedural programming languages have been with computers since the earliest days. It is no accident that early commercial use of computers was called 'data processing.'
Consider an airline reservation system. It has factual knowledge about passengers, flights, and bookings stored in a database. It has procedures that manipulate that data, for example to book a passenger on a flight.
This type of automation is well suited to a computer's design.
Logical knowledge is relationships. On paper, logical knowledge might be expressed as rules, or in tables showing conditions and implied results, or as graphs showing connections, or in formats that are particular to a given application area.
In an airline reservation system, pricing knowledge would be logical. It is a complex set of rules and tables describing relationships between air fare and dates, places, connections, durations, class, frequent flier miles, weekends, holidays, discounts, promotions and who knows what else.
Logical knowledge, unless relatively simple, does not lend itself to easy encoding in a computer.
It doesn't fit well in a database, because the relationships expressed are more complex than the simple factual relationships databases can encode.
It doesn't fit well in procedural code because the programmer is forced to artificially express the independent logical relationships as a sequence of instructions with well-defined flow of control.
Examples of Logical Knowledge
Pricing the relationships between price and the factors affecting it, for almost any product of even modest complexity;
Regulations government's and private organization's rules and regulations, such as tax codes, insurance rules, legal requirements, benefits, purchasing, and work flow;
Configuration the complex relationships between customer needs and products and components;
Support the relationships between faults and symptoms in diagnostic technical support solutions, or between customer needs, and appropriate products and services;
Scheduling the rules governing broadcast scheduling, radio and TV music scheduling, work scheduling, resource allocation, sports events;
Grammars translation rules between data transfer protocols, program inputs, or natural languages;
Scientific geologic relationships between surface observations and oil below, electric circuit behavior, network modeling, medical diagnosis, and economic modeling.
While not well suited for the task, traditional tools are often used to encode logical knowledge.
In a few cases, the traditional tools are workable. For example, if the relationships are simple enough to be expressed in tables with the same columns, then a database can be used effectively. If the rules fit readily in a decision tree, then that tree can be represented by procedural branching statements.
But logical knowledge of any significance has a variety of factors in the relationships, making them ill-suited for database; and no implied sequence of execution, making them awkward to code procedurally. Different combinations of rules in different sequences are required depending on the input data.
The advantage of using traditional tools is, well, that they are traditional tools. There are a large number of programmers who are skilled in using them.
The disadvantage of using traditional tools is the procedural code and/or fragmented collections of data tables needed to express the interrelated logical relationships winds up being a rat's nest of unwieldy, difficult to maintain and highly error prone code.
For some application areas, this might not be a factor. But if the logical knowledge is changing, and it is important to keep up with the changes, then the costs of maintaining the encoding of the logical knowledge becomes prohibitive. More importantly, due to the time consuming and error prone nature of that approach, competitive advantage could well be lost.
There's If-Then and then there's If-Then
The term 'if-then' for rules is sometimes confusing because it is used both to describe branching instructions in a procedure, and certain logical relationships. In procedural code, if-then statements steer the flow of control. As logical relationships, if-then rules have no implied order of execution.
What about object-oriented programming? An 'object,' in computer science terms, is an encapsulation, in a single entity, of data and the procedures that work on that data. Object-oriented programming is a powerful tool, making the programmer's job of developing and maintaining procedural code that manipulates data much easier.
But object-oriented programming does not address the problems created by logical relationship knowledge, because it still only provides semantics for data and procedure.
What about scripting languages? HTML? Java Beans? Active Server Pages? and all the other Internet tools? These, too, are all tools for generating sequences of instructions for a CPU.
If the problem with encoding logical knowledge is the underlying machine, then what's needed to do the job right is a machine designed to handle logical knowledge. Building a hardware machine is not very practical, but software can be used to build a wide variety of virtual machines.
This is exactly what is done in all of the tools available for expert systems, business rule systems, knowledge base systems, logicbase systems, case base systems and others.
Each of these tools has a virtual machine architecture with two key components:
- a "knowledge representation" syntax and interface for entering and maintaining logical relationships in a file called a "knowledge base," and
- a "reasoning engine" that takes input data and, using the knowledge base, produces answers.
- A pricing application has a knowledge base of pricing rules and regulations; takes as input particulars of a given flight; and produces as output a fare.
- A support application has a knowledge base of diagnostic rules; takes as input symptoms of a given problem; and produces as output a solution.
- A configuration application has a knowledge base of related components; takes as input customer requirements; and produces as output a configured assembly.
This architecture provides the major benefit that the logical knowledge no longer has to be forced into a format that is ill-served for coding it. Because the logical knowledge is more naturally expressed in a knowledge representation language, it is easier to create and maintain. Because it is easier to maintain, it is less error-prone, more reliable, and changes can be incorporated in production software much more rapidly.
In some cases the logical relations can be maintained directly by those with the knowledge, avoiding the translation step through an intermediate programmer. This further magnifies the benefits.
The science of Artificial Intelligence (AI) concerns itself with the engineering and use of virtual machines that work with knowledge that cannot be easily expressed either factually or procedurally. Working with logical knowledge is a large part of AI. The term AI might be somewhat justified considering that human brains, unlike computers, are naturally good at processing logical relationships.
Unfortunately, there is tremendous variety in the forms of logical knowledge required for different application domains, and accordingly, there are a number of different tools and approaches.
How well a given tool fits a particular application depends on how close the knowledge representation language and reasoning engine match the way the application logic is naturally expressed and used.
For example, pricing knowledge is usually formal and precise, whereas knowledge about technical support has more vagaries in it, and also requires support for textual or HTML questions and answers. Configuration knowledge includes rules for how components are combined and also needs to express the logical relationships of hierarchies of parts.
Both pricing and technical support would have reasoning engines intent on finding a specific solution, but the knowledge for configuring complex products needs to be applied in a building block manner, creating a complex structure as output.
There are numerous general-purpose tools that might fit a given application, or an organization might decide to build a customized tool for their particular application.
A customized tool has the huge benefit that the knowledge representation can be designed to specifically match the way knowledge for that application is expressed. This often means those with the knowledge can directly maintain the knowledge base without programmer intervention.
A general-purpose tool can be purchased off-the-shelf and might provide a good enough fit for the application.
Spreadsheets are a perfect example of a specialized tool for a specific type of logical knowledge. In this case the logical relationships are arithmetic formulas linking the contents of the various cells.
The designers of a spreadsheet program first create the pattern of cells and allowable formulas users can use to express relationships. That is the knowledge representation.
They then write a program that knows how to compute the required cells in a spreadsheet. That is the reasoning engine.
The logical relationships defined in the spreadsheet, such as this cell is equal to the sum of those cells, are then used to compute values for different inputs. The result is financial users can directly enter the types of relationships they deal with in a familiar manner, without requiring a programmer. The underlying spreadsheet engine does the computation for them.
As we all know, spreadsheets are tremendously popular because they let non-programmers encode logical relationships that are executed by the spreadsheet reasoning engine. Of course, they are limited to expressing the sorts of things you can express in an array of related cells and formulae.
There are many general purpose expert system tools and business rule products that follow the same architecture. They provide a knowledge representation for entering logical relationships as rules, and a reasoning engine that knows how to execute those rules.
These tools are powerful and are often used to solve the problem of encoding logical relationships.
The degree to which they are successful is related to how closely the semantics of the particular logical relationships are to the given tool. When the tool does not fit particularly well, then often, programmers are still needed to code the relationships for the tool.
This means those with the know-how don't maintain the logicbase directly. On the other hand, this is a better solution than using traditional tools because the programmer is now working with declarative specifications of the logical relationships rather than forcing them into procedural code.
The result is faster, more reliable response to changing conditions.
Prolog is a tool that has a reasoning engine that takes as input formal logical assertions of facts and relationships. It's knowledge representation is ideal for precise sorts of relationships, such as those found in regulations and definitive business rules.
Prolog logic can be compiled for fast execution, and the Prolog reasoning engine is well suited for access from other applications, making it easy to access a logicbase in an application.
Prolog has the advantage over most tools in that it is an ISO standard language with many vendors providing compatible implementations. While not as widespread as Java or C++, many programmers have had some exposure to Prolog.
For application areas where those with the know-how prefer less formal syntax for representing logical relationships, it is not difficult to create front-end maintenance tools that translate a more informal representation into high performance Prolog syntax.
For example, developers might provide a spreadsheet or database front-end that allows those with know-how to enter rules and relationships.
That is then translated into a back-end Prolog logicbase for production.
The result is a hybrid system that provides many of the advantages of an application-specific logicbase, with a reliable, high-performance, general purpose logic reasoning engine for deployment.
Application-specific knowledgebases have tremendous advantages for those cases where they are cost-effective. They provide a very powerful tool for those with the know-how to use, and deployment without requiring programmer intervention.
The result is fast reliable turn around of the business logical knowledge in response to changing business environments. The trade-off is development cost, as it takes time and money to design and build a custom knowledge representation and reasoning engine.
Prolog can greatly reduce the cost of building these custom tools. In addition to its easily learned and used formal logicbase capabilities, Prolog supports more advanced logic programming.
Logic programming is an extremely powerful programming technology ideally suited for implementing custom tools for maintaining and deploying logical knowledge.
While Prolog's easily learned pure logic is limited in its application to knowledge that is formal in nature, using logic programming, it is almost trivial to design knowledge representation formats for an infinite variety logical knowledge.
In a fraction of the time and code it would take using traditional programming technologies, logic programming can be used to implement reasoning engines that provide any sort behavior a particular application requires.
Logic programming makes use of Prolog's built-in pattern-matching and search algorithms. It might be called meta logic, because with logic programming it is easy to create a wide variety of ways to represent and reason over knowledge.
It takes some learning for a programmer to become skilled at logic programming, but once learned, allows for very rapid development of specialized knowledge-base tools.
The advantages to this approach are immense. It allows for the customization of knowledge representation to exactly the form that is easiest to work with for those that matter most, the people with the know how that is being encoded.
The result is responsibility for the knowledge lies with those that have the knowledge.
Amzi! offers a variety of products and services all aimed at deploying application components that make use of logical knowledge.
The resulting applications can be deployed on Windows or Unix operating systems and be integrated into a variety of Web-based or stand-alone environments.
A subset of Amzi! Prolog provides an easily learned and used syntax for expressing logical relationships directly as pure logical assertions. Together these assertions form a logicbase that can be queried much as a database can.
Because such a logicbase is "pure" logic it is best suited for application areas where the rules and relationships are crisp and well defined. Examples include regulations, such as for taxes or insurance forms, and business rules, such as for pricing, underwriting or workflow.
The Amzi! Logic Server allows the logicbase to be deployed on the Web or as part of a stand-alone application. It can run on Windows or Unix operating systems and connect directly to software written in languages such as Java, C++, VB, C# and Delphi.
Prolog syntax can also be generated from other forms of logical knowledge. If those with the knowledge have their own way of recording that knowledge, say in a spreadsheet or a database, then that form can be translated into executable Prolog for all of the deployment advantages of the Amzi! Logic Server.
In addition to supporting logicbases for directly representing logical relationships, Amzi! Prolog supports full logic programming capabilities.
Logic programming is ideal for modelling any sort of knowledge and its use. Logic programming might be called meta logic, because it uses logical statements to describe general properties and behaviors of the domain being modelled.
Because logic programming is an extension of Prolog logicbase capabilities, it can be used to enhance logicbases with extra functionality. It can also be used to create entirely new applications for representing and reasoning over specific types of knowledge.
Some examples of logic programming applications are intelligent tutorials, broadcast scheduling, product configuration, pattern-matching for customers/suppliers, pattern-matching for mines and output, natural language, and grammar rules for message translation.
For applications involving knowledge representation and reasoning, logic programming often yields greater than a ten to one improvement in productivity when compared to procedural programming tools. The trade off is logic programming can take one to two weeks to learn.
Logic programs developed with Amzi! Prolog can be deployed using the Logic Server, providing all the advantages of embeddability and extendability that the Logic Server offers for logicbases.
Product: Amzi! Consulting
Amzi! provides custom solutions in a variety of ways:
- Building custom rule engines and knowledgebase tools.
- Prototyping applications and technology transfer.
- Providing custom extensions to the Prolog environment.
- Providing ports to different environments.
- Licensing distribution of Amzi! products under other brand names.
- Training professionals in the use of Prolog.
Weather Shield provides configuration and pricing information for doors and windows (the glass type) using a hybrid logicbase. The knowledge is maintained by sales and manufacturing experts in a database format, which is translated into a Prolog logicbase for download and deployment on customer computers. This makes it very easy to do business with Weather Shield.
DigitalXPress schedules real-time streaming video, multicasts and large data transfers via satellites. Their high-performance scheduler, a logic program, creates the schedule in real-time as prioritized requests are entered.
eoTek, a supplier of mortgage services for Nexstar, maintains separate knowledgebases of pricing and underwriting rules. They switched from a pure Java approach to a hybrid logicbase approach, gaining faster turnaround of pricing/underwriting changes, shorter test cycles, increased reliability, and high performance. This gives Nexstar a competitive edge in mortgage services.
Youbet.com supplies dynamic Web content for the horse racing enthusiast. It has separate logic program and logicbase that describe how content is extracted from a large and changing set of suppliers, for example various race tracks around the World. This lets them quickly provide the latest services for their customers.
CCH uses a hybrid logicbase approach for use by applications that fill out insurance forms. Changing regulations and forms are maintained by those that know the regulations and forms without need for program modification.
GeoReference Online uses logic programming to implement a sophisticated ontological and semantic net tool used to build applications that aid geologic exploration.
U.S. Army uses a custom knowledgebase from Amzi! that uses Arden medical expertise syntax for knowledge representation. The domain is breast cancer information and the knowledge is maintained directly by non-programmers with breast cancer expertise.
CST hired Amzi! for the development of technical support knowledgebase tools as part of a start-up venture.
SAIC subcontracted Amzi! for the development of a custom knowledge archiving and reasoning system that would allow collaborative development and use of knowledge from government funded medical research. This was a three-tiered 100% pure Java application.
A major computer manufacturer hired Amzi! for custom extensions to the Prolog engine to support proprietary high-performance Web applications. (Those extensions are part of the latest Amzi! release.)
A provider of equipment design and cost modelling software for the chemical and refinery industries hired Amzi! to port its Prolog engine to VMS, and to Alphas utilizing full 64-bit addressing.
Pacific AI hired Amzi! to design and build a knowledge representation and reasoning engine to be used for creating intelligent tutorials in a variety of subject areas.
Fitcentric hired Amzi! to implement a customer jig for KnowledgeWright that allowed the easy encoding and deployment of physiological logical knowledge specific to providing coaching advice for endurance athletes.
A human resources specialist is using the KnowledgeWright Guide Jig to implement a knowledgebase providing advice on available employee benefits.
A software applications development company hired Amzi! to train developers in the use of Prolog for the implementation of an airline pricing system.
Two major software vendors license Amzi! products for inclusion in workflow products.
These are the primary benefits of the Amzi! approach to deploying logical knowledge, helped with some metrics from a customer that kept good statistics.
- Automate 'difficult' components - Logicbases can easily implement application components that are 'difficult' using conventional tools. Typically they are difficult because they are specified as sets of interrelated rules and relations that are too complex for database, yet are not easily expressed in procedural languages. Because a logicbase is composed of non-procedural logical relations and rules, this type of application is very easy in Prolog. For example, one user replaced 5000 lines of Java code that implemented complex pricing rules, with 500 lines of Prolog logic.
- Bring business logic closer to those who know it best - Logicbases can often be maintained directly by those who maintain the business rules. This is sometimes due to the declarative nature of Prolog, and sometimes to the ease with which Prolog can represent various types of knowledge. For example, the pricing component used to require Java programmers to implement changes, now a hybrid front-end allows those changes to be directly handled by pricing experts.
- Greater Reliability - Logicbases can be independently tested and debugged, before integration, making for quicker, more error-free implementation. Also the often factor of ten reduction in code means there is simply less code to go wrong. The pricing component has been virtually error-free.
- High Performance - Logicbases execute extremely fast. This is because the declarative Prolog logic is compiled to run on a specialized Prolog virtual machine. Dynamic Prolog logic is indexed for high performance. The pricing component takes up an insignificant portion of a total pricing transaction.
- High Volume Use - Logicbases are ideal for Web deployment. Multiple simultaneous logicbase engines can be run in multiple threads. The pricing application maintains a pool of Logic Servers, serving online demand.
- Rapid Development - Components are developed in a fraction of the time required using procedural languages and database. Developers don't worry about procedural flow-of-control or memory allocation issues, concentrating instead on pure application logic. The pricing application took two years to develop in Java, but less than two months in Prolog.
- Easy Integration - Logicbase components can be deployed as part of any application context. The Amzi! Logic Server API provides interfaces for popular languages and environments. The pricing component is part of a Java real-time Internet service.
- Highly Portable - Amzi! logicbases can be run on most any computing environment. Compiled logicbases are machine independent, running on a Prolog virtual machine. The pricing component was moved without change between Solaris and Windows NT servers.
- International Applications - Logic-bases can be deployed in any national language, using either Unicode or locale-specific multi-byte character sets. The pricing application is in English. An erosion advisor was developed and deployed in Chinese.
Amzi! inc. is a small privately-owned business that specializes in products and services for maintaining and deploying knowledge that is best stored as logical relationships. It has been in business since 1991, servicing a wide range of commercial and government customers with a level of support that only a small, focused company can provide.
Copyright © 1995-2016 Amzi! inc. All Rights Reserved.
Amzi!, Logic Server, ARulesXL, KnowledgeWright, Adventure in Prolog, Building Expert Systems in Prolog, are trademarks of Amzi! inc.
Flying squirrel photo Copyright © Joe McDonald