Reasoning for Moving Blocks Problem: Formal Representation and Implementation

07/28/2013
by   P. A. Wałȩga, et al.
0

The combined approach of the Qualitative Reasoning and Probabilistic Functions for the knowledge representation is proposed. The method aims at represent uncertain, qualitative knowledge that is essential for the moving blocks task's execution. The attempt to formalize the commonsense knowledge is performed with the Situation Calculus language for reasoning and robot's beliefs representation. The method is implemented in the Prolog programming language and tested for a specific simulated scenario. In most cases the implementation enables us to solve a given task, i.e., move blocks to desired positions. The example of robot's reasoning and main parts of the implemented program's code are presented.

READ FULL TEXT VIEW PDF

page 1

page 2

page 3

page 4

11/15/2019

Fine-grained Qualitative Spatial Reasoning about Point Positions

The ability to persist in the spacial environment is, not only in the ro...
05/19/2017

RankPL: A Qualitative Probabilistic Programming Language

In this paper we introduce RankPL, a modeling language that can be thoug...
02/19/2022

A Probabilistic Programming Idiom for Active Knowledge Search

In this paper, we derive and implement a probabilistic programming idiom...
07/11/2012

A Logic Programming Framework for Possibilistic Argumentation with Vague Knowledge

Defeasible argumentation frameworks have evolved to become a sound setti...
05/05/2014

KR^3: An Architecture for Knowledge Representation and Reasoning in Robotics

This paper describes an architecture that combines the complementary str...
04/19/2018

A Trajectory Calculus for Qualitative Spatial Reasoning Using Answer Set Programming

Spatial information is often expressed using qualitative terms such as n...
06/28/2021

Modeling and Reasoning in Event Calculus using Goal-Directed Constraint Answer Set Programming

Automated commonsense reasoning is essential for building human-like AI ...

1 Introduction

Reasoning algorithms that may represent incomplete and uncertain knowledge are greatly needful in a number of robotic applications, where the exact information is hardly available. In such cases, the probabilistic reasoning methods are mostly in use because of their ability to model uncertain knowledge and cognitive agent’s beliefs. In parallel, there are also many attempts to develop qualitative approaches inspired by the human way of interpreting the surrounding world. Such methods allow to model imprecise and uncertain information, vary the grain of the reasoning, eliminate information overload, and fasten program execution (see [Forbus1] and [Forbus2] for details). The qualitative approach is still being explored, therefore a number of new methods are lately developed as presented in [bhatt], [PDL], [jgp], and [Belief], among others.

The proposed approach is a combination of both approaches: Qualitative Reasoning and Probabilistic Functions. The developed method for beliefs’ representation is universal but was implemented and tested for a specific scenario in which the robot’s task is to move cubic blocks in order to obtain the goal configuration using qualitative reasoning methods, with no numerical, quantitative information. One of the main advantages of the approach is the formal language that describes the robot’s knowledge as a set of different, often inconsistent, beliefs. The formalism is based on the second order Situation Calculus language ([Handbook], [Reiter]) that was established in order to reason about actions and change. The main concepts to be used are:

  • Actions that may change the world features,

  • Situations which are possible states of the world that are in fact sequences of actions, called histories of the world,

  • Fluents that describe features of a specified situation.

In the Situation Calculus language the initial situation is an empty sequence of actions. The binary function symbol do maps a pair , for an action and a situation , to a successor situation obtained by performing to . For example, the situation that occurs after performance of an action in the initial situation , followed by and once more, is denoted by . Actions are usually parametrized, e.g., moving a block from a column to the top of a column may be represented as an expression , where is a binary function symbol. The situation that results from moving block from a column to a column , and then moving it back from to is denoted by . Fluents may be functional or relational, but we will use only functional fluents that return values describing the world’s features in a specified situation. For instance, the robot’s belief that a column is large in a situation can be represented as the functional fluent whose value describes a degree of the robot’s belief. In our approach robot’s beliefs about columns of blocks are described with qualities , , , and

, although values of the corresponding functional fluents are expressed in terms of probability. Therefore, we develop a reasoning method that is based on the probabilistic approach. Furthermore, since the similarity to fuzzy logic was observed, the idea of triangular membership functions is used (see

[Fuzzy]

). The proposed approach is not only developed but also implemented in the Prolog declarative programming language, which is often used to model artificial intelligence methods

[Bratko]. Therefore, it may be tested and the performance quality may be measured in different simulated situations.

Most significant observed advantages of the proposed approach are: scalability feature, incomplete and uncertain knowledge representation, reasoning without strictly numerical information. Mentioned pros are essential for those robotic systems that need to work in the unknown environment or have information that is not enough precise to reason with classical quantitative methods. On the other hand, since the probabilistic reasoning algorithms are implemented in order to model the uncertainty, in some cases the robot possesses incorrect beliefs and is unable to complete the given task. Although the disadvantages cannot be ignored, the developed method has a number of significant features that are crucial for robotic application.

The paper is organized as follows. In Section 2 the formal approach of representing beliefs, its language and axioms are introduced. Afterwards, solutions to the Qualification Problem and the Frame Problem are proposed. In Section 3 a brief breakdown of the Prolog implementation is shown. Three systems performance tests that present correct and faulty functionality are shown in Section 4. Finally, conclusions and future work plans are presented in Section 5.

2 The formal beliefs’ representation in the Situation Calculus with probabilistic functions

A specific scenario consists of a plane table with cubic blocks situated on its surface and the robot located in front of them. Separate columns are formed with blocks that are put on the top of each other as shown in Fig. 1.

Figure 1: The basic scenario setup.

The robot is equipped with an arm that can grab and move individual objects. At the beginning, blocks are placed on the table in the requested configuration which constitutes a goal setup. The robot observes the configuration and keeps its pure qualitative representation in mind. Afterwards, blocks are shuffled and a new configuration called an initial state is shown to the robot. The system’s task is to observe the given configuration and plan the actions’ sequence that will bring back the goal configuration i.e. in the final configuration height of each column will be the same as in the goal configuration. Predicates that are used for beliefs’ description and reasoning procedure express qualitative (symbolic) information e.g. ”column 1 is large”. Therefore, the exact number of blocks in columns is unknown for the robot. Furthermore, since observations take place only twice – when the goal and the initial states are presented – the robot cannot check effects of performed actions.

The Situation Calculus formal approach is used in order to describe changes of robot’s beliefs. The adapted second order language consists of the following alphabet:

  • Standard logical symbols: , , ,

  • Individual variables: for actions, for situations, for columns made of blocks,

  • Constants , , , and to represent qualitative values,

  • Function symbols for situations: the initial situation and a binary function symbol , whose value , for an action and a situation , represents a situation that results from applying an action in situation ,

  • The binary predicate symbol for an ordering relation on situations (transitive, irreflexive, and asymmetric); means that in a situation performance of at least one action may lead to a situation ; a binary predicate symbol is defined as usual: iff or ,

  • The binary predicate symbol ; represents a possibility to perform an action in a situation ,

  • The unary predicate symbol for a situation independent relation; represents the fact that is a column,

  • The binary function symbol for a move action; means that the top block from a column is moved to the top of a column ,

  • Binary function symbols for functional fluents. Fluents describing agent’s beliefs – , , , and – map a pair to a value from the interval interpreted as a degree of robot’s belief; means that in situation the robot has a strong belief (with a degree of 0.9) that a column 2 is . Other fluents are used in order to describe the goal situation – – and main agent’s beliefs – . Both of them are defined on pairs and return one of the qualitative values: , , , or , e.g. means that in situation the robot’s goal is to construct a column 2 that will and means that in situation the robot’s main believe about a column 2 is that it’s .

The initial situation denotes the robot’s beliefs and goals that were given to him at the beginning of the scenario. Performing different actions (that are in fact -actions done by the robot) leads to different situations, namely different agent’s belief states. A demonstrative tree of situations graph is presented in Fig. 2.

Figure 2: A tree of situations graph.

The robot’s task is to find a sequence of actions that leads to a situation in which his beliefs are equal to the given goals, thus to a situation in which holds for all . If it is impossible to find such a path, then the robot’s solution should bring him to the closest situation to the given goal. Fundamental axioms of the approach are shown in Fig. 3.

For all actions and situations :

(existence of a predecessor)
(transitivity of )
(irreflexivity of )
(asymmetry of )
Figure 3: Fundamental axioms of the Situation Calculus.

The main idea of our method is to represent agent’s beliefs in terms of the combined means: the qualitative and probabilistic (quasi-fuzzy) ones. Therefore, specific functional fluents for robot’s beliefs are implemented. They return floating point numbers from the interval that are treated as a degree of the belief, where means the weakest belief and the strongest one. In the case of inconsistent beliefs occurrence – such as ”column is large” and ”column is small” with the same degree of belief – an additional, main agent’s belief fluent with an argument is implemented. It may return one of the qualitative values: , , , or .

The most desired situation occurs when values of belief fluents change triangular membership functions known from the fuzzy logic (see [Fuzzy]), i.e., the increase of some belief function value leads to the reduction of the ”nearest belief function” value, where the ”nearest belief function” corresponds to the next most probable state to occur. In Fig. 4 we present an example, where the number of blocks in a column affects on agent’s beliefs, namely , , , . Thus, adding the 9th block to the column increases a belief that this column is large and decreases a belief that it is medium.

Figure 4: Triangular membership functions for states of beliefs.

Researches on the qualitative modelling and reasoning indicate that a pure qualitative approach is usually impractical and impossible to be implemented. Programmable methods used in the Qualitative Reasoning usually make use of a quantitative approach at least on some basic level. Although such implementations are more natural and intuitive due to usage of qualitative methods, numerical values still cannot be omitted and, as a consequence, hybrid approaches are most applicable. The proposed approach should be treated as such a hybrid method, since it combines qualitative and quantitative methods. Belief fluents refer to qualities such as ”column is large”, ”column is small”, whereas values of functional fluents are expressed with the quantitative probabilistic description. An action performance results with the belief fluents value changes which are precisely and numerically defined.

One of the most desired feature of qualitative systems is the scalability (see [Forbus1] for details). Not only the quantization needs to be relevant to the problem but also the ability of changing the grain of the reasoning should be provided. The fulfillment of such a constraint allows to change the modelling precision and is called scalability. The proposed method provides such a feature, as the number of qualities and a degree of actions’ influence on numerical fluents’ values may be freely changed. The more qualities are, the more precise modelling becomes.

There are three fundamental problems in the reasoning about actions: the Qualification Problem, the Frame Problem and the Ramification Problem. In order to exploit the Situation Calculus formal language all of them need to be considered and solutions for them ought to be proposed.

The Qualification Problem states that it is impossible to define all preconditions of an action. As a result, no inference of the form about executable actions in a particular situation may be obtained. In order to explain the problem clearly and formally, let us consider an example in which the system contains the axiom (1) of the form:

(1)

It means that if it is possible for the robot to move a block from a column to a column in a situation , then and are columns and the robot believes that there are at least some blocks on the column . Unfortunately, the reverse implication that is:

(2)

is false. Hence, it is impossible to infer when a move action is executable. The condition (2) is unacceptable, since it may be impossible to perform a move action, for instance, when the top block on a column may be glued to the table or too heavy to be picked up by the robot. The number of such qualifications in a complex domain is extremely large, so it is obviously impossible to specify all of them. The preferable solution to the problem is to specify only important preconditions which are directly connected to an action’s execution and ignore minor ones (until they arise). In most cases defining all preconditions is impractical or even impossible, whereas the presented solution allows to overcome both implementation and logical problems.

The Frame Problem concerns unchanged fluents after action’s performance. A great number of such frame axioms need to be declared (their number is equal to the number of actions multiplied by the number of fluents). For instance, the axiom (3) states that moving one block from a column to a column does not affect the agent’s main belief about the other column .

(3)

The solution that was chosen is to assume that fluents may change only due to defined actions and no unknown effect may occur. That kind of solution is the simplest one, nevertheless it is good enough for the developed approach.

The Qualification Problem is about indirect effects that are caused by actions performance e.g. moving the bottom block from a particular column leads to change of upper blocks position. A number of such effects cannot be provided, and may occur in some specific situations. Defining every single indirect effect is unreasonable and usually impossible. Therefore, our solution is to define a list of causal laws that describe indirect effects that occur when specific conditions are fulfilled. Summing up, direct effect are specified and additional causal laws for computing indirect effect are provided.

3 The implementation

The implementation of the described scenario is done with the Prolog environment. Additionally, the IndiGolog [Indigolog] – an agent architecture with the Situation Calculus implementation, completely programmed in Prolog – is used. It provides all elements of the Situation Calculus language and common programming structures like ”if” condition and the ”while” loop. The whole reasoning module is fully implemented in the IndiGolog architecture. Now, we will present and describe its parts.

Constants. The only constants used in the program are columns numbers. The example presented in Fig. 5 corresponds to the blocks’ configuration shown in Fig. 1. It consists of five columns, where the expression means that is a column.

  col(N)     :-    N=1; N=2; N=3; N=4; N=5.
Figure 5: Constants represent numbers of columns.

Actions. There is a single group of actions that may be performed by the robot for instance, moving the top block from a column and putting it on the top of a column . The Prolog definition is presented in Fig. 6.

  prim_action(move(X,Y))     :-    col(X),col(Y).
Figure 6: Action .

Fluents. One of the functional fluents describes the goal configuration to be achieved. It may return any quality available for a specified column. Other functional fluents denote beliefs’ states of the robotic agent. The fluent returns a degree of a belief that a column is large in a current state and it remains in the interval as described in Section 2. The program code depicted in Fig. 7 shows additional three fluents: , , and . They play the analogous role as . One more functional fluent – – is used to denote the most probable state of column according to the robotic agent’s knowledge. No relational fluents have been used.

  prim_fluent(large(N))     :-    col(N).
  prim_fluent(medium(N))    :-    col(N).
  prim_fluent(small(N))     :-    col(N).
  prim_fluent(zero(N))      :-    col(N).
  prim_fluent(goal(N))      :-    col(N).
  prim_fluent(believe(N))   :-    col(N).
Figure 7: Functional fluents.

Causal laws. The actions’ influence on fluents’ values has been described by making use of fixed laws. In fact, since values of fluents denote agent’s beliefs, causal laws expose the actions’ influence on the robot’s beliefs. Every action changes robot’s beliefs about the height of columns and , namely, column is believed to decrease and column to increase. Depending on earlier beliefs about and height, different causal laws are to occur.

A short part of causal laws section is presented in the program code in Fig. 8. It describes how agent’s beliefs change when a block from a column is taken, if was believed to be large so far. The probabilistic value of the functional fluent decreases and the value of the fluent increases. Furthermore, if the value of becomes greater than (or equivalently, greater than the value of fluent ), then the agent will believe that the column is medium rather than large.

  causal_val(move(X,_),large(X),N,and(N is large(X)-0.25,large(X)>0.0)).
  causal_val(move(X,_),medium(X),N,and(N is medium(X)+0.25,large(X)>0.0)).
  causal_val(move(X,_),believe(X),medium,and((medium(X)+0.25)>0.5,large(X)>0.0)).
Figure 8: Examples of causal laws.

Preconditions. The action is executable when a column is not empty (see Fig. 9). It is worth noting that this precondition is constituted with respect to the robot’s knowledge. Therefore, if the agent’s beliefs are incorrect, he may try to take a block from an empty column.

  poss(move(X,_))     :-    neg(believe(X)=zero) ).
Figure 9: An example of a precondition.

Belief functional fluents and the change of their values play the most significant role in our approach. Now, we will provide an illustrative example and its detailed description. Table 1 presents agent’s qualitative belief states with respect to the precise number of blocks in a column . As we mentioned in Section 2, the proposed approach uses a scalability feature. In our case there are four qualities, namely , , , and . denotes any column whose number of blocks is in the interval . Similarly, , , and denote any column whose number of blocks is in the interval , and zero, respectively (see the top two ranks of Table 1). There are four main agent’s belief fluents related to a column , i.e., , , , and . Thus, if in the initial situation shown to the agent the column has 11 blocks and he recognizes the column as large, then his initial beliefs should be as follows: , , , and (see the third column of Table 1). Performing an action , i.e., taking the top block from a column and placing it somewhere else, results in a change of belief fluents’ values. The magnitude of such a change depends on the granularity of qualities and equals . In our case the granularity equals , so the magnitude is . If one block from a column is moved, then decreases, while increases. Thus, the final agent’s beliefs should be: , , , (see the fourth column of Table 1). In a similar way, further -actions change the agent’s beliefs as illustrated in Table 1.

Qualities Blocks in col. 12 11 10 9 8 7 6 5 4 3 2 1 0 1 0.75 0.5 0.25 0.25 0.5 0.75 1 0.75 0.5 0.25 0.25 0.5 0.75 1 0.75 0.5 0.25 0.25 0.5 0.75
Table 1: Belief fluents table for 11 blocks in the initial state.

The initial blocks setup has a significant meaning for the whole reasoning process. Table 2 shows values of belief fluents for four different initial setups, namely with 12 blocks, 11 blocks, 10 blocks, and 9 blocks in . Although in all these cases the robot qualifies as large, further inferences about its height are different, and even in some cases reasoning leads to false beliefs.

Qualities Blocks in col. 12 11 10 9 8 7 6 5 4 3 2 1 0 1 0.75 0.5 0.25 0.25 0.5 0.75 1 0.75 0.5 0.25 0.25 0.5 0.75 1 0.75 0.5 0.25 0.25 0.5 0.75 1 1 0.75 0.5 0.25 0.25 0.5 0.75 1 0.75 0.5 0.25 0.25 0.5 0.75 1 0.75 0.5 0.25 0.25 0.5 0.75 1 0.75 0.5 0.25 0.25 0.5 0.75 1 0.75 0.5 0.25 0.25 0.5 0.75 1 0.75 0.5 0.25 0.5 1 0.75 0.5 0.25 0.25 0.5 0.75 1 0.75 0.5 0.25 0.25 0.5 0.75 1 0.75 0.25
Table 2: Belief fluents table for four different initial states.

4 Performance tests

A number of tests for different initial and goal configurations were performed. The same scenario as a described one in Section 2 was simulated, i.e, there were five columns made of blocks and four qualities, namely , , , and . When the initial situation is shown to the robot, he assigns a quality value to each column and keeps in mind only such a qualitative representation. Therefore, the first column with 8 blocks in one initial situation and with 5 blocks in another initial situation is represented by the robot in both these cases in the same way, namely as a column. This kind of system’s behaviour may lead to mistaken reasoning and inability to complete a given task. Now, we present three different simulations, namely a goal achievement in a well established initial situation, a goal achievement in a borderline initial situation, and an inability to complete a given goal in a specific borderline initial situation.

Table 3 shows a goal achievement simulation. Initial situation is well established for every column, which means that no borderline values are to be used. Borderline numbers of blocks in a column are 5 and 8, since denotes any column whose number of blocks is in the interval . System’s behaviour presented in Table 3 leads to the goal achievement for every column. Another goal achievement simulation is presented in Table 4. Borderline numbers of blocks are established in order to make the goal achievement more difficult. Nevertheless, the given task is completed and no mistakes in blocks configuration for every column occur. At last in Table 5 a simulation, in which the goal is not achieved is presented. The robot obtains a goal for columns 2, 3, 4, and 5, but failed to place blocks in the first column properly. He believes that the final number of blocks in the first column that consists of 8 blocks corresponds to the quality but in fact it corresponds to the quality. The robot’s belief is incorrect, and therefore, the goal is not achieved. However, occasional mistakes cannot be eliminated as only the qualitative representation and not a quantitative exact number of block in each column is known to the robot.

Columns 1 2 3 4 5 Initially blocks in col. 7 2 0 11 6 Assigned qualities in initial sit. Goal Finally blocks in col. 4 3 8 8 3 Goal achievement yes yes yes yes yes
Table 3: Goal achievement in a well established initial situation.
Columns 1 2 3 4 5 Initially blocks in col. 12 8 4 9 0 Assigned qualities in initial sit. Goal Finally blocks in col. 7 7 11 5 3 Goal achievement yes yes yes yes yes
Table 4: Goal achievement in a borderline initial situation.
Columns 1 2 3 4 5 Initially blocks in col. 5 3 0 7 10 Assigned qualities in initial sit. Goal Finally blocks in col. 8 0 3 4 10 Goal achievement no yes yes yes yes
Table 5: Inability to complete a given goal.

5 Conclusion and future work

The combined method for reasoning about actions and robot’s beliefs has been presented. The approach is implemented in the Prolog declarative programming language, therefore the method may be tested and modified. The main advantages of the presented approach are: scalability feature, formal language usage, incomplete and uncertain knowledge representation, qualitative reasoning without strictly numerical information. The mentioned features are essential for robotic application which cannot use the quantitative, numerical methods of reasoning. Such situations are common and occur in an unknown environment, when sensors are not able to return precise information or in cases when the reasoning need to be achieved quickly and classical numerical methods need too much time (or too much computational power). The method was implemented for the moving blocks problem, but since more fluents and rules of reasoning might be easily defined, this method can be used for other problems as well.

The future work consists of the reasoning system’s extension for further robotic applications, for instance, for the qualitative representation of moving objects in general and qualitative methods of detection. Another idea is to exploit a method for systems where no certain knowledge may be achieved, e.g., when the gain of information always contains a noise that cannot be filtered. The implementation for the real robot and not only simulated one is also taken into consideration. Additionally, the usage of the ExpCog framework [expcog] that has been established in order to integrate different robot reasoning approaches is planned.

Acknowledgments

The work presented in this paper is supported by the Polish National Science Centre grant 2011/02/A/HS1/00395. The author would like to thank Joanna Golińska – Pilarek for her valuable criticism and members of the ExpCog project, namely: Mehul Bhatt, Jakob Suchan, Maciej Przybylski for a great chance to work with their ExpCog framework.

References

  • [1] V. Bos and S. Mauw (2002-06) A LaTeX macro package for message sequence charts—maintenance document—describing version . Note: Included in MSC macro package distribution
  • [2] V. Bos and S. Mauw (2002-06) A LaTeX macro package for message sequence charts—reference manual—describing version . Note: Included in MSC macro package distribution
  • [3] V. Bos and S. Mauw (2002-06) A LaTeX macro package for message sequence charts—user manual—describing version . Note: Included in MSC macro package distribution
  • [4] M. Goossens, S. Rahtz, and F. Mittelbach (1997) The LaTeX Graphics Companion. Addison-Wesley.
  • [5] ITU-TS (1997) ITU-TS Recommendation Z.120: Message Sequence Chart (MSC). Geneva.
  • [6] L. Lamport (1994) LaTeX—a document preparation system—user’s guide and reference manual. 2nd edition, Adsison-Wesley. Note: Updated for LaTeX2e
  • [7] E. Rudolph, P.Graubmann, and J. Grabowski (1996) Tutorial on message sequence charts (MSC’96). In FORTE,