This document describes a commonsense question answering system that uses conceptual graphs for knowledge representation and reasoning. It uses several state-of-the-art NLP and knowledge representation tools including C&C Tools for parsing natural language into conceptual graph interchange format (CGIF), Cogitant for conceptual graph operations, and OpenCyc for commonsense knowledge. The system converts natural language sentences into conceptual graphs, uses commonsense rules from OpenCyc to augment the graphs, and can answer questions by querying the graph knowledge base. Future work includes improving the system with probabilistic reasoning and rule induction capabilities.

1. Natural Intelligence -
Commonsense Question Answering
with Conceptual Graphs
Fatih Mehmet Güler and Aysenur Birturk
Department of Computer Engineering, METU
06531, Ankara/TURKEY
fmguler@gmail.com
birturk@ceng.metu.edu.tr

2. Motivation
 Massive Knowledge found as Natural Language
 Text based Question Answering (no tagging)
 Open Domain Question Answering
 Address Commonsense Reasoning Problem
 Linguistically motivated KRR
 Intelligence is the accumulation of knowledge
 Integrate State of the Art Tools
 Ultimate goal: Getting closer to strong AI

3. Summary of the System
 Natural Language is parsed
 Utterances are represented using CGs
 Concepts and Relation types are mapped to
Cyc equivalent counterparts
 Type hierarchies are computed
 Knowledge is accumulated
 If the input is a question
 Search for answer (projection)

4. Summary of the System (Cont’d)
NI
NLP KRR Commonsense
CCG CGs Open Cyc
C&C Tools Cogitant

5. Background
 Combinatory Categorial Grammar (CCG)
 C&C Tools
 Conceptual Graphs
 Cogitant
 Open Cyc

6. Combinatory Categorial Grammar (CCG)
 Lexicalized Theory of Grammar based on
Categorial Grammar ( Steedman 2001).
 Functions can be applied or composed
 Arguments can be picked up or turned into
functors (Type raising)
 Easy for Semantic Representations
 Small number of semantically transparent
combinatory rules to combine CCG categories.
 Assign semantic representations to the lexical entries
 Interpret combinatory rules

7. CCG parse for “Mr. Hyde ate two
lemmons”

8. CCG Parse for “Susan knows that Bob
likes Fred”

9. DRS for “Susan knows that Bob likes
Fred”

10. C&C Tools
 Linguistically Motivated Large-Scale NLP with C&C
and Boxer. (Curran, Clark, Bos, 2007)
 C&C Parser
 POS Tagging, Supertagging
 Parsing, Chunking
 Named Entity Recognition
 Boxer
 Uses CCG parser output
 Generates DRS Semantic Representations
 Freely available for research
 http://svn.ask.it.usyd.edu.au/trac/candc/wiki

11. C&C Tools
 Large Scale NLP is possible with C&C and
Boxer
 C&C Parser: state of the art parser for CCG
 Boxer: Semantic representations in DRS

12. Open Cyc
 Open source version of Cyc system
 Cyc: greatest effort to encode Common Sense
knowledge in machine processable way
 500.000 concepts 26.000 relations and 5.000.000
assertions
 CycL language similar to Lisp
 We use Cyc to map parsed words to common sense
counterparts such as person to #$Person
(disambiguation)

13. Open Cyc (cont’d)
 (#$likesAsFriend #$GeorgeWBush #$AlGore)
 #$isa, #$genls
 (#$isa #$GeorgeWBush
#$UnitedStatesPresident)
 (#$genls #$UnitedStatesPresident #$Person)

14. Cogitant
 Library for Conceptual Graph operations
 Supports broad CG operations (Genest &
Salvat, 1998)
 Graph representation
 Conversion from CGIF
 Projection checking
 Rule application

15. Natural Intelligence – Commonsense
Question Answering with CGs
 Augment Common Sense knowledge
 Modular Approach
 Separation of Concerns
 State of the art tools

16. Architecture - Modules
 Natural Language Processing (C&C Tools are used
for implementation)
 Convert natural language to CGIF
 Reasoning (Cogitant library is used for
implementation)
 CG operations
 Common Sense (Open Cyc is used for
implementation)
 Common sense mapping
 Storage (Conceptual Graphs are stored in a
database)
 Persistence of CGs

17. System Definition
 User enters a sentence from web interface;
 This sentence is converted to CGIF using the NLP module;
 CGIF is converted to CGs using the reasoning module;
 Support is generated to CGs using the common sense module;
 Common sense rules gathered from common sense module are
applied to CGs using reasoning module;
 CGs are merged to the previous ones using reasoning module;
 If the input sentence is a question sentence, same operations
take place, except the resulting graph is used to query existing
CGs using the reasoning service, and if there are projections
from this query graph to previous CGs, results are displayed to
the user;
 CGs are persisted using the storage module.

18. Common Sense Mapping
 Cyc: (prettyString TERM STRING)
 Chain up to #$Thing using #$genls relations
 Same for relations using #$genlPreds
 Relation hierarchies are converted to forward
rules
 #$performedBy -> #$temporallyRelated

19. Sample Concept Hierarchy
 #$Place ->
 #$EnduringThing-Localized ->
 #$Location-Underspecified ->
 #$Thing ->
 #$SomethingExisting ->
 #$Individual ->
 #$Thing ^^
 #$Trajector-Underspecified ->
 #$Location-Underspecified ^^
 #$TemporallyExistingThing ->
 #$TemporalThing ->
 #$Individual ^^
 #$SpatialThing-Localized ->
 #$TemporallyExistingThing ^^
 #$SpatialThing ->
 #$Individual ^^
 #$Boundary-Underspecified ->
 #$Region-Underspecified ->
 #$Location-Underspecified ^^
 #$Landmark-Underspecified ->
 #$Individual ^^
 #$Location-Underspecified ^^
 #$SpatialThing-NonSituational ->
 #$SpatialThing ^^
 #$Individual ^^
 #$Location-Underspecified ^^

20. Conversion to Cogitant Support
 Convert Cyc hierarcy to Cogitant support
format
 Concept Types
 Relation Types
 Individuals
 Rules
 Convert assertions to Cogitant graph format
 Apply forward rules

21. Answering Queries

22. Significance
 Sentences like;
 What are the intangible things in this situation?
 Was Mr. Hyde there while eating the apples?
 Does Mr. Hyde exist after eating the apples?
 Do the apples exist after Mr. Hyde ate them?
 Deep Natural Language Understanding
 State of the art tools
 Open domain question answering

23. Difficulties
 Open Cyc API is broken
 Does not work in Turkish locale (fixes are sent to
maintainers)
 Still, provided API sends one IP packet per character, way
too slow over network
 Custom socket API is developed and used over TCP
 Custom Lisp functions for generalization hierarchy and
concept mapping
 Cogitant problematic
 Java API is very limited (compared to C++)
 Only works over XML files

24. Conclusion
 Central Integrated Common Sense QAS
 CCG for Natural Language Processing
 Conceptual Graphs for KRR
 Cyc for Common Sense

25. Future Work
 Implement Rule Induction
 Backward Chaining (Resolution)
 Improve NLP module and Common Sense mapping
 Probabilistic Reasoning
 Question Answering System (QAS) to be used in;
 Education (Learning Management Systems)
 Semantic Search (Content Management Systems)
 Intelligent Help