The Basics: Facts, Rules, and Queries

Ergo Syntax Quick Reference

• Terminating a statement: A period '.' ends every statement in Ergo, including queries as well as assertions.
• Asking a query: ?- starts queries embedded in files. However, the '?-' should be omitted when entering queries in ErgoAI Studio's Query window or Listener window; and when entering queries to Ergo Reasoner's command line (i.e., "on the command line").
• Basic connectives:
  • :- -- directional implication. E.g., head :- body . means: if body holds then conclude head .
  • , (comma) or \and (for those who don't mind typing extra) -- conjunction.
  • ; (semi-colon) or \or -- disjunction.
• Constants:
  • Numeric constants: 123 (integer), 345.31 (decimal), 0.123e1 (floating point number)
  • General constant symbols (also known as Prolog atoms): a, John, 'a string with $#@^% in it'
  • Data type constants (a la XML data types): "12345"^^xsd:integer (same as 12345), "2015-10-13"^^\date (a date constant, same as \d"2015-10-13"), and more -- see Data Types in Ergo)
• Variable symbols are alphanumeric symbols prefixed by the character “?”: ?x, ?Var1, ?ABC, ?_ABC (if a variable starts with an "_", it is called a silent variable), ?, ?_ (the last two are called anonymous variables, as they don't have names).
• Terms: f(1,a,?Var), ?p(b(?x),?q(c,d)) -- HiLog terms; [a,b,c], [1,2,3|[4,5]], [3,?X,?Y|?Z] -- list terms.
• Negation symbols: \naf -- negation-as-failure, a.k.a. default negation; \neg -- explicit negation. See More Advanced Features.
• Unification and equality symbols: = -- unifies, :=: -- logically equal; := -- operator used in user-defined functions; \is -- arithmetic and string expression evaluator. Most of these features are illustrated in Section More Advanced Features, but see ErgoAI Reasoner User's Manual for more details.
• Frame construction symbols: -> or \hasvalue; => or \hastype; : or \isa -- class membership; :: or \sub -- subclass-of. These constructors are used in the frame syntax of Ergo, which is described later in this section and in User-defined Types and Default Values in the Frame Syntax.
• Comments: // -- comments out the rest of this one line; /*… */ -- multi-line comment.
• Aggregation operators: min, max, count, sum, avg. See More Advanced Features.
• Comprehension operators: setof , bagof. These operators are related to aggregation and are defined in ErgoAI Reasoner User's Manual.
• Logical quantifiers: forall, exists (or exist or each or all). See the section Quantifiers and Omniform Rules (this is a fairly advanced feature).
  • Implications: ~~>, ==>, <~~, <==, <~~>, <==>. See the section Quantifiers and Omniform Rules.
• Delay quantifiers (goal reordering): must, wish. This is a very advanced feature that is briefly illustrated in Section More Advanced Features, but see ErgoAI Reasoner User's Manual for further details.
• Other/auxiliary symbols: (, ) , [, ] , , (comma), < , > , | , { , } , $ (used for reification), @ (used for meta-info annotation, modules) , ’ (single quote, used to enclose non-alphanumeric symbols), #, \ (backslash - used for special operators).

A complete grammar is defined in the ErgoAI Reasoner User's Manual. This manual is searchable and well-indexed, so finding specific features should be easy.

Facts, Rules, and Queries in Ergo Using the "socrates" Example

The following discussion makes use of the ergo files, socrates.ergo and socrates_frames.ergo. Please download the files and load the first into ErgoAI so you can follow along.

• Ergo is a reasoning engine - it combines facts and rules to infer new facts.
• Because Ergo is built on top of Prolog, a basic understanding of Prolog is helpful in learning Ergo
  • A good tutorial can be found here: Learn Prolog Now

Facts

Users can teach Ergo basic facts or provide data for the reasoning engine to work on.

• Facts can be based on any natural language (NL) sentence. In our examples in this tutorial, we will use English sentences to create Ergo facts, queries, and rules.
• Large amounts of facts can be imported from existing data stores.
  • For example, Ergo can automatically import facts from triple stores, RDF, or OWL via the Ergo2OWL API -- see Ergo Connectors and API's.
  • The fastload{} primitive allows one to quickly load large amounts of data.

Here is an example of encoding a fact in the socrates.ergo example:

Ergo facts are also called literals and have the form: predicate(arguments) or \neg predicate(arguments), where arguments is a tuple of (zero or more) arguments separated by commas. Literals can also use the frame notation described later.

Rules

• Rules show logical relationships and implications among facts. They are the basis for Ergo's ability to map terminology, aid in decisions, create alerts, answer questions, and, in general, reason with data.
• Rules consist of two parts: the head and the body, separated by the :- symbol.
• A rule means that the body of the rule implies the head. A rule can be read as "If the body is true then the head is true". (Here, truth is in the sense of belief under the semantics of the computational logic Rulelog.)
• Note that in Ergo, the then-part of the rule comes first (the head) and is on the left in the example below while the if-part of the rule comes after the :- symbol (the body) and is on the right in the example below.

Here is a rule encoded from an English sentence in the socrates.ergo example:

Variables

• The socrates.ergo example made use of a variable, ?X.
• Variables are symbols that begin with ?,
  • The ? symbol can be followed by a letter or the underscore, '_', which in turn can be followed by letters, underscore, or digits.
  • Examples include ?X, ?name, ?person, ?_437, ?avgAge, ?patient_1
• Occurrences of the same variable within one rule denote the same variable. Variables are local to a particular rule, a variable with the same name in different rules stands for different, unrelated variables.
• ?_ or ? is an anonymous variable, a unique variable name is created for each occurrence of such a variable anywhere.
  • Thus, different occurrences of ?_ and ? denote different variables -- even within the same rule!
• ?_Alphanumeric is a Silent variable because it starts with an underscore. Such variables have many purposes:
  • In a query, bindings are not returned for such variables; the system assumes that the user placed such a variable in a query because specific values of the bindings for that variable are of no importance. (If they are, then don't place a silent variable there!)
  • Ergo does various checks and issues warnings for:
    • Singleton variables
    • Unsafe variables: those that appear in the rule head, but not in the rule body.
  • If any such variable is found, a warning is generated because this is a mistake with high probability. If the user is sure that a particular occurrence of an unsafe or singleton variable is not a mistake, he or she should use anonymous or silent variables in such places.
  • In ErgoAI Studio Editor, singleton variables are flagged with a yellow warning symbol.

Queries

Queries in Ergo use the same syntax as the bodies of the rules. That is, any rule body can be used as a query. Queries can be asked either interactively or they can be embedded inside Ergo knowledge bases. In the latter case, the embedded queries will be asked automatically after the corresponding knowledge base is loaded or added.

Interactive queries

A query can be asked interactively on the command line (in a terminal window or in the Ergo Listener), or it can be asked using the Query Panel, which is accessible via the Tools menu in the listener. In addition, the ErgoAI Studio Editor allows users to pose queries by selecting text and then choosing an appropriate item from the contextual menu opened via a right click. The images below use the Query Panel method.

For example, suppose we wish to query to find out whether Socrates is mortal.

Is Socrates mortal?

We could use the fact-form literal itself as a query if we put it in the query window or in the input area of the Studio Listener:

        mortal(Socrates).

With the result:

Yes.

We could also be more indirect, and instead query to find out more generally who is mortal. To do so, we can use the rule head as a query (be sure to add a period):

       mortal(?X).

The result shows all instances that satisfy the rule and bind to the variable ?X:

Try adding a few more facts to socrates.ergo about mortals and reloading it to see the query in action. For example, add:

• mortal(Fred).
• mortal(Linda).
• mortal(turtle).

Then you will see more answers to the query mortal(?X).

Another query: man(?X). -- who is a man?

Try formulating and running a query in Ergo for each of the following English sentences (answers at the bottom of the page):

• What is the age of each person?
• Where is Socrates grandfather's home?

Non-interactive (embedded) Queries

Non-interactive queries are embedded directly into files and are asked when the file is first loaded or added. These queries are not asked again if the file is re-loaded/re-added unless the file was changed since the last load/add; it if was changed, it will be re-compiled (as well as re-loaded/re-added) which triggers re-execution of the query. An example of this use of queries is shown in the file socrates_with_embedded_queries.ergo. This is a little knowledge base, similar to socrates.ergo, but we added some information about a woman Safo and included two embedded queries:

?- writeln('Query 1:')@\io, mortal(?X), age(?X,?A), ?A < 56.

?- writeln('Query 2:')@\io, man(?X), age(?X,?A), ?A < 56.

Note the symbol ?- that indicates that we are dealing with embedded queries. If one loads this file (e.g., using [socrates_with_embedded_queries].) then the following will be output to the terminal window:

Query 1:

?X = Plato

?A = 27

?X = Safo

?A = 55

?X = Xenophon

?A = 27

3 solution(s) in 0.0010 seconds

Yes

Query 2:

?X = Plato

?A = 27

?X = Xenophon

?A = 27

2 solution(s) in 0.0000 seconds

Yes

Times (in seconds): elapsed = 1.0940; pure CPU = 1.0440

Yes

Besides embedded queries there also are latent queries, which are distinguished with the symbol !- instead of ?-. A latent query is similar to embedded queries in that it appears inside a file and is never asked interactively. However, latent queries are not run automatically when their containing files are loaded or added. Instead, they are run at later times by the user via the special command query{...}, which itself can be asked interactively or embedded in a file. More information on that appears in the ErgoAI Reasoner User's Manual., section "Latent Queries."

Using Frame Syntax in Ergo

Now open and load the socrates_frames.ergo example.

• Ergo offers an alternative, object-oriented syntax for many expressions: frame syntax (F-logic).
• The regular syntax is called, by contrast, predicate syntax.
• Frame syntax is sometimes more concise than predicate syntax.
• Especially for users familiar with object-oriented programming or RDF, frame syntax is sometimes more intuitive or familiar than predicate syntax.
• Frame syntax rearranges the components of Ergo facts/literals that have 2 arguments.
• More generally, it rearranges the subject, predicate (a.k.a. property), and object (a.k.a value) of the fact:

There is a special syntax for expressing several values for the same property. The second, shorter variants (in blue) expand into the longer variants (in black).

If desired, we can write a frame containing several properties of the same subject:

Structures can be nested:

We can also make statements asserting what class, or kind of thing, an object is:

We can also express subclass relationships between classes:

We can also write rules in the frame syntax, including using class and subclass. Here we show two ways to represent the same English sentence in Ergo. The second variant (in blue) both of the predicate and the frame syntax uses the {...,...} construct, which expands into the first construct in each case.

Example queries and expected answers for the socrates_frames.ergo example are shown below:

Frame Syntax: More Examples

• In the example below, 'John' and 'Mary' are the Object Ids, name, phoneNum, and children are the attributes.

Additional features of the frame syntax (user-defined types and default values) are covered in Section User-Defined Types and Default Values.

Typed Variables

In addition to regular variables as described above, Ergo supports typed variables. Typed variables can be bound to classes, which will restrict the variables so that they will be unifiable only with members of the specified classes.

• Typed variables permit the class to be any of Ergo's primitive data types such as \integer, \real, \time, and so on, as well as to be any of the user defined classes (which are specified in the knowledge base's assertions). For more information, see section "Typed Variables" in the ErgoAI Reasoner User's Manual.
• The syntax is ?Var^^Class. Here, Class can be a primitive data type or a user defined class.

For example:

To better understand the difference between the typed variables and the regular ones, consider the following set of facts:

p(John), p(Bob), p(Tom).

p(2), p(3).

John:student, Tom:student.

Then the query p(?X). will return five answers: ?X = John, ?X = Bob, ?X = Tom, ?X = 2, and ?X = 3. In contrast, the query p(?X^^student). will return only the first and the third (John and Tom). Why? Because Bob, 2, and 3 are not students. Similarly, the query p(?X^^\integer). will return only ?X = 2, and ?X = 3 (because integers are automatically made to be members of the type \integer -- see the tutorial page Data Types in Ergo).

For information on how to specify the types of the properties and methods in a class, including Inheritable Types, see the tutorial page, Types and Defaults in the Frame Syntax.

Answers to 'Interactive queries' section problems

• What is the age of each person? The corresponding Ergo query is:

age(?person, ?age).

• Where is Socrates grandfather's home? The corresponding Ergo query is:

home(father(father(Socrates)),?home).