DiscASP: A Graph-based ASP System for Finding Relevant Consistent Concepts with Applications to Conversational Socialbots

Conversational AI has been an active area of research, starting from a rule-based system, such as ELIZA [23] and PARRY [8], to the recent open domain, data driven conversational agents like Amazon’s Alexa [21]. Early rule-based bots were based on just syntax analysis and thus were limited, while the main challenge of modern machine learning (ML) based chatbots is the lack of “understanding” of the dialogs in the conversation. Current machine learning technology-based chat-bots [15] learn patterns in data from large corpora and compute a response without having any semantic understanding of the conversation utterances. Such an approach limits these chatbots, e.g., they may give an irrelevant response or they cannot provide an explanation for their response. We believe that a chatbot that can converse like a human has to employ semantic understanding and reasoning, aside from other AI technologies such as machine learning and natural language processing.

The goal of our research is to develop a conversational socialbot that can hold a conversation with a human stranger on topics of general interest such as movies, books, music, pets, family, etc. Our work is inspired by the Amazon Alexa Socialbot Challenge competition [2, 5] in which the authors’ participated. A realistic socialbot should be able to understand and reason like a human. In human to human conversations, we do not always tell every detail, we expect the listener to fill gaps through their commonsense knowledge. Thus, modeling commonsense knowledge and commonsense reasoning is an important consideration in developing a socialbot.

As is well known, the human thought process is flexible and non-monotonic in nature, which means what we believe now may become false in the future with new knowledge. Given the need for nonmonotonic reasoning, we use Answer Set Programming (ASP) [12] as the underlying formalism for commonsense knowledge representation and reasoning. With the use of (i) default rules, (ii) exceptions to defaults, and (iii) preferences over multiple defaults, one can model bulk of human-style reasoning [12], at least those parts that are needed for realizing a socialbot.

One of the problems that need to be addressed in developing a conversational socialbot is inferring the knowledge “relevant” to the topic at hand. That is, concepts that are consistent with the knowledge we possess about the topic. We call these concepts relevant consistent concepts for that topic. During a conversation about movies, for example, if the other person says that their favorite movie is Titanic, then we immediately will try to recall all the knowledge we possess about that topic. Thus, we may remember that Titanic’s main actors were Leonardo Di Caprio and Kate Winslett, that Titanic got many Academy awards, and that the director of the movie, James Cameron, became very famous. We may then advance the conversation by saying, “Yes, Titanic was a wonderful movie, and it got many Academy Awards.” Social conversations drift from a topic to another related topic. For example, after talking a little bit more about Titanic, the conversation may shift to another movie directed by Titanic’s director James Cameron such as Avatar. Or, it may shift to another movie of one of the actors in Titanic, e.g., Wolf of Wall Street, in which Leonardo Di Caprio was also the lead actor. This knowledge that we recall about Titanic is the relevant consistent concept (RCC) for Titanic. Finding the RCC, given a topic, is an important problem in developing conversational socialbots, as it helps in moving the conversation along. In this paper, we focus on the problem of efficiently finding the RCC($\tau$) for a topic atom $\tau$, given a commonsense knowledgebase coded in ASP. In this paper, we restrict ourselves to conversations about movies, though the approach applies to any domain.

We present an efficient graph-based algorithm for computing the RCC($\tau$) for a topic $\tau$ given relevant commonsense knowledge coded in ASP. The program can only have headless constraints, while constraints realized through odd loop over negation are not permitted. This is done for simplicity: such restricted programs are sufficient for modeling conversational socialbots. Our algorithm computes the set of atoms that represent the concepts that are related to the topic at hand in a given answer set. This set of atoms is computed incrementally, i.e., it is not based on computing the entire answer set. Given a query, we want to not only find out a justification for it, but also the related associated knowledge. E.g., given a query ?- flies(tweety), if we infer that Tweety flies because Tweety is a bird due to the rule flies(X) :- bird(X), not ab_bird(X)., then we also want to know the associated concept that Tweety has wings from the rule haswings(X) :- bird(X). This is very similar to how humans will bring in relevant concepts in their current working memory through a combination of backward and forward chaining.

Our algorithm (called DiscASP) guarantees that the computed partial answer set is part of a complete answer set dictated by the Gelfond-Lifschitz transform [12]. Traditional tools for ASP such as CLINGO [11] are not suitable for this task, as they compute the entire answer set. The entire answer set can be quite large as the amount of commonsense knowledge can be enormous. Even if we restrict ourselves to conversations about movies, the movie database that a socialbot may have to work with will have information about at least 50 movies (assuming that a person can only keep information about that many movies in their head). In reality, this number can be much larger (e.g., the iMDB movie database has more than 7.5 Million entries). In addition, systems such as CLINGO lose all the information connecting two atoms during the grounding process. Thus, explaining the connections as we leap from topic to topic in a conversation is difficult.

Our contribution is twofold: (i) we present an efficient graph-based algorithm for computing a subset of atoms of an answer set that are consistent with, and relevant to, a topic atom present in the answer set. To the best of our knowledge, the algorithm is novel. The algorithm also provides the logical relationship between the topic atom and any other atom in the computed partial answer set based on the commonsense knowledge rules provided; (ii) we present a practical way of solving the important problem of computing the set of relevant consistent concepts for a topic atom while developing conversational socialbots.

Answer set programming (ASP) [19] is a popular nonmonotonic-logic based paradigm for knowledge representation and reasoning and for solving combinatorial problems. Most ASP solvers employ SAT solver-like technology to find these answer sets. As a result, justification for why a literal is in the answer set is hard to produce. Compared to SAT solver based implementations, graph-based implementations of ASP have not been well studied. Graph-based approaches for ASP [3, 16, 17] are well designed, but their graph representations are complex as they all rely on extra information to map the ASP elements to nodes and edges of a graph. In contrast, our approach uses a much simpler graph representation, where nodes represent literals and an edge represents the relationship between the nodes it connects. Since this representation faithfully reflects the causal relationships, it is capable of producing causal justification for goals entailed by the program. In this section, we introduce the background concepts of our novel graph representation.

Conventional dependency graphs are not able to represent ASP programs uniquely. This is due to the inability of dependency graphs to distinguish between non-determinism (multiple rules defining a proposition) and conjunctions (multiple conjunctive sub-goals in the body of a rule) in logic programs. For example, the following two programs have identical dependency graphs (Figure 2).

To make conjunctive relationships representable by dependency graphs, we first transform them slightly to come up with a novel representation method. This new representation method, called conjunction node representation (CNR) graph, uses an artificial conjunction node to represent a conjunction of sub-goals in the body of a rule (Figure 2). The conjunction node (colored in black) refers to the conjunctive relation between the incoming edges from nodes representing sub-goals in the body of a rule. Note that a CNR graph is not a conventional dependency graph.

ASP also allows for special types of rules called constraints. There are two ways to encode constraints: (i) headed constraint where the negated head is called directly or indirectly in the body (e.g., Program 3), and (ii) headless constraints (e.g., Program 4).

Our algorithm models these constraint types separately. For the former one, we just need to apply the CNR-DG transformation directly. Note that the head node connects to the conjunction node both with an in-coming edge and an out-going edge (Figure 4(a)). For the headless constraint, we create a head node with the truth value as False. For simplicity, we currently only permit headless constraints, as these are sufficient to model conversational socialbots.

The reason why we don’t treat a headless constraint the same way as a headed constraint is because in the latter case, if head node (p in Program 3) is provable through another rule, then the headed constraint is inapplicable. Therefore, we cannot simply assign a false value to its head.

We have developed DiscASP, a graph-based algorithm, for finding partial answer sets. The philosophy of DiscASP is to translate an ASP program into a CNR dependency graph, which is always constrained by some constraint rules, then try to satisfy the constraints by assigning presumed truth values to the related nodes, until all constraints have been satisfied. At the same time, DiscASP will propagate truth values of the nodes whose truth value has already been determined. Our graph-based approach performs reasoning in an incremental manner. It starts from the constraints in the answer set program and traces along with causal nodes until it finds support through facts (well-founded case) or it detects a cycle through negation (cyclic case). Our algorithm can be thought of as a more general form of the Galliwasp algorithm for query-driven execution of answer set programs [20]. The DiscASP approach is constraint-driven and thus significantly reduces the search space by avoiding the exploration of worlds that are inconsistent with the constraints. Furthermore, the incremental reasoning from constraints allows DiscASP to perform query-driven execution.

For positive loops, we need to ensure that any models computed are consistent with ASP semantics. Suppose we have a program p :- q. q :- p., under ASP semantics, it will have only one answer set: {p/False, q/False}. The other model ({p/True, q/True}) has to be rejected, as it is not well-founded per ASP semantics. Thus, positive loops have to be handled properly so that only correct answer sets are reported. To detect a loop, DiscASP keeps track of the presumed nodes along the branch, when the current node has been seen previously, we will check whether there exists any False node between these two nodes. If so, it is an even loop, otherwise, it is a positive loop and only the falsifying assignment should be computed.

For disjunctive merging, we will keep the conflicted sub-models along with successfully merged ones. Let’s modify the above example a little bit by presuming the value of node $n$ to be True, and keep everything else unchanged. Now the merging condition becomes disjunctive because one of $p$ or $q$ being False will still make $n$ True. Since $p_{1}$ and $q_{1}$ can be merged without conflict, we replace them with their union {a/True, c/True, d/True, b/False}. But this time we don’t discard $p_{2}$, because $p_{2}$ is also a valid model that makes $n$ True. Therefore, after this merging, we will have two sub-models for $n$ being True: {{a/True, c/True, d/True, b/False}, {a/False, b/True}}.

DiscASP propagates truth values every time a presumed node value has been established, by using a causal map that covers all of the causal relationships for each node/value. When a presumed node/value is established, DiscASP will check whether there is any other node whose value can be inferred from current node assignments. If there are any, the inferred value is assigned to that node and propagation continues until the model does not change.

For query handling, DiscASP negates the query literal and appends it to the ASP program as an additional constraint. So for the above example, the query $p/True$ will be converted to a constraint rule :- not p. and added to the original program. So the program will now be p :- not q. q :- not p. :- p, q. :- not p.

DiscASP begins its reasoning from a constraint node (typically, the query represented as a constraint), then searches for a partial answer set to satisfy the constraint.

In some application scenarios, finding the whole answer sets may be overkill or impractical. Especially for commonsense reasoning, where the knowledgebases may be large and guaranteeing consistency may be hard as parts of the knowledgebase were constructed separately. If a subset of the knoweldgebase that contains the answer we are seeking is consistent, we may not care about other inconsistent part of the knowledgebase.

For a socialbot to hold such casual conversations with a human, it needs to figure out the knowledge related to a topic (represented as a propositional atom, e.g., like(john, titanic)). We term the conceptual knowledge related to a topic $\tau$ as relevant consistent concepts (RCC) of $\tau$. These concepts are inferred by humans from commonsense rules that they learn over time, for example, we might learn that normally, a person who likes a movie, will also like the actors in the movie. Thus, if we know that John likes Titanic, we infer that very likely, he likes Leonardo Di Caprio, the lead actor, too.

In DiscASP, if a dependency sub-graph is disconnected to a query related to a topic $\tau$, then for obvious reasons, the atoms in this sub-graph do not have to be considered at all to compute the RCC($\tau$) set. Given a query for a topic $\tau$, we only need to verify its validity and find out its related consistent concepts. As discussed (Section 3), DiscASP guarantees the following property: given an answer set program P, if P has an answer set, then any partial answer set computed by DiscASP will be a subset of a complete answer set of P.

DiscASP is designed as a system that finds partial stable models for a given topic with respect to a specific knowledgebase coded in ASP. The knowledgebase will be encoded as propositional logic facts and will contain both generic data that is collected from data sources, e.g., iMDB movie database, user profiles, etc., as well as commonsense knowledge rules that capture the knowledge of the domain. These facts and rules are expressed in ASP. The commonsense rules are grounded using the GRINGO grounding system [11]. Since DiscASP is a graph based ASP solver, we need to transform the grounded program into a CNR dependency graph as discussed earlier. While building this graph, the topic query, Q, will also be added as the constraint (:- not Q.). Then the dependency graph will be passed to the partial answer set solver, which computes partial stable models. The DiscASP algorithm is quite simple: it starts with the constraint introduced by the query (:- not Q.) and finds the smallest model, M, that ensures that the constraint holds. If there are atoms in M that also involve other constraints, then the DiscASP algorithm ensures that these constraints are also satisfied. The partial model found is the relevant consistent concept (RCC) set of Q.

We use the talk_preference/3 predicate to capture the attribute A, that the socialbot can talk about next, regarding a movie M, given a user P. For example, people prefer to talk about an actor of a movie if he/she is the main actor, a famous actor or an Oscar winning actor. Also, normally, people like to talk about a movie’s awards, awards to actors in the movie, or trivia about a movie. Note that these default rules include exceptions, for example, to capture the situation that whenever the socialbot is done talking about an attribute it adds it to its exception list so as to not talk about it again in the same conversation. The ab_talk_preference/3 predicate models these exceptional situations (in the code below, the user John has already talked about the movie Avatar).

$\{$talk_preference(john,titanic,trivia), talk_preference(john,titanic,awards),

talk_preference(john,titanic,leonardo_dicaprio)$\}$

Note that if we pick, for example, talk_preference(john,leonardo_di_caprio) then the fact already_discussed(john, titanic,leonardo_di_caprio) will be added to our database. When the RCC is computed for the next utterance, we will not pick the topic talk_preference(john, titanic, leonardo_di_caprio) for advancing the conversation.

The CNR Dependency Graph and our DiscASP algorithm have a number of advantages: (i) partial answer set can be incrementally computed to find the RCC set; the chain of reasoning that connects one concept atom in the answer set to another can be found with no additional costs; this is in contrast to other methods such as CLINGO, where the entire answer set has to be computed, and Galliwasp, where atoms related to proving a query only can be found. (ii) Declarative Knowledge: The DiscASP algorithm allows knowledge in a conversational socialbot to be represented declaratively as an answer set program, considerably reducing the complexity of the project. (iii) A better representation for Knowledge Graph: The CNR dependency graph provides a better representation for a knowledge graph, as it can account for exceptions and preferences as well. Traditional knowledge graphs such as ConceptNet [18] and Microsoft Knowledge Graph [24] represent knowledge by connecting words through relations and providing an ontology; they cannot represent exceptions and preferences. Thus, knowledge is inconsistent and wrong conclusions (such as “penguins can fly”) can be drawn.

Logic programming has been used in the past for developing chatbots. Tarau and Figa [10] represent domain knowledge with propositional clauses in Prolog and find answers via using goal driven queries. Also, Tarau et al. [22] explored the use of dependency graphs with lexical knowledge and TextRank algorithm to give the most relevant answers given a query. In recent times, most chatbots are developed using machine-learning technology [15]. Researchers have developed many dialog datasets to train and test the language models, such as SwitchBoard corpus [13], bAbI dialog dataset [6], etc.

These systems that are built with deep learning techniques learn the patterns of the training text remarkably well and show promising results on test data. With the recent advancements in the language model research, the pre-trained models such as BERT [9] and GPT-3 [7] show outstanding capability in generating natural language responses. Using these language models people have also developed techniques to build conversational chatbots, such as PD-NRG (policy driven neural response generator) [14]. While these tools and techniques based on machine learning and deep learning are very impressive, they are based on syntactic and contextual pattern matching. They produce absolutely no understanding of the knowledge contained in the text. They utterly fail when any type of reasoning is required. Their black-box nature also precludes them from explaining their responses.

There are also systems, such as StaCACK [4], based on ASP that not only outperform the neural-models in accuracy on the bAbI-dialog dataset but also show natural language justification for each of its answers. Our conversational socialbot application using DiscASP is another step forward toward mimicking the human reasoning process in intelligent systems. We believe that, to obtain truly intelligent behavior, machine learning and commonsense reasoning should work in tandem.

We proposed a dependency graph based algorithm called DiscASP to compute the atoms of an answer set that are related to a query atom within a fixed “causal distance”. We used a novel transformation to ensure that each program has a unique dependency graph, as otherwise multiple programs can have the same dependency graph. A major advantage of our algorithm is that it can produce a justification for any proposition that is entailed by a program. Currently, DiscASP only works for propositional answer set programs. Our goal is to extend it so that answer sets of datalog programs can also be computed without having to ground them first. This will be achieved by dynamically propagating bindings along the edges connecting the nodes in our algorithm’s propagation phase. Thus, DiscASP will help us pave the way for finding answer sets efficiently without grounding the program first. The DiscASP algorithm is quite efficient and has been applied to practical problems such as developing conversational socialbots.

We described a real-world application of DiscASP to developing conversational socialbots. We showed how commonsense knowledge about holding a conversation about movies can be coded as an answer set program. We showed how atoms that are relevant to advancing a conversation given a topic can be found using the DiscASP algorithm. Future work includes incorporating knowledge about other social topics such as books, movies, sports, family, pets, etc., to realize a full-fledged socialbot using ASP technology. Current technology for developing socialbots is primarily based on machine learning. An effective socialbot can only be built if the socialbot “understands” the utterances of the human user and can reason about them. Thus, knowledge-based approaches such as those based on ASP are crucial for developing conversational socialbots.