Traditional acquaintance with knowledge representation (KR) relates to the boolean logic including classical logic, modal logic and linear logic [3, 4]. Within this setting, knowledges are expressed as a logic of facts. Many KRs in AI textbooks and papers  have been written in boolean logic. However, boolean logic is too simple to represent an important aspect of knowledge, i.e., tasks that can be accomplished by the agent. In particular, boolean logic is awkward to use in representing accomplishable tasks by many interesting agents.
It is possible to expand knowledge about an agent by employing a task/game logic called computability logic (CL) [6, 7], a powerful logic which is built around the notion of success/failure. CL is a logic of task in which accomplishable tasks can be easily represented. Consequently, CL can express both deterministic (true/false) and nondeterministic task (success/failure) in a concise way. The task logic offers many new, essential logical operators including parallel conjunction/disjunction, sequential conjunction/disjunction, choice conjunction/disjunction, etc.
This paper proposes to use CL as an KR language. The distinguishing feature of CL is that now knowledge about an agent include new, sophisticated tasks that have not been supported by previous logical languages. While CL is an excellent KR language, it is based on the first-order logic. We also consider its higher-order extension where first-order terms are replaced by higher-order terms. It is well-known that higher-order terms can describe objects of function types including programs and formulas. Higher-order terms have proven useful in many metalanguage applications such as theorem proving.
2 Task Logical KR
A task logical knowledge representation and reasoning (KRR) is of the form
where represents an agent who can do task and is a query. In the traditional developments of KR, is limited to facts or accomplished tasks. Accomplishable tasks are totally ignored. In KR, however, representing accomplishable tasks is desirable quite often. Such examples include many interesting agents including coffee vending machine, many OS processes, lottery tickets, etc.
To define the class of accomplishable tasks, we need a specification language. An ideal language would support an optimal translation of the tasks. We argue that a reasonable, high-level translation of the tasks can be achieved via computability logic(CL)[5, 6]. An advantage of CL over other formalisms such as sequential pseudocode, linear logic, etc, is that it can optimally encode a number of essential tasks: nondeterminism, updates, etc. Hence the main advantage of CL over other formalisms is the minimum (linear) size of the encoding.
We consider here a higher-order version of CL. The logical language we consider in this paper is built based on a simply-typed lambda calculus. Although types are strictly necessary, we will omit these here because their identity is not relevant in this paper. An atomic formula is where is a (predicate) variable or non-logical constant and each is a lambda term.
The basic operator in CL is the reduction of the form . This expression means that the task can be reduced to another task . The expression means that the agent can perform two tasks and in parallel. The expression means that the agent can perform the task repeatedly. The expression means that the agent can perform either task or , regardless of what the machine chooses. The expression means that the agent can perform the task , regardless of what the machine chooses for . The expression means that the agent can choose and perform a true disjunct between and .
The notion of CL makes KR versatile compared to traditional approach. As an example, we present an agent who can compute the factorial function. This task can be defined as follows in English:
can either claim that holds, or
can replace by .
It is shown below that the above description can be translated into CL formulas. The following is a CL translation of the above knowledge, where the reusable action is preceded with . Note that our version use which dynamically creates/destroys facts. . A task of answering queries is typically given in the form of a query relative to agents. Computation tries to solve the query with respect to the agent . As an example, executing would involve the user choosing a value, say 5, for . This eventually results in the initial resource being created and then transformed to , then to , and so on. It will finally produce the desired result using the second conjucnt five times.
An example of interactive, accomplishable tasks is provided by the following agent which is a lottery ticket. The ticket is represented as which indicates that it has two possible values, nothing or one million dollars.
The following is a CL translation of the above agent.
Now we want to obtain a final value of . This task is represented by the query . Now executing the program would produce the following question asked by the agent in the task of in the program: “how much is the final value?”. The user’s response would be zero dollars. This move brings the task down to . Executing would require the machine to choose zero dollars in for a success.
An example of parallel tasks is provided by the agent which consists of two (sub)agents and working at a fastfood restaurant. The agent waits for a customer to pay money(at least three dollars), and then generates a hamburger set consisting of a hamburger, a coke and a change. The agent waits for a customer to pay money(at least four dollars), and then generates a fishburger set consisting of a fishburger, a coke and a change.
The following is a CL translation of the above algorithm.
Now we want to execute and in parallel to obtain a hamburger set and then a fishburger set by interactively paying money to and . This interactive task is represented by the query . Now executing the program would produce the following question asked by the agent in the task of : “how much do you want to pay me?”. The user’s response would be five dollars. This move brings the task down to which would be a success. The task of would proceed similarly.
As an example of higher-order KR, consider the interpreter for Horn clauses. It is described by - and -formulas given by the syntax rules below: In the rules above, represents an atomic formula. A -formula is called a Horn clause. The expression involves bindings. We represent such objects using lambda terms. For example, is represented as .
In the algorithm to be considered, -formulas will function as queries and -formulas will constitute a program.
We will present an operational semantics for this language based on . Note that execution alternates between two phases: the goal-reduction phase and the backchaining phase. Following Prolog’s syntax, we assume that names beginning with uppercase letters are quantified by .
Definition 1. Let be a goal and let be a program. Then the notion of executing – – is defined as follows:
% This is a success.
% change to backchaining phase.
In the rules (3) and (7), the symbol will be instantiated by a term. In this context, consider the query . In solving this query, will be formed and eventually solved.
Knowledge representation is traditionally based on the logic of facts, expressed in boolean logic. This paper proposed a new, task logical approach to KR. This approach allows us to build sophisticated KRs about many interesting agents, which have not been supported by previous boolean logical languages.
This paper was supported by Dong-A University Research Fund.
Design and implementation of linear logic programming languages. Ph.D. Dissertation, Kobe University, 2002.
-  Iliano Cervesato, Joshua S. Hodas, and Frank Pfenning. Efficient resource management for linear logic proof search. In Proceedings of the 1996 Workshop on Extensions of Logic Programming, LNAI 1050, pages 67 – 81.
-  Jean-Yves Girard. Linear logic. Theoretical Computer Science, 50:1–102, 1987.
-  Joshus Hodas and Dale Miller. Logic programming in a fragment of intuitionistic linear logic. Journal of Information and Computation, 1994. Invited to a special issue of submission to the 1991 LICS conference.
-  G. Japaridze. The logic of tasks. Annals of Pure and Applied Logic, 117:263–295, 2002.
-  G. Japaridze. Introduction to computability logic. Annals of Pure and Applied Logic, 123:1–99, 2003.
-  G. Japaridze. Sequential operators in computability logic. Information and Computation, vol.206, No.12, pp.1443-1475, 2008.
-  K. Kwon and D. Kang. Extending Logicweb via Hereditary Harrop Formulas. IEICE Transactions on Information and Systems, vol.E91-D, No.6, pp.1827-1829, 2008.
-  D. Miller and G. Nadathur. 1987. A logic programming approach to manipulating formulas and programs. In IEEE Symposium on Logic Programming, S. Haridi, Ed. IEEE Computer Society Press, 379–388.
-  D. Miller and G. Nadathur. 1988. Prolog version 2.7. Distributed in C-Prolog and Quintus Prolog source code.
-  D. Miller and G. Nadathur. 2012. Programming with higher-order logic. Cambridge University Press.