Neota Logic Server
Applications created in Neota Logic Author are executed by Neota Logic Server, which contains the reasoning engines for the many, integrated, hybrid reasoning methods supported by the Neota Logic System. The capabilities available in Server include:
- Situations—Combinations of facts and conclusions, including complex Boolean sets, are constructed as Situations, either automatically from the values of selected inputs or individually one at a time.
- Mappings—If / Then rules are created visually by drag-and-drop. Mappings may include facts, conclusions and situations.
- Decision Trees—Complex rules may be created in tree form, also by drag-and-drop. Trees are sometimes the clearest view of the domain expert's reasoning about an aspect of a problem.
- Decision Tables—Multiple rules of the same pattern can be created very quickly in spreadsheet form.
- Optimization—Conclusions may be set to Optimize, e.g., set Default Risk to Optimize-to-Maximum , which causes an application to seek the highest (or lowest) value possible for that conclusion using all available logic paths. This technique, unique to Neota Logic System, enables extraordinarily compact representation of very complex rules, and therefore very rapid construction and easy maintenance of such rules.
- Multi-value facts and conclusions—Conclusions may have multiple values, e.g., Required Compliance Steps, each of which is determined by different logic paths. Logic Server will automatically traverse all relevant logic paths to be sure that all possible values are determined.
- Instances—Applications can apply reasoning to tabular data structures, included nested structures, of the sort typically defined in a relational database. For example, a financial services product may have several aspects (type, duration, risk and governing contract); the contract may also have several aspects (name, date). An application might apply rules based on product type, contract, and duration to assess the risk for every product in the database.
- Weighted Factor Matrixes—Multiple factors that may affect a conclusion are identified. Each factor is weighted, using one of several weighting schemes, and scored on a scale, as defined by the domain expert. Factor weights and scores are combined mathematically to set a result conclusion, which may in turn be used in other reasoning. Weighted Factor Matrixes are particularly suited to the balancing tests often used in legal analysis.
- Case-Based Reasoning (CBR)—A set of input facts is matched to the characteristics of existing cases using a nearest-neighbor best fit algorithm. Cases with the closest match to the input facts are retrieved and can be displayed and used in other reasoning processes. CBR is particularly suited to diagnostic and customer assistance problems, where new patterns or exceptions may be captured as new cases.
- Calculations—With the Calculations Editor, authors can specify many different types of operations to be performed on facts and conclusions, including arithmetic, date and text operations, like Microsoft Excel functions.
- User-Defined Functions—If none of the built-in functions solves a problem at hand, a custom function can be written (with a Neota Logic Editor or any programming language) and added to the Logic Server.
- Mathematical and Spreadsheet Models—An application can use formulas in a Microsoft Excel spreadsheet or call upon Mathematica for exceptionally complex calculations.
- Custom logic engines for specific problems—For example, a text analytics engine to classify users' natural language answers to questions in accordance with a taxonomy could be integrated via the Logic Server's extensible architecture.
All reasoning methods are automatically integrated and prioritized. In contrast to business rules systems, it is not necessary to construct explicit ruleflows to determine the sequence in which rules are executed. This unique capability of the Neota Logic System enables rapid creation and easy maintenance of very sophisticated, subtle and complex applications that replicate the thinking of the best experts in a domain.
Neota Logic applications can run interactively—presenting questions and returning answers to a user in a web browser on a computer or smartphone—or can run invisibly as part of other business applications and processes such as transaction auditing.
Via Connector, Neota Logic Server can integrate with all databases and applications. It can read and write data to and from relational databases such as Microsoft SQL Server and Oracle as well as non-relational data stores such as SharePoint. It can add complex reasoning to workflow systems such as K2 Blackpearl. It can produce transaction-ready documents via document assembly engines such as DealBuilder and HotDocs.
Neota Logic Server can be configured in a cluster of 10 or 100 or 1,000 virtual servers. It is thus scalable to handle thousands of users and millions of inquiries. In the Amazon Web Services cloud, which provides virtual servers on demand for as long or short a time as needed, Neota Logic Server can scale up (and down) to handle very large peak loads for transaction audit and other intensive assignments.