FO(.)

This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these messages) This article's use of external links may not follow Wikipedia's policies or guidelines. Please improve this article by removing excessive or inappropriate external links, and converting useful links where appropriate into footnote references. (January 2022) (Learn how and when to remove this message) A major contributor to this article appears to have a close connection with its subject. It may require cleanup to comply with Wikipedia's content policies, particularly neutral point of view. Please discuss further on the talk page. (February 2022) (Learn how and when to remove this message) The topic of this article may not meet Wikipedia's general notability guideline. Please help to demonstrate the notability of the topic by citing reliable secondary sources that are independent of the topic and provide significant coverage of it beyond a mere trivial mention. If notability cannot be shown, the article is likely to be merged, redirected, or deleted. Find sources: "FO(.)" – news · newspapers · books · scholar · JSTOR (February 2022) (Learn how and when to remove this message) (Learn how and when to remove this message)

In computer science, FO(.) (a.k.a. FO-dot) is a knowledge representation language based on first-order logic (FO).^[1] It extends FO with types, aggregates (counting, summing, maximising ... over a set), arithmetic, inductive definitions, partial functions, and intensional objects.

By itself, a FO(.) knowledge base cannot be run, as it is just a "bag of information", to be used as input to various generic reasoning algorithms. Reasoning engines that use FO(.) include IDP-Z3,^[2] IDP^[3][4] and FOLASP.^[5] As an example, the IDP system allows generating models, answering set queries, checking entailment between two theories and checking satisfiability, among other types of inference over a FO(.) knowledge base.

FO(.) has four types of statements:

• Type, function and predicate declarations,
• Axioms, i.e., logic sentences about possible worlds,
• Definitions that specify a unique interpretation of a defined symbol, given the interpretation of its parameters. Definitions can be inductive.
• Enumerations, i.e., definitions of symbols by enumeration.

A voting law specifies that citizens must be at least 18 years old to vote. Furthermore, if the voting law is interpreted as being prescriptive, voting is mandatory when you are over 18. This can be represented in FO(.) as follows:

vocabulary V {
  age: () → ℤ                             // function declaration
  prescriptive, vote: () → 𝔹              // predicate declarations
}
theory T:V {
  age() < 18 ⇒ ¬vote().                   // axiom: if you are less than 18, you may not vote.
  prescriptive() ⇒ (age() ≥ 18 ⇒ vote()). // axiom: if prescriptive: if you are at least 18, you must vote
}

In this code, A→B indicates a function from A to B, ${\displaystyle \mathbb {Z} }$ denotes integers, ${\displaystyle \mathbb {B} }$ denotes the booleans, ¬ denotes negation, and ⇒ denotes material conditional. Predicates < and ≥ are built-in and have their usual meaning.

Such knowledge base can be turned automatically into an Interactive Lawyer^[6] (see here^[7])

• Official website