A Knowledge Base and Question Answering System Based on Loglan and English

A KNOWLEDGE BASE AND QUESTION ANSWERING SYSTEM

BASED ON LOGLAN AND ENGLISH

Presented in Partial Fulfillment of the Requirements

for the Degree Master of Science of Computer Science

by

Sheldon Linker

University of Illinois at Springfield

2007

— 2 —

Table of Contents

Title Page 1

Table of Contents 2

Project Summary/Abstract 6

Introduction 7

Rationale and Significance 7

Problem Statement 9

Legal Notice 9

Literature Review 12

Introduction 12

Other research into the Sapir Whorf hypothesis 13

Logical languages 13

Patents 15

Question answering systems and related programming 18

Specifically Prolog-based systems 24

Prolog and the alternatives 24

Speech acts 29

The Loglan grammar 30

Execution of Work 31

Task Breakdown 31

Software and Hardware Specifications (Development Environment) 32

Evaluation 33

— 3 —

Actual work 34

Design Considerations 35

Veracity 35

Limitations 36

Comparisons 37

Vocabulary 40

Implementation 41

The choice of language 41

Internal storage design 41

The program by specification 42

Inputs 42

Processing 42

Outputs 44

Performance 44

Tests 45

Results 45

Speakability 91

Conclusions 94

Finally 97

Vita 98

Appendix I — A Loglan Primer 99

Appendix II — Transformation of Loglan Into Functional Form 103

Step 1: Loglan Grammar 103

— 4 —

Step 2: Change From YACC Input to BNF-Like Notation 132

Lexicon 133

Grammar 139

Step 3: Simplification of the Representative Form 147

Lexicon 148

Grammar 148

Step 4: An Increase in Formality 156

Lexicon 157

Grammar 157

Step 5: Taking Advantage of a Written-Only Form 163

Lexicon 165

Grammar 165

Step 6: Limiting the Choice of Word Order 171

Lexicon 171

Grammar 172

Step 7: Converting to the Functional View 175

Lexicon 177

Grammar 177

Appendix III — Preferred Versus Other Embodiments 181

Appendix IV — The First-Cut Functional Form 183

Appendix V — Redesign of the Language 192

The Symbols of Logic 193

Items Inherited, or not, from Loglan 195

— 5 —

The Semantics of Predicates 210

Commands 210

Appendix VI — The Derived Rules of Syntax 213

Appendix VII — Additional Concerns 222

The Real World 222

The States of Logic 222

Methods Used in the Execution of a Message 224

Appendix VIII — Internal Structure 237

References 255

— 6 —

PROJECT SUMMARY / ABSTRACT

One of the "holy grails" of computational linguistics has been to have a machine

carry out a conversation, and to have some idea of what it is talking about. Loglan's

(Brown, 1960 & 1975) machine grammar (Linker, 1980) was a first attempt to carry out

such a project using a grammar which was unambiguous yet able to encompass the whole

of human discourse. It now seems that writing a logical, speakable language, with a

SLR-1 grammar (simple left-to-right parsing, with one look-ahead), and then reducing

that to a functional form ends up in a language that is hard to use for spoken logic, and is

hard to translate into. It further seems that a more useful way to go is to use the symbols

of predicate, first-order logic, second-order logic, and higher-order logic, and to use the

word-classes of Loglan, and to build a functional form from those in combination, then to

work backward from such a functional form to a speakable language, as much like

English and Loglan, in priority order, as possible.

The thesis presented herein is that such a language is feasible, speakable,

understandable and useful. The project detailed herein is to produce prototype of a

language which can be used for humand and machine discours (named JCB-English), and

a program which converses in this language, in such a way as to be useful in business or

academia.

— 7 —

INTRODUCTION

Rationale and Significance

Since the concept of machine intelligence was first made popular in English-

speaking countries by Karel Capek (1920) in the play Rossum's Universal Robots, people

have been interested in the possibility of conversing with machines. In a seemingly

unrelated development, Sapir and Whorf are said to have developed a psychological

hypothesis, that "there may be a linkage between the language one speaks and one’s

patterns of thought. " (Beeman, 1987). Dr. James Cooke Brown (1960 & 1975) invented

the Loglan language as a tool to investigate the Leibnitz conjecturetest by testing the

Sapir-Whorf hypothesis (see below). Loglan was to be a language which was complete

enough to express every thought-form expressable in every human language, have a

sound set pronounceable by everyone, be adjustable to test parts of the hypothesis, and be

totally unambiguous.

It appears that Dr. Brown's Loglan article in Scientific American in 1960 was a

turning point in linguistics. Dr. Brown, in his article, cites Leibnitz as the instigator of

this line of work:

The central notion underlying Leibnitz's vision may be stated in a quesion.

Is it true that the "rational power" of the human animal is in any significant

measure determined by the formal properties of the linguistic game it has

been taught to play?

— 8 —

Many years later, Dr. Brown, Michael Urban, and myself started an association aimed at

making Loglan provably unambiguous, and to create a SLR-1 machine grammar for

Loglan (Linker, 1980). Since then, others have continued this line of research (Brown,

1999) — both at the Loglan Institute, with its Loglan language, and the "rebel" offshoot,

the Logical Language Group (2007), with its competing language, Lojban — but have

gone only as far as verifying and graphing the grammar of this human-spoken language.

What of the Sapir-Whorf hypothesis? This author saw three significant effects

from learning Loglan and its grammar: (1) The ability to learn languages better and more

quickly, (2) the ability to work out a greater variety of problems without benefit of paper,

and (3) the sometimes-unfortunate ability to see dozens of ambiguous meanings in what

others see as having exactly one reasonable meaning.

What about communications with computers? That is the basis of the current

project, which is designed to use the predicate calculus basis of Loglan to form the basis

of a knowledge base combined with a logic inference engine that will be able to answer

questions directly from its knowledge base or, when required, make logical inferences

and answer questions. Although having a computer program that could carry on a

conversation and answer questions in plain English would be nice, this paper and project

will be limited to a design to deal with a "back end", which will communicate in a

language of its own. The end product should be able to carry on a conversation with a

person, know things, understand the interrelationships, and be able to answer questions.

— 9 —

Problem Statement

In this system, a full English-language conversation with the computer involves

the following steps:

• The person conversing with the computer will, for some time to come,

formulate statements, commmands, and question in English. Example: "I like

my cat"

• The user then translates these items into the controlled English described herein,

hereinafter known as JCB-English. Because of the similarity of JCB-Enlish to

naturally spoken English, not much translation will be required. Example:

"like i my cat"

• The JCB-English is entered into the system. For the purposes of this project,

the data entry is via an input file. However, in follow-on projects or products,

the entry could well be in the form of HTTP page requests, other net-bourne

request packets, or even spoken.

• A parser then translates the language to a data structure which directly

represents the entered utterances.

• Rules of transformation then restructure the representation of the utterance into

a more basic logical structure in some cases of grammar detailed below.

Example: "like i my cat", when spoken by a user named "sheldon" becomes

"both be x 1 cat and both own "sheldon" x and like "sheldon" x"

— 10 —

• Next, certain optimizations may take place to prune the data structure.

Example: Changing "both x and true" to "x". Commands are executed at

this point.

• Statements and questions are evaluated by a knowledge-base management

system (KBMS). This results in statements being accepted, rejected, or passed

to the next step. Questions are also answered or passed to the next step.

• Statements and questions too complicated for the KBMS will be submitted to an

inference engine. Statements will be accepted or rejected. Questions will be

answered or deemed unanswerable.

• Lastly, the result is translated into JCB-English.

In preparing for this thesis, a reformation the grammar of Loglan into an even

more formal form was made, to prepare for the description and implementation of a

single-user, functional-form conversational knowledge base. In the appendices to this

document, a series of transformations to the Loglan grammar is made, to increase the

formality, and to bring the language into a functional form, to alleviate the need for

parsing.

The original Loglan grammar, like English, allowed for incomplete utterances.

There could be raw additudinal indicators, such as "Hurrah!" ("ua"), or simple, sentence-

free answers to questions, such as "No." In increasing the formality of the language, the

language is restricted to full sentences only, and "Hurrah!" becomes "I am happy", and

"No" becomes "I am not a goat" or some other negation.

Once this linguistic form was developed, some preliminary testing was done to

find out just how speakable and understandable the resulting language was.

— 11 —

Unfortunately, the result was neither easily spoken nor easily understood. With this

problem observed, a re-design effort was made. This new design effort takes advantage

of the knowledge gained in the Loglan project, but also has speakability as a guiding

concern. In this project, the author shows that a speakable formal grammar can be easy

to understand and use for informational purposes on the computer.

Legal Notice

There is a patent pending on the methods described herein.

— 12 —

LITERATURE REVIEW

Introduction

In reading about question-answering systems, it seems that most of the work

concentrates around fitting data into an existing slot, as is the case in most database

systems, with manuals and descriptions too numerous to mention, or with finding text

containing the data, deciding which are likely to be relevant, and then delivering a list of

such documents, delivering the most likely text, or even trying to construct an answer

based on the likeliest data. It seems that there is almost no information, though, on the

idea of taking an unclassified datum, and storing it into a knowledge base, in a self-

defining manner. For instance, one can store "Patrick Henry said 'give me liberty or give

me death,'" as plain text, but the likelihood of a system making enough sense of it to

make it useful is slim. If one takes a little effort to translate it to something more formal,

"Patrick Henry desires that the British give him either liberty or death" (or, as shall be

translated below, "desire "patrick henry" the event give "britain" "patrick

henry" the event either free "patrick henry" or dead "patrick henry"", or for

those with an even more formal bent, "there exists x such that both be x "patrick

henry" and desire x the event give "britain" x the event either free x or

dead x").

There is much to be said, too, about the artificial formal languages, such as

Loglan and Lojban. Little if anything, though, of direct use in the way of putting these

languages to work.

— 13 —

On the subject at hand, conversing with the computer in speakable formal

language, there is virtually nothing to be found. As Isaac Newton is oft quoted, "…I

stand on the shoulders of giants." I stand there only that I may take a flying leap into new

territory. That said, I begin my literature review in sections: Patents, Question

Answering Systems, and Languages.

Other Research into the Sapir Warf Hypothesis

One of the best examples of the Sapir Whorf hypothesis was shown in

experiments by Phillips & Boroditsky (2003). In the experiments, they showed that,

given pictures of various objects, people who spoke (in addition to English) a language in

which the object has a female "gender" in their native language saw the object has having

female qualities. Similarly, people who spoke a language in which the same object has a

male gender in their native language saw the object as having male qualities. Thus

showing that language and thought are closely related, and in this type of case, the native

language does indeed drive certain thought processes.

Logical Languages

The subject of machine conversation with people has been rampant in fiction.

However, true conversation on a meaningful basis with a computer requires both a formal

language and a machine understanding of context. The idea of a speakable formal

language was started by Prof. James Brown of the University of Florida, and described as

— 14 —

an article in Scientific American, in 1960 (Brown, 1960). Later, books on the subject

were published (Brown, 1975 and 1978), and became the subject of web-based

publication and update (Jennings, 2006). Rather than being the culmination of a research

project, things had only begun. Other projects, such as Lojban (LeChevalier, 2006) and

Guaspi (Carter, 1991) branched out. Despite grand plans after the first machine grammar

was delivered (Linker 1980 and 1981), there had been many half-attempts (Goertzel,

2005), but a machine conversationalist, running a limited subset of Lojban finally was

written (Speer & Havasi, 2004). This was a great advance, but still had its limitations, in

that full Lojban was not yet supported, and (of course), the common English speaker

would not be able to make use of the system. It is also pleasing to note that the Lojban-

speaking program is happy with its work, as is evidenced by its use of the word "ua".

Proposals for a language partway between Lojban and English, such as "Lojban++" have

also been proposed (Goertzel, 2006).

This paper makes heavy use of the interrelatedness of Loglan, thought, and

higher-order logic. An excellent overview of all of these, plus the Sapir-Whorf

hypothesis appears in Lógica y Lenguajes (Logic and Languages, Laboreo, 2005).

Relatively recently, Norbert Fuchs and his colleagues (Fuchs, et al, 1999) at the

Institute for Information at Zurich University have developed a number of schemes, each

layered on another, to bring English to usability in logic. They have taken English, and

applied a large number of rules against it, and limited it to a subset they call Attempto

Controlled English, or ACE (Fuchs, et al, 1999). ACE is a limited subset of English. It

is very powerful for a limited subset. The description of the subset takes the form of a

manual, part grammar lesson and part programming manual. Because Attempto attempts

— 15 —

to follow English so closely, there are a very large number of context rules. This is a

very strong point in ACE, in that anyone can read ACE; however, the weak point is

strong reliance in context rules, and the inherent ability to get into trouble with a

misplaced phrase. Given their language specification, the authors next set out to develop

the specifications for a Reasoner for ACE, or RACE (Fuchs, et al, 2002). A thesis project

was done by Hirtle (Hirtle, 2006) bringing these components together. Unfortunately,

ACE has no usable query language capability at this time, and is limited to the

description of facts. Hirtle's project and this one have the possibility of being used

together in the future, in that Hirtle's project could take Attempto, and transform it into

statements acceptable to this project's language or data-store. One could then use this

project's query language to extract information from the resulting, combined knowledge

base.

Patents

Some of the patents claiming to involve "universal languages" actually pertain to

internal computer coding, and not spoken languages, such as an intermediate compile-to

language (Goss et al, 1987), or suggested data structures for storing data for later analysis

(Jung, 2005).

There are also patents and patent applications which claim to disclose new

information or teach new methods, but do not, even though they have intriguing

introductions. These include universal language parsing, in which we are told how to

write a compiler (Bralich et al, 1999), a "cognitive processor" of knowledge bases or

— 16 —

which understands information (Stier & Haughton, 2002; Suda, 1994; Suda &

Jeyachandran, 2003), a logical agent (Jowel & Kessock, 2006), answering in English

(Chang, 2006), and even how to build your own fully functional android (Datig, 2002 and

2005).

There are a number of descriptions of question-and-answer methodologies, in

which the user presents a command or query, and the computer responds with a series of

questions of its own to narrow down the exact nature of the initial command or query.

These include pattern-matching to determine the information content and question, much

like a game of Twenty Questions (Schramm, 1987; Yano et al, 2002; Matheson, 2006;

Zhang & Yang, 2002).

Many patents discuss methods of speeding up processing, some more obvious

than others. These include parallelism (Dixon et al, 1992), optimization of the

information store (Kautz & Selman, 1993), and hashing (Miller et al, 2002; Brassell &

Miller, 2003). In a similar vein, several patents (Eldredge et al, 2004; McConnell &

Barklund, 2006; Spiegler & Gelbard, 2002) describe indexing systems that can be applied

to existing textual or other forms of data, for quicker retrieval.

A very common method of using natural language is to apply grammatical rules,

or picking out sentence fragments or key words to use the utterance or writing to serve as

the basis for a formulation of a query, SQL or otherwise, which is then used to query a

data base or table (Lamberti et al, 1994; Schwartz, 1993 and 1998; Machihara et al, 2001;

Wyss et al, 2002; Hsu & Boonjing, 2002; Metcalf & Dingus, 2004; Sheu & Kitazawa,

2004; Nakamura & Tate, 2005; Ejerhed, 2006; Rosser & Sturges, 2006; and others too

numerous to mention) or to perform some command activity (Firman, 1994; Namba et al,

— 17 —

1996; Salanha at al, 2004; Hogenhout & Noble, 2006; Diederiks & Van De Sluis, 2001;

Ross et al, 2002 and 2005; Fain & Fain, 2002; Beauregard & Armijo-Tamez, 2006;

Dusan & Flanagan, 2002). A similar technique is to see if the utterance or writing

matches a preformulated query template, and then to retrieve query elements from the

matching template zones (Appelt, 2003; Harrison et al, 2003; Agarwal & Shahshahani,

2004; Williams & Hill, 2005).

Many systems retrieve information, pulling either entire documents or facts from

the documents. This searching can take place based on noun, keyword, or phrase

matching (Fujisawa et al, 1991, 1995, and 1996; Haszto et al, 2001; Ho & Tong, 2002;

Brown et al, 2003; Fung et al, 2004; Ejerhed, 2006; Tsourikov, 2002), actual grammar-

fragment matching (Kupiec, 1996 and 1997; Ford, 2003), statistical likelihoods of having

meaningful data (Ahamed, 1998), or a plurality of these techniques (Weber, 2002;

Scheneburg et al, 2002; Brody, 2004; Bennett, 2005). An adjunct method to these,

reading documents, placing search tags in them, and coming back for matching tags later

(Kasravi & Varadarajan, 2006; Pustejovsky & Ingria, 2001) is also described.

There are also a number of inventions dealing with presentation, allowing the

computer to put on a better face (sometimes literally [Guo et al, 2003]) to the human side

of the conversation. This includes "human-like responses" (Armstrong, 1998; Hagen &

Stefanik, 2005), emulation of an understood system, similar to the Eliza program of the

1970s (Klipstein, 2001), text to speech (Epstein, 2002; Kobayashi et al, 2004; Wang,

2006), and keeping the dialog on track (Coffman, 2003). On the flip side of this, there is

much in the way of speech recognition (Gould et al, 1999; Strong, 2001 & 2004; Romero,

— 18 —

2002; Bangalore et al, 2003; Wang et al, 2004). The use in speech recognition would be

nice in a follow-on to this project, but is not required.

Some systems (Moser et al, 2001; Sukehiro et al, 2004) rather than storing,

understanding, or retrieving information, simply translate it to another language.

One system (Hawkinson & Anderson, 2004) uses a tree-structured set of classes,

in which numeric class IDs exist in ranges, so that, for instance, Dog might have an index

in the Mammal range, and Mammal might have an index in the Animal range (as would

Dog). However, full prepositional logic is impossible in this sort of configuration. Here

is a simple example: Consider Charles, Price of Wales. He is a member of the classes

Men and Royalty. Any simple indexing scheme using numbers will not do. Prince

Charles cannot be assigned any numeric index which will be both numerically in the Men

range and in the Royalty range. The current project, in contrast, uses logic reasoning

statement to derive such knowledge. For instance (shown in the English equivalent) "A

prince is the son of a king. A son is a male child. A king is royalty.

One system (Tunstall-Pedoe, 2006) uses "objects", which are for the most part

nouns or nominative phrases, but which may also be verbs or verb-like phrases. Objects

can be grouped to form facts, and facts are queryable. This sort of system can find facts

and negative facts quickly, but cannot reason out more complex problems.

— 19 —

Question Answering Systems and Related Programming

In their review, Andrenucci and Sneiders (2005) point out a list of approaches

being used in question answering systems:

• Natural Language Processing maps user questions into a formal

world model and ensures the most reliable answers.

• Information Retrieval powered QA, together with NLP, focus on

fact extraction from large amounts of text.

• Template-based QA matches user questions to a number of

templates that cover often queried parts of the knowledge

domain.

Despite these facts, this project will be using near-natural language data and queries.

The Pegasus language processor (Knöll & Mezini, 2006) uses natural language

(currently English and German), and interprets what is said as a series of imperatives. It

translates those imperatives to Java. The grammar parsing, of course, is dependent on the

input language. Within Pegasus, the basic unit is called an "idea". All in all, the result

looks much like Cobol.

The idea that there should be a special information retrieval language, perhaps

based on Loglan (Ohlman, 1961) or a logical subset of English (Cooper, 1964), is not

new. Indeed, these were proposed over 40 years ago.

There have been a number of discussions on the idea of retrieving documents, or

fractions thereof, based on input questions (Cardie et al, 2000; Radev et al, 2001; Brill et

al, 2002; Ramakrishnan et al, 2003; Sekine & Grishman, 2003). Some take the additional

— 20 —

step of allowing the user to narrow down the responses (Small. 2003), or by template

(Srihari, Rohini & Li, 2000) or pattern (Roussinov & Robles, 2004) matching, or even

reformulating the question to use other such systems as agents (Agichtein et al, 2001 and

2004). Although there are many more articles in this category, the same data tends to

repeat, so no further mention of such articles will be made herein.

In the QA1 system, first-order predicate calculus was used to deal with list-

controlled data (Green & Raphael, 1968). List-controlled data is likely a good idea, since

the true structure and interrelatedness of the data (as relevant) will not be known until the

query is issued. However, it seems unlikely that first-order logic would be sufficient for

any but the most basic questions. QA1 has the advantage that is can quickly categorize

data, and thus search quickly, but the disadvantage of needing to categorize data at input

time. The language itself is very Lisp-like. A very similar system, MRPPS (Minker,

1977) uses a more traditional descriptive technique. In a latter paper (1978), Minker

describes, in great detail, how one might go about writing a theorem prover into an

analysis engine. Since Prolog is available, this project will use Prolog for the time being,

but replacing Prolog with Minker's method would yield far greater control in tuning

performance. There are also methods whereby some rules can be quickly excluded in

such a prover (Joshi, 1977).

Some systems (Reiter, 1977; Waltz, 1978; Kang, 2002) attempt to retrieve data

from a relational data-base system using natural language queries.

Similarly, but perhaps more clever, one system, QuASM, gathers data from

tabular information found on the web (Pinto, 2002). Such a technique could be used to

drop data into a strict-grammar system, in that a crawler could gather the tables, and a

— 21 —

template could be entered manually for the data, thus effectively adding all of that table's

data to the knowledge base. The technique is not a part of the current project, but could

be used to enhance future versions.

It has been pointed out (Lita & Carbonell, 2004) that entering data into a

question-answering system can be a time-consuming enterprise, and that the data will

thus be limited. A method of gaining large amounts of reliable data is proposed. While

this technique is not being incorporated into the current project, automatic data gathering

could be a useful, later addition. A similar technique, based on similarities

(Ramakrishnan, 2004) is also possible.

One innovative system, Cogex (Moldovan, 2003), transforms front-end natural-

language queries into a logical first-order predicate form. It does the same with back-end

documents. It then uses a theorem prover to find substantial matches, and then returns

the source sentence.

The writing of theorem provers has been proposed a number of times, in a number

of different ways. However, Prolog is cited as being useful directly as a theorem prover

(Loveland, 1986), albeit with a little work. One important source of Prolog techniques,

as well as a good list of pitfalls to avoid (such as ways a logic specification can infinite-

loop) appears in Prolog Programming for Artificial Intelligence (Bratco, 2001).

If a system is going to answer questions, then it needs to be trustworthy, or at least

report the trustworthiness level of its data, as Chen et al (2006) point out. This is true

whether questions are answered by an automatic system, or by a person. It is for this sort

of reason that this project will involve rating the veracity of the information and its

answers.

— 22 —

Obviously, if the question-answering system can parse English (or some other

source language), then it will be fairly precise. Hao et al (2006) show how to reasonably

parse a certain subset of English questions, giving reasonable answers to the most-often

type of questions asked. This shows, more by omission than anything else, that a precise

language syntax is required for truly precise answers. That is the reason that the current

project first attempted the use of Loglan, and has since switched to Loglan-like English.

Some of the question-answering systems are really just FAQ systems, saving pairs

of questions and their answers, and either answering directly, or answering a question-

answer pair when the new question and the saved question are close enough (Wang et al,

2006).

Burek et al (2005) describe breaking a sentence down into components, based on

linked phrases. They give as an example, "What researchers work in the ALPHA project

financed by the Argentine government?" They show that this can be broken down into a

sentence describing the Alpha project, and a question about the researchers on the

project. Of course, such method can be applied recursively. This is the type of technique

which will be used when linking words like "my" appear in statements or questions in

this project.

Bererle (1993) describes a language, Lilog, which is similar to Loglan, first order

logic, and the limited English presented below. An example of some Anglicized Lilog is

"forall X: BUILDING(exists Y: TOWER part-of(X,Y) impl

CASTLE(X))". The same sentence in Loglan would look similar, but would be far

simpler to say and write. For instance "forall x:" is "Ba go" in Loglan. In the

limited English presented below, the concept presented above, "for all X, if X is a

— 23 —

building, and there is some tower Y which is a part of X, then X is a castle" would be

expressed as "for all x if both building x and contains x at least 1 tower then

castle x".

One system, Chanel (Kuhn & Di Mori, 1995), attempts to learn semantics and

grammar on the fly. Herein, though, a fixed grammar will be used.

Specifically Prolog-Based Systems

Baral and Tari (2006) present a project in which grammatical parsing is used to

formulate the data and the question into Prolog, and Prolog is then used to formulate the

answer to the question. This is an example of an application-specific question-answering

system, but what is still desired is a general-purpose question-answering system.

Additionally, if the data is to be large, the use of Prolog or its equivalent should be a last

resort.

In the work of Marchiori (2004), a project somewhat similar to the current project

is discussed. Like this one, and English-like syntax is developed, and Prolog is used to

perform the logic. However, the grammar presented is at once too loose ("JOHN IS

'tall like a tower'.") and too specific ("VERB represents

'http://www.w3.org/2003/m2#verb'."), so that general discourse would be

almost impossible. The same problem was found in attempts to use Loglan grammars.

Also, using Prolog for the first cut would mean that all responses would be somewhat

slow. Thus, in this project, a more extensive yet fixed grammar will be used, but with a

— 24 —

self-extending vocabulary. Additionally, there will be a fast (but limited) prover as the

logic engine, with Prolog as a back-up.

Similarly, Greetha & Subramanian (1990) describe a limited English sentence

structure is not only understood in Prolog, but parsed in Prolog. An example given in the

work is "John opened the door with a key". Using Greetha & Subramanian's method, the

Prolog structure which is first developed is "sentence(agent(np(propernoun(

john))), (vp(verb(opened), (object(np(det(the), noun(door))

), (instrument(pp(prep(with), np(art(a), noun(key)))))", which

is then simplified to "sentence(agent(np(john)), verb(opened),

object(np(the door)), instrument(pp(with a key)))". In the project

described below, the same original sentence is presented as 'before now open "john" 1

door 1 key', because each predication (verb, for most practical purposes) carries

positional arguments. In this example, the translated phrase would be presented to Prolog

in a form equivalent to "time(T<0), open(john, qtty(1, door), qtty(

1, key))". In Greetha & Subramanian's work, the introduced function abbreviations

"np", "vp", "det", "pp", "prep", and "art" stand for Noun Phrase, Verb Phrase,

DETerminant, Prepositional Phrase, PREPosition, and ARTicle, respectively.

Prolog and the Alternatives

Prolog is an obvious and popular choice for logic programming. However,

because Prolog is so different from most other languages, being almost entirely

declarative rather than procedural. A Prolog manual does not give an explanation of how

— 25 —

one might go about actually using Prolog for a project such as this. However, the book

Prolog Programming for Artificial Intelligence (Bratco, 2001) does just this. Some key

points from apropos to this project from Bratko's book are:

• That if a Prolog program or knowledge base defines a rule on itself,

directly or in a loop, that the program may fail in an infinite loop. A

trivial example of self-reference is "a :- a." A trivial example of a

loop is "a :- b. b :- a." Thus, in a project of this nature, the

program should guarantee that no such loop is passed to Prolog. This

may or may not prove practical in the given time constraints. If

impractical, it should be a future goal. (§2.6.1)

• Because of the way in which Prolog recurses, it is possible that ordering

of the clauses passed to it in the knowledge base can involve recursive,

depth-first goals, which may prove unsolvable. If a program and query

are passed to Prolog, and Prolog infinite-loops for this reason, the result

will be a stack overflow message of some sort. In these cases, the

driving program (this project) can rearrange the Prolog program such

that recursion will be breadth-first. (§2.6.2)

• Exclusive paths — paths which, if followed, preclude other paths from

being tried — can be used to speed program execution, using the "!"

operator. (5.1.1)

• If exclusive paths are used, then criteria following the exclusive paths

may be omitted, much the same way that in C, one can change "if

— 26 —

(x>0) y(); else if (x<=0) z();" to "if (x>0)

y(); else z();". (§5.1.2)

• Prolog uses a closed-world system. Anything that cannot be proven or

disproved is considered false. Thus, its use is limited. (§5.4) More on

this below.

• Rather than having to generate a new program if the knowledge base is

changed, Prolog predicates "assert" and "retract" can add and

remove facts and rules. Additionally, and for the purposes of

optimization, "asserta" can add facts and rules at the beginning of

the consideration list. (§7.4)

• Prolog, in some implementations, has the ability to define a parser. It

remains to be seen whether the parsing ability is robust enough for the

purposes of this project. If so, some or all of the parser might be

written in Prolog, rather than Java. (§21)

• Programs are often written in Prolog for rapid prototyping, and then

rewritten in other languages to execute quickly, once the methods or

rules are locked in. (§23.1)

• A meta-level executive — in which the Prolog program controls the

execution of another Prolog program —can be written almost trivially

in Prolog. Use of this type of facility allows various sorts of tracing,

explanations of the methods and/or facts used in a proof or

determination, and the direction or limitation of depth of exploration.

(§23.2.1)

— 27 —

• For full theorem proving, rather than just determination of found or not

found, Prolog may have to be supplied with a transform function,

giving it the explicit rules of double negation, elimination, distribution,

sub-expressions, and De Morgan's laws. (§23.6)

Although Prolog is a well-known quantity, it suffers from the major drawback of

being a closed-world system, in which Yes is "yes" and both Maybe and No are "no".

This makes Prolog unsuitable as the full-fledged engine behind a conversational

knowledge base. Prolog is, however, optimal for a first-cut system, and the debugging

thereof, because it is such a known quantity. One alternative (Boley & Sintek, 1995) is

RelFun. RelFun solves the problem neatly:

Queries to RelFun differ only as follows: they return the truth-

value "true" instead of printing the answer "yes"; they signal

failure by yielding the truth-value "unknown" instead of printing

"no". When we stay in the relational realm of RelFun this makes

not much of a difference since "true" can be mapped to "yes" and

"unknown" can be mapped to "no". However, when proceeding to

RelFun's functional realm, queries will be able to return the third

truth-value "false": this is to be mapped to those of Prolog's "no"

answers for which the closed-world assumption is justified. In

general, however, RelFun does not make the closed-world

assumption, and in the absence of explicit negative information

modestly yields "unknown" instead of "omnisciently" answering

"no".

— 28 —

Other alternatives exist, too. However alternatives such as CP (for Conceptual

Programming) provide open-world facilities, but in a completely different manner. For

example (as shown by Hartley, 1986):

<>

<- [STATE: (PERSON: John] -

(POSS) -> [BOOK: * b]],

<- [EVENT: [GIVE] -

(AGT) -> [PERSON: John]

(OBJ) -> [BOOK: * b]

(RCPT) -> [PERSON: Mary]

<- [STATE: [PERSON:Mary ] -

(POSS) -> [BOOK: * b]].

Another such alternative is OWL (for Open World Logic), which can be accessed from

Prolog (Matzner & Hitzler, 2006), but which again has different enough methods of use

as to make porting into or out of it difficult. Yet another example is the Lisp-like

PowerLoom (Chalupsky, 2005). Although PowerLoom differs significantly from Prolog,

PowerLoop actually has a simpler syntax, and a program written for Prolog could be

quickly converted to PowerLoom. PowerLoom has the advantage of running on a variety

of platforms including Max OS/X. Given these data, an extension of the program by

porting from Prolog to PowerLoom must be considered for a later phase (or the current

project, if time allows).

— 29 —

Speech Acts

Speech acts are utterances which are themselves an act of some sort, over and above

simple utterances (Ljungberg & Holm, 1996). These acts can be divided up into several

categories:

• "Performatives", in which the utterance itself performs some deed, such as

marrying two people, or sentencing someone. Such acts must generally be

performed by member of a particular class of people. In English, an example

would be "I now pronounce you man and wife." In JCB-English, described

herein, the same speech act would be rendered "now declare i the event

beginning now marry you".

• Minor "performative constructions", in which the utterance performs a deed,

simply by explaining that it does, such as "I warn you to stop."

• Obvious from the above, is a lesser category of imperatives and question, each in

and of themselves a demand that an action or an answer occur. In this light, all

programs, and all of JCB-English, can be considered speech acts. As described

below, each command, predication, query, or question is an explicit instruction to

do something, a direct request for an answer, or an implicit demand that

information be stored.

• Least of the speech acts are the "indirect speech acts", which accept, reject, or the

like, only be inference. For example, "Will you marry me?" answered by "I'd

rather die first."

— 30 —

• It would seem that a sixth category might apply, in that certain direct agreements

may in and of themselves form contracts, since a contract is formed with offer and

acceptance.

The Loglan Grammar

The Loglan grammar deserves a full citation in this literature review because it

was, to a large extent, two of the steps in writing this proposal. It was the culmination of

the project that led to this one, and it was the basis for the first cut at this proposal (in

which Loglan was going to be the language in use), and served as the basis for the

planning of the English subset in this proposal. The grammar (Brown, 1960; Linker,

1980; Prothero et al, 1994) encapsulates the whole of human language capabilities, in a

very small space. Rather than taking the space inline, the grammar and its derivations

appear in the indices which follow. The 1994 Loglan Machine Grammar is ©1982

through 1994, and is used herein with the express written permission of the publisher.

— 31 —

EXECUTION OF WORK

Task Breakdown

The tasks required for the ultimate goals of the project include both the tasks of

the project proper, and a roadmap to future work. The roadmap to future work appears in

the Conclusion section. The tasks herein were and are as follow:

• Design a fully speakable and understandable grammar, such that a human can enter

this grammar directly, and such that this grammar can unambiguously express the

speaker's thoughts and knowledge. (Done.)

• Design a data storage scheme, such that the data represented by the language can be

saved, searched, and used. This data storage scheme will by its nature, be tuned to a

particular environment architecture. (Done, with the environment used for this

prototype being a JCB-English representation of the knowledge base, since Java does

not easily admit to binary I/O of its internal data structures.)

• Design the three major components of the back-end system: Inputs, Processing, and

Output:

° Input Processing: Design a parser which can parse the language and store it, as well

as read data back from persistent storage. (Done.)

° Main-line Processing: Design a processing method which forms the skeleton of a

logic engine and does the work of a knowledge base engine, in that it is able to take

statements and questions, decide whether a statement is worthy of being stored as

— 32 —

knowledge, decide whether a question is answerable, and if need be, answer

questions. (Done.)

° Output Processing: Design an output method which replies to humans, can reply to

a front-end program which would translate the result to English or another

language, and which persists the knowledge. (Done, for the stand-alone, batch

configuration.)

Software and Hardware Specifications (Development Environment)

Since this system is to be a back-end system, it must be scalable, and run as

quickly as possible. However, for purposes of this prototype, it was written in languages

which requires the least amount of work: Java and Prolog. For real production work,

through, the entire system should be rewritten into a compiled language, such as C, C++,

or PL/1. Java and Prolog are supported on a wide variety of platforms. For this work, a

Mac PowerBook G4 was used, running OS/X, Java, and Prolog. Prolog may later be

replaced by LogFun. The machine uses an AltiVec G4 processor running at 1GHz, with

768MB of memory. Since this project is a back-end system by design, only standard I/O

streams are used, and no graphics are involved.

— 33 —

Evaluation

In this scope of work, not every aspect of the proposed language system can be

implemented immediately. Thus, some functions specified in the appendices are

"stubbed out". However, all the important elements are present at a level to demonstrate

the effectiveness of this method.

Evaluation is at several levels — Speakability of the language, Unit test, and

Actual usability of the system. Speakability and unit test have been combined to some

extent, in that unit test contains a wide variety of concepts.

• Speakability of the language: Can the language be used to express every concept

which Loglan does, thereby allow expression of every concept in every human

language? This can be tested by actual translations, but cannot be tested exhaustively.

The first tests involve simple statements and questions, and increase in complexity

from there.

• Unit test: One very workable method of testing a piece of software is to check each

sentence of the manual or description, and see that the feature is present and correct.

Because of the large number of goals in this project, the more complex feature of

presentation to RelFun has been left stubbed out. The aerospace method of checking

that every instruction believed to be reachable was used. Some instructions are

present for exceptional cases, but are not believed to be actually reachable. Since the

effort to prove that some code is unreachable is not worth the effort, such code

remains in place.

— 34 —

• Actual usability of the system: Can the system be used to store data, accept new data,

reject data, answer questions, and report that questions cannot be answered? The unit

tests, below, show that this is indeed possible. During testing, a surprising result

occurred: Some of the test cases were written, and then run. Unexpected results then

occurred. In some of these unexprected result cases, rather than finding a bug in the

code, it was found that the program had reached a logical conclusion based on some of

the retained input that the test case itself had not contemplated.

Actual Work

• The total number of lines of code, which varies as of this writing (as improvements

continue), is between 5,000 and 6,000 lines of Java code, including embedded Prolog.

• The total number of test cases, which increases as of this writing (as improvements

continue and are tested), is approximately 100, each including two to dozens of

utterances.

— 35 —

DESIGN CONSIDERATIONS

Veracity

In any system which takes in data, and gives results, one must avoid the Garbage

In, Garbage Out syndrome. Data base systems typically do this by having trusted users,

untrusted users, and excluded users. Trusted users are allowed to write data into the

system, update it, and remove it. Untrusted users can only query the system. In a system

of this type, those categories are insufficient to a multi-user system. Many times, one

hears of one person's reality versus another's. If nothing else, Einstein proposed that the

truth, under certain circumstances, can be relative (in that no complete agreement can

ever be made on the relative coordinates of two event can be made, not even on their

relative times of occurrence (Einstein, 1916)). So, unlike a standard data base system, in

which each fact is accepted universally or not, the situation here is of each fact being

accepted universally, or pertinent only to a given user and to those users who accept the

given user's viewpoint. Thus, trusted users may speak ex programico, dictating what is

truth for all. Untrusted users can still add data to the system, but should only be held as

holders of beliefs. This may be best shown by example.

Bob, a trusted user, speaking ex progmatico, says that his cat is large. In speaking

ex progmatico, Bob supercedes the logic of belief structures and states absolute,

inarguable fact. Bob also says, this time acting as a regular person, that his dog is small.

Although Bob is given a great deal of trust, Bob's normal statement is accepted as Bob's

— 36 —

belief. Bill, a regular, untrusted user, later says that Bob's cat is small, and that Bob's dog

is big.

In the case of Bill's data entry, the statement about Bob's cat being small should

be rejected, because the fact that Bob's cat is large is absolute. However, as a regular

user, and from Bill's perspective, Bob's dog is indeed big. Thus, if Bill asks for

information on Bob's animals, he should be told that Bob's cat is large (as Bob made

known as absolute truth), and that Bob's dog is big (as is true from Bill's perspective).

If a third user, trusted or not, were to ask about Bob's animals, the result should be

something on this order: "Bob's cat is large. Bob states that Bob's dog is small. Bill

states that Bob's dog is big." Filtering is allowed, so that a statement under a given trust

level can be ignored.

Limitations

Development of the type of system being described here is an open-ended affair.

There will always be room for increased functionality and increases in the ability to make

logical transformations and solutions. Thus, in implementing a pilot program to

demonstrate the concept's viability, certain limitations may be placed on the current

version of the program. These limitations may include:

• Operating the system in single-user mode, thus,

° There is currently no shift of pronouns, other than from "you", "i" and "me" to

name form.

— 37 —

• Each utterance (a linguistic term meaning one or more sentences [which may be

statements, questions, imperatives, and in informal languages, sentence fragments]

spoken at once) must be either a collection of statements, or contain exactly one

predication containing exactly one question-word. Mixed statements and questions,

complex questions, and imperatives are not accepted.

Comparisons

The knowledge base and logic engine accept as input four types of utterance:

(1) A statement of fact, which may be composed of one or more predications and/or

logical connectives, (2) a yes/no question, (3) a fill-in-the-blank question, and (4) direct

system directives (commands). The knowledge base is composed of stored fact-type

utterances. In answering a yes/no question, the system attempts to prove or disprove the

question's predication. In the case of a fill-in-the-blank question (using a word, such as

"when" or "which"), the logic engine searches the knowledge base for a match (a proof

with wild-cards), so that the question can be answered. If a new statement is to be added

to the knowledge base, and the same knowledge is already present, the new statement is

discarded. If a contradiction to the new statement is found (i.e., the new statement can be

disproved), then the new statement is not accepted. (Remember that some users will

speak globally, where others speak only for their own frame of reference.) If a new

statement is received, and plausible (neither provable nor disprovable), then the system

accepts the statement into the knowledge base (at the current level of trust).

— 38 —

Here, the rules for what constitutes a match are explained. The system will use

two types of logic. There is a fast-proof system involving only direct matches, and a

slow-proof system, which will make use of inference, used when the fast-proof system

fails to deliver a result. If two statements exactly match in form and content, they are

equal. (For instance, "I am Sheldon" matches "I am Sheldon" in form and content.

Similarly, "I am who" matches, because "who" matches everyone.) If two statements

match in form, but do not match in content, the two statements are unequal. (For

instance, "I am Sheldon" does not match "I am Bob".) If one statement matches another

in content, but not in form, they may still match, by virtue of one of the statements

implying the other. For instance, "I have a cat" matches the statement "I have a happy

cat". The statement "I have a cat" is a generalization of the statement "I have a happy

cat" because they both imply "I have a cat". The second statement refines this

knowledge. Thus, the following table of conversations: (Note that these conversations

are in English for purposes of clarity of explanation, and not in the language used in a

following section.)

— 39 —

Statements Result

I have a cat.

I have a happy cat.

Do I have a happy

cat?

(accepted as new information)

(accepted as new information; "I have a cat" may be discarded as

redundant)

Yes

I have a happy cat.

I have a cat

Do I have a happy

cat?


(ignored as redundant information)

Yes

I have a cat.

Some cat is happy.

Do I have a happy

cat?



(Unknown, because we have not identified it as the same cat.)

I have a cat.

I have no cat.


(rejected as contradictory to known information)

— 40 —

Vocabulary

The vocabulary is the the list of words defined in the grammar proper, plus the

words which are recognized in context as predication words, "is" and "own". Input to the

program is (a) persistent user-account information, (b) persistent knowledge gained from

conversations, and (c) persistent encyclopedic and dictionary-like data, such as "if a is

bigger than b, and b is bigger than c, then a is bigger than c", this defining "bigger".

"Smaller" could be defined as "if a is bigger than b, then b is smaller than a". This woul

be expressed in the language proposed as "for all x y z if both bigger x y and

bigger y z then bigger x z" and "for all x y if and only if bigger x y then

smaller y x". A complete grammar follows.

— 41 —

IMPLEMENTATION

The choice of language

As stated above, the prototype system was written in Java, and generates (but

does not yet use) Prolog. In the future, RelFun can be used to run the Prolog code.

Future versions would be written in C, C++, or PL/1, and possibly using a data base

system. In a production setting, this is a project that will be dealing with a large amount

of data, with the need to respond in a very short amount of time.

Internal Storage Design

The internal storage specified as Appendix VIII is that of the language-parsed

syntax, plus the needed tables.

— 42 —

The program by specification

When a program is to be produced, a specification is written first. The

specifications usually involve inputs, processing, outputs, and throughput. Processing, to

a large extent, is a black box, and part of design, rather than specification.

Inputs

The program needs to read control files, and a number of utterances.

The control file serves to establish the vocabulary, and the rules of vocabulary-

driven logic. There is a control file containing: The user account data and basic world

knowledge. For the initial tests, only a single operator account is required. There will

also be a third file, which will be persistent knowledge gained in conversation.

For this phase, the program reads the utterances from the standard input stream,

and sends all of its output to the standard output stream. Each utterance ends with an

End-Of-File or in an "execute" keyword. For actual operation, the program should act

as a server, communicating with clients using packets.

Processing

When the program initializes, it must first read the account-and-knowledge file.

No knowledge need be present, since the system can start with a blank slate.

The system then starts reading from the test input stream. When an utterance is

received, marked either by "execute", or by EOF, it should process the utterance. When

— 43 —

the end-of-file is received, the program either exits (if no changes have been made to the

knowledge base), or output the logic base, making a backup copy, and then exits.

Each utterance must be checked for a number of things, in no particular order. Of

course, the utterance must be syntactically, lexically correct, and within the vocabulary.

There can only be one question word, at most. There can be no imperatives.

Once the preliminary checking is done, the utterance can be evaluated. If the top

level is a compound, then the sub-utterances can be separated, and considered separately.

This type of separation is applied recursively. Each is added to the knowledge base one

as a time. This involves several steps: The sentence or question is then refactored and

optimized to have the least logic, and least implication possible. (For instance, "X is a Y

or X is not a Y" is always true, and thus should not be added to the data base. "(X xor Y)

or (X and Y)" is the same as "X or Y".) The sentence is then evaluated against the

knowledge base for veracity. If the sentence can be shown to be false, then the entire

utterance must be discarded as false. If the sentence passes, then each of the sentences

must be added to the knowledge base. If there is a question present, then it should be

answered.

The logic applied above is able to handle adjectives. The subject of adjectives

does not usually come up in discussions of logic. So, if the knowledge base held "X is a

cat", and the new sentence is "X is a male cat", then it checks out as true. However, it

should also be noted that "X is a cat" would be replaced if the sentence is accepted. If the

knowledge base held "X is a male cat" and the sentence is "X is a cat", then the new

sentence is redundant. If the new sentence is "Y is a dog", then the sentence is plausible,

and the system must assume the sentence is true (in the viewpoint of the speaker). Given

— 44 —

"X is a cat" as the knowledge base, then these fill-in-the-blank questions would match:

"? is a cat", "X ? a cat", and "X is a ?".

Outputs

Output from the program occurs at the end of each utterance, responding with

acceptance, rejection, or the answer to any given question. Outputs to questions will be

in the language shown below..

At termination (and only if changes were made), "knowledge.new" is written. For

simplicity, and for now, the knowledge base can be written in JCB-English. At some

future time, a format conducive to faster loading can be added to the accepted formats.

Performance

Performance for the fast-prover is rather quick. Time required is linear with the

size of the knowledge base and the size of the input. Once RelFun is used, timing will

become significantly longer.

— 45 —

TESTS

Tests consist of two types. Black-box and white-box testing, shown as Results, below,

exercised each element of grammar, and each line of code believed to be executable.

Speakability, following, demonstrates that two items of sample text can indeed be

translated into JCB-English.

Results

Each of the following test cases involved the same input data, that there is a super-user

(the first user) named "operator", with a password of "secret", and that according to that

user, speaking as a common user, and that Earth is a planet:

add user operator password 'secret' execute

owner 0 planet "earth"

Each input file (unless otherwise noted) begins with:

i am operator with password 'secret' execute

Above and below, blue shows keywords recognized in the JCB-English language. The

following table shows the input from the test-case file, the output displayed in response,

and the data stored. In the output data stored, the initial knowledge, above, is not shown.

If deletions are made to this knowledge, then those deletions will be shown in

strikethrough font.

— 46 —

Case Input and Display Storage

1 > for all x y sub 2 true

This was already known.

(unchanged)

2 > there exists x y such that false

That would contradict information already held.

(unchanged)

3 > there exists at least 1 x such that be x

my cat

This information is being saved.

owner 0 there exists at

least 1 x such that

both *be x b sub

1000000/ and both

*be b sub 1000000 1

*cat// and *own

"operator" k sub

1000000/

4 > there does not exist x such that both cat

x and blue x


owner 0 there exists 0 x

such that both *cat

x/ and *blue x/

— 47 —


5 > either say "streak" 'meow' or say

"streak" 'woof' execute


> say "streak" either 'meow' or 'woof'


owner 0 either *say

"streak" 'meow'/ or

*say "streak" 'woof'/

6 > neither be me you nor be i your cat


owner 0 neither *be

"operator" "j c b"/

nor both *be

"operator" b sub

1000000/ and both

*be b sub 1000000 1

*cat// and *own

"operator" b sub

1000000/

7 > certainly be "streak" the sum of 0 and 1

cat


owner 0 certainly *be

"streak" 1 *cat//

— 48 —


8 > on good authority be "streak" the

difference between the product of 3 and

3 and the quotient of 16 and 2 cat


owner 0 on good

authority *be "streak"

1 *cat//

9 > as a belief the statement cute x is

implied by cat x execute


> as a guess if dog x then friend x


owner 0 as a belief if

*cat x/ then *cute x/

execute

owner 0 as a guess if

*dog x/ then *friend

x/

10 > according to "socrates" if and only if

exist i then think i


owner 0 according to

"socrates" if and only

if *exist "operator"/

then *think

"operator"/

— 49 —


11 > likely exclusively dog "streak" or cat

"streak" execute


> it is not the case that cat i is true


owner 0 likely

exclusively *dog

"streak"/ or *cat

"streak"/ execute

owner 0 it is not the

case that *cat

"operator"/ is true

12 > adjective jointly black and brown affects

cat "streak"


owner 0 adjective jointly

*black/ and *brown/

affects *cat "streak"/

13 > cat "streak" execute


> dog "fido" execute


> cat what execute

Answer: "streak"

> dog which

Answer: "fido"

owner 0 *cat "streak"/

execute

owner 0 *dog "fido"/

— 50 —




> blank "streak" execute

Answer: *cat "streak"/

> blank "nemo"

I don't have the answer to that question.


15 > adjective go anything emphasis affects

school "m i t"


owner 0 adjective *go

anything emphasis/

affects *school "m i

t"/

16 > be "streak" the item 1 cat with property

love i


owner 0 *be "streak" b

sub 1000000/ execute

owner 0 *be b sub

1000000 1 *cat//

execute

owner 0 *love "operator"

b sub 1000000/

— 51 —


17 > gullible most of the class human execute


> liar all of the class politician


owner 0 *gullible most

of the class *human//

execute

owner 0 *liar all of the

class *politician//

18 > good some of the event surprise anything

me execute


> good anything little of the event surprise

anything me execute


> desire i the event *with you the class

force


owner 0 *good some of

the event *surprise

"operator"// execute

owner 0 *desire

"operator" 1 the event

*with "j c b" 1 the

class *force///

— 52 —


19 > like i the number 3.1415926 execute


> nice all the class cat execute


> nice 1000000 dog execute


> nice how many of the class cat execute

Answer: all of the class *cat/

> nice how many dog

Answer: 1000000 *dog/

owner 0 *like "operator"

the number

3.1415926/ execute

owner 0 *nice all of the

class *cat// execute

owner 0 *nice 1000000

*dog//

20 > like i both 1 aardvark and 1 bear execute


> like i neither 1 cat nor 1 dog execute


> like i the item 1 elephant is implied by 1

fox execute


> like i if 1 gazelle then 1 hamster execute


> like i if and only if 1 iguana then 1 jaguar


1 *aardvark// execute


1 *bear// execute

owner 0 neither *like

"operator" 1 *cat//

nor *like "operator" 1

*dog//

execute

— 53 —


execute


> like i exclusively 1 kangaroo or 1 llama


owner 0 if *like

"operator" 1 *fox//

then *like "operator" 1

*elephant// execute

owner 0 if *like

"operator" 1

*gazelle// then *like

"operator" 1

*hamster// execute

owner 0 if and only if

*like "operator" 1

*iguana// then *like

"operator" 1 *jaguar//

execute

owner 0 exclusively *like

"operator" 1

*kangaroo// or *like

"operator" 1 *llama//

— 54 —


21 > grant 1 cat/ you the property happy


owner 0 *grant 1 *cat/

"j c b" 1 the property

*happy//

22 > at noon go i 1 home execute


> on tuesday go i 1 school


owner 0 at june 17 2007

12:00 *go "operator" 1

*home// execute


*go "operator" 1

*school//

23 > after august go "rachael" 1 school

execute


> on or after next week go i 1 school

execute


> when go "rachael" 1 school

Answer: on or after september 1 2007

owner 0 on or after

september 1 2007 *go

"rachael" 1 *school//

execute

owner 0 on or after july

1 2007 *go "operator"

1 *school//

— 55 —


24 > potentially burn the class wood execute


> when burn the class wood

Answer: potentially

owner 0 potentially

*burn 1 the class

*wood//

25 > beginning last month ending this year

magic 1 frog


owner 0 beginning may 1

2007 ending before

january 1 2008 *magic

1 *frog//

26 > beginning after today located at "u i s"

whatever execute


> bye

owner 0 beginning after

june 18 2007 located

at "u i s" *whatever/

27 > before now located at a distance of

3000000 meters from "u i s" whatever


owner 0 before june 17

2007 22:02:18.632

located at a distance

of 3000000 meters

from "u i s"

*whatever/

— 56 —


28 > on or before yesterday located at a

distance of up to a meter from "u i s"

whatever


owner 0 on or before


at a distance of up to

1 meters from "u i s"

*whatever/

29 > ending before tomorrow located at a

distance of at least a meter from "u i s"

whatever


owner 0 ending before


at a distance of at

least 1 meters from "u

i s" *whatever/

30 > during 11:00 am through 2:00:00 pm

located at a range of 1 meter to 100

meters from "u i s" whatever


owner 0 during june 17

2007 11:00 through

june 17 2007 14:00

located at a range of

1 meters to 100

meters from "u i s"

*whatever/

— 57 —


31 > at 6:00 near "u i s" whatever



6:00 near "u i s"

*whatever/

32 > at midnight far from "u i s" whatever

execute


> where whatever

Answer: far from "u i s"


far from "u i s"

*whatever/

33 > at april 15 whatever execute


> tense whatever

Answer: at april 15 2007

owner 0 at april 15 2007

*whatever/

34 > at april 15 2005 12:00 whatever


owner 0 at april 15 2005

12:00 *whatever/

— 58 —


35 > at offset a year before offset 2 months

from offset 3 days from offset 4 hours

from offset 5 minutes from offset 6

seconds from april 15 2005 bce 12:00

whatever



bce 16:05:06

*whatever/

36 > add user abe execute

> trust abe execute

> add user bob execute

> trust bob to level 0.5 execute

> add user sales execute

> do not trust sales execute

> drop user sales execute

> bye execute

> i am abe

add user abe execute

execute trust user bob

to level 0.5 execute

execute trust user sales

to level 0.0

— 59 —


37 > name of user operator is "sheldon"

execute

> commoner execute

> cool i execute


> ex progmatica execute

> guy i


owner 0 *cool "sheldon"/

execute

*guy "sheldon"/





> forget cat "streak"


— 60 —



> cat "streak" execute


> bye execute

> i am abe execute



> list facts execute

Fact 0: *planet "earth"/

Fact 1: *cat "streak"/

Fact 2: *dog "fido"/

> list facts i control

Fact 2: *dog "fido"/



execute


— 61 —







> mouse "mickey" execute


> forget fact 1


owner 0 *mouse

"mickey"/ execute


— 62 —





> bye execute

> i am abe execute



> mouse "mickey" execute


> bye execute

> i am operator with password 'secret'

execute

> forget what operator said execute

> trust what abe said


owner 0 *planet "earth"

execute

*dog "fido"/ execute

*mouse "mickey"/

— 63 —




> is cat "streak" true execute

Yes.

> is dog "streak" true execute

There is insufficient information to say.

> is it is not the case that cat "streak" is

true true

No.




> for which x is cat x true

This information is being saved. Note that this

answer is the result of getting no items in the

list returned from RelFun. The empty result

here is because the RelFun interface is

currently stubbed out.


— 64 —


44 > there exists at most 1 x such that

president x

STUBBED CODE: THERE EXISTS AT MOST

n

(unchanged)

45 > there exists 1 x such that best x

STUBBED CODE: THERE EXIST EXACTLY

n

(unchanged)

46 > potentially near "uis" burn the class wood

execute


> potentially near "uis" burn the class

blank

Answer: *wood/

owner 0 potentially near

"uis" *burn 1 the class

*wood//

— 65 —


47 > located at a distance of 1000 meters

from "u i s" according to me burn the

class wood execute


> located at a distance of 1000 meters

from "u i s" according to what burn the

class wood

Answer: "operator"

owner 0 located at a

distance of 1000

meters from "u i s"

according to

"operator" *burn 1 the

class *wood//

— 66 —


48 > located at a distance of 1000 meters

from "u i s" according to 1 person burn

the class wood execute


> consider facts only execute

> where according to 1 person burn the

class wood execute


> consider opinion to level 0.4 execute


class wood execute

Answer: located at a distance of 1000

meters from "u i s"

> consider opinion execute


class wood

Answer: located at a distance of 1000

meters from "u i s"


distance of 1000

meters from "u i s"

according to 1

*person/ *burn 1 the

class *wood//

— 67 —


49 > go i execute


> potentially hop i execute


> is go i true execute

Yes.

> is potentially go i true execute

Yes.

> is hop i true execute

There is insufficient information to say.

> is potentially hop i true

Yes.

owner 0 *go "operator"/

execute

owner 0 potentially *hop

"operator"/

50 > near "u i s" go i execute


> where go i

Answer: near "u i s"

owner 0 near "u i s" *go

"operator"/

— 68 —


51 > go i execute


> both true and true execute


> both false and false execute


> both blank i and cat "streak"


owner 0 *go "operator"/

52 > it is not the case that it is not the case

that false is true is true


(unchanged)

53 > idle execute

> collect garbage

(unchanged)

54 > text 'it''s fun'


owner 0 *text 'it''s fun'/

55 > nice .5 the class dog


owner 0 *nice 0.5 the

class *dog//

— 69 —


56 > add user bob execute

> trust what bob said

add user bob


> bye execute

> i am bob execute

> forget fact 0

You must be Operator to execute the command.

(halted [because of the test

environment only])


> bye execute

> i am bob execute

> forget planet "earth"

You must be Operator to execute the command.


environment only])

59 > is planet "earth" false

No.

(unchanged)

60 > for which x is cat x false

No answers found for the question.

(unchanged)

— 70 —


61 > i am operator with password 'secret'

execute

> add user bob execute

> bye execute

> i am bob execute

> blank "earth"

Answer: *planet "earth"/

add user bob

62 > for all x before noon according to me

near "u i s" it is not the case that flat

"earth" is true execute


> for all x located at a distance of a meter

from "u i s" flat "earth" execute


> for all x both flat "earth" and planet

"mars" execute


> for all x like i the item the sum of y and

z cat with property own execute

owner 0 before june 17

2007 12:00 according

to "operator" near "u i

s" it is not the case

that *flat "earth"/ is

true execute


distance of 1 meters

from "u i s" *flat

"earth"/ execute


b sub 1000000/

— 71 —



> for all x like i the number 3.1415926

execute

for all x near x flat "earth"


execute

owner 0 *be b sub

1000000 the sum of y

and z *cat// execute

owner 0 *own emphasis b

sub 1000000/ execute


the number

3.1415926/ execute

owner 0 for all x near x

*flat "earth"/

— 72 —


63 > located at a distance of the sum of x and

3000000 meters from "u i s" certainly

according to me both it is not the case

that planet "pluto" is true and flat

"earth" execute


> forget located at a distance of the sum

of 3000000 and x meters from "u i s"

certainly according to me both it is not

the case that planet "pluto" is true and

flat "earth" execute

> for all x near "u i s" interesting

'supercalifragilisticexpialidocious' x

execute


> forget for all x near "u i s" interesting

'supercalifragilisticexpialidocious' x

execute

> at noon potentially like i the number

3.1415926 execute


(unchanged)

— 73 —


64 > like i the item the number x with

property apple execute


> forget like i the item the number x with

property apple

No such statement was on file: both *like

"operator" c sub 1000000/ and both *be

c sub 1000000 the number x/ and *apple

emphasis c sub 1000000/ Note that an

improvement is possible to deal with this sort of

situation: If a variable is involved in a

percolation, don't introduce a new variable.


environment only])

65 > mismatch execute


> forget mismatch 1 cat

No such statement was on file: *mismatch 1

*cat//


environment only])

— 74 —


66 > mismatch 2 cat execute


> forget mismatch 2 cat/ 3 dog

No such statement was on file: *mismatch 2

*cat/ 3 *dog//


environment only])

67 > certainly like i the sum of x and y cat

execute


> like i what execute

Answer: the sum of x and y *cat/

> like "sam" the number 3.1415926 execute


> like "sam" what

Answer: the number 3.1415926

owner 0 certainly *like

"operator" the sum of

x and y *cat//

execute

owner 0 *like "sam" the

number 3.1415926/

— 75 —


68 > located at a range of 3000000 meters to

1 meter from "u i s" like i the class cat

execute


> located at a range of 3000000 meters to




range of 3000000

meters to 1 meters

from "u i s" *like

"operator" 1 the class

*cat//



execute


> located at a range of x meters to x

meters from "u i s" like i the class cat



range of 3000000

meters to 1 meters

from "u i s" *like


*cat// execute


distance of x meters

from "u i s" *like


*cat//

— 76 —



1000000 meters from "u i s" like i the

class cat



distance of up to

1000000 meters from

"u i s" *like


*cat//

71 > located at a distance of 100 meters from

"u i s" like i "toni" execute


> forget located at a distance of 100

meters from "u c l a" like i "toni"

No such statement was on file: located at

a distance of 100 meters from "u c l a"

*like "operator" "toni"/

(Halted [because of the test

environment only])

— 77 —





> forget located at a distance of up to 100

meters from "u i s" like i "toni"

No such statement was on file: located at a

distance of up to 100 meters from "u i s"

*like "operator" "toni"/


environment only])




> forget located at a distance of 200

meters from "u i s" like i "toni"

No such statement was on file: located at a

distance of 200 meters from "u i s" *like

"operator" "toni"/


environment only])

— 78 —


74 > like i the number the sum of x and y

execute


> like i the number the product of x and y

execute


> like i the number the sum of x and z

execute


> like i the number the sum of 0 and x

execute


> like i the number the sum of x and 0

execute


> like i the number the difference between

x and 0 execute


> like i the number the product of 1 and x

execute


the number the sum of

x and y/ execute


the number the

product of x and y/

execute


the number the sum of

x and z/ execute


the number x/ execute


the number 0/

— 79 —


75 > like i the number the sum of x and y

execute


> forget like i the number the product of x

and y

No such statement was on file: *like "operator"

the number the product of x and y/


environment only])

76 > like i the number the difference between

x and y execute


> forget like i the number the difference

between y and x

No such statement was on file: *like "operator"

the number the difference between y and

x


environment only])

— 80 —


77 > both it is not the case that planet

"earth" is true and planet "mars" execute


> either planet "earth" or planet "mars"

execute


> neither planet "earth" nor planet "mars"

execute


> if planet "mars" then planet "earth"

execute


> adjective green affects it is not the case

that planet "earth" is true


(unchanged)

78 > both like i the number 1 and true execute


> both it is not the case that like i the

number 2 is true and it is not the case


the number 1/ execute


"operator" the number

— 81 —


that like i the number 3 is true execute


> either false or like i the number 4

execute


> either like i the number 5 or false

execute


> neither like i the number 6 nor false

execute


> neither false nor like i the number 7

execute


> neither it is not the case that like i the

number 8 is true nor it is not the case

that like i the number 9 is true execute


> if true then like i the number 10 execute


2 / nor *like


3/ execute


the number 4/

execute


the number 5/

execute


case that *like


6/ is true execute


case that *like


7/ is true execute


the number 8/

— 82 —


> exclusively like i the number 11 or false

execute


> exclusively it is not the case that like i

the number 12 is true or like i the

number 13 execute


> exclusively it is not the case that like i

the number 14 is true or it is not the

case that like i the number 15 is true

execute


> exclusively like i the number 16 or it is

not the case that like i the number 17 is

true execute


> if and only if false then like i the number

18 execute


> if and only if like i the number 19 then

execute


the number 9/

execute


the number 10/

execute


the number 11/

execute


*like "operator" the

number 12/ then *like


13/ execute



14/ or *like "operator"

the number 15/

— 83 —


false execute


> if and only if it is not the case that like i

the number 20 is true then like i the

number 21 execute


> if and only if it is not the case that like i

the number 22 is true then it is not the

case that like i the number 23 is true

execute


> if and only if like i the number 26 then it

is not the case that like i the number 27

is true


execute





17/ execute


case that *like


18/ is true execute


case that *like


19/ is true execute



20/ or *like


21/ execute

— 84 —






23/ execute



26/ or *like


27/

79 > near "u i s" both true and cat "streak"

execute


> at noon both true and far from "u i s"

cat "streak"


owner 0 near "u i s"

*cat "streak"/

execute


12:00 far from "u i s"

*cat "streak"/

— 85 —


80 > near "u i s" for all x cat "streak"

execute


> at noon for all x far from "u i s" cat

"streak"


owner 0 near "u i s"

*cat "streak"/

execute


12:00 far from "u i s"

*cat "streak"/

81 > be "streak" 1 either cat or dog


owner 0 either *be

"streak" 1 *cat// or

*be "streak" 1 *dog//

82 > like i 1 of dog



1 *dog//

83 > like i the sum of x and 2 dog execute


> like i the sum of x and how many dog

execute

Answer: 2

> like i the sum of y and how many dog



the sum of x and 2

*dog//

— 86 —


84 > like i 'this thing: "'



'this thing: "'/

85 > it is not the case that either like i the

number 1 or like i the number 2 is true

execute


> it is not the case that neither like i the

number 3 nor like i the number 4 is true

execute


> it is not the case that if and only if like i

the number 5 then like i the number 6 is

true execute


> it is not the case that exclusively like i

the number 7 or like i the number 8 is

true execute


> it is not the case that both like i the



1/ nor *like "operator"


owner 0 either *like












8/ execute

— 87 —


number 9 and like i the number 10 is true

execute


> it is not the case that both it is not the

case that like i the number 11 is true and

it is not the > case that like i the number

12 is true is true



case that both *like


9/ and *like "operator"

the number 10/ is true

execute




the number 12/

— 88 —


86 > according to the class astronomer/ it is

not the case that planet "pluto" is true

execute


> forget at noon according to the class

astronomer/ it is not the case that

planet "pluto" is true

No such statement was on file: at june 18

2007 12:00 according to 1 the class

*astronomer/ it is not the case that

*planet "pluto"/ is true


environment only])

— 89 —


87 > either like i the number 1 or both like i

the number 2 and if like i the number 3

then like i the number 4 execute


> adjective nice affects cat "streak"

execute




1/ or both *like


2/ and if *like


3/ then *like


4/ execute

owner 0 adjective *nice/

affects *cat "streak"/

88 > collection "one" "two" "three" "four"


owner 0 *collection

"one" "two" "three"

"four"/

— 90 —


89 > beginning january 1 like i "al" execute


> at january 2 like i "al" execute


> beginning after january 1 like i "bob"

execute


> at january 2 like i "bob" execute


> before january 3 like i "charlie" execute


> at january 2 like i "charlie" execute


> during january like i "dan" execute


> at january 2 like i "dan" execute


> ending february like i "ed" execute


> at january 2 like i "ed"


owner 0 beginning

january 1 2007 *like

"operator" "al"/

execute

owner 0 beginning after

january 2 2007 *like

"operator" "bob"/

execute

owner 0 before january

3 2007 *like

"operator" "charlie"/

execute

owner 0 during january 1

2007 *like "operator"

"dan"/ execute

owner 0 ending before

march 1 2007 *like

"operator" "ed"/

— 91 —


90 > at offset 1 week from tomorrow there

exists at least 1 x such that cat x

execute


> like i what execute


> when planet "earth" execute


> there exists at least 0 x such that dog x

execute


> there exists at most 0 x such that

starship x



there exists at least 1

x such that *cat x/

execute

owner 0 there exists 0 x

such that *starship x/

Speakability

Here, the speakability of JCB-English is demonstrated. The first example is an informal

text, and can be translated loosely:

Once upon a time, there were three little pigs. One pig made a house of

straw, one made a house of sticks, and one made a house of bricks.

— 92 —

This can be translated as:

before now both be x 3 adjective little affects pig and both

member x sub 1 x and both member x sub 2 x and both member

x sub 3 x and both build x sub 1 1 adjective straw affects house

and both build x sub 2 1 adjective stick affects house and build

x sub 3 1 adjective brick affects house

As an example of a more formal document, the author calls into evidence what many

would call the oldest formal document still in good standing. Since this document is

older than English, proper translation should be from the original language, and not from

an English translation. Below are shown the original, modern but formal English, and

JCB-English. First, the original:

הארץ ואת השסים את אלהים ברא בראשית

וכהו תהו היתה והארץ…

Rendered into rather exact English, word-by-word (actually, letter-by-letter, in some

cases), that becomes:

At-[the]-root-[of everything]*, created elohim** the-depths-of-space***

and the-land. And-the-land was unformed and-void…

*Root word is "head"

**G-d, god, gods, spirit, or spirits (since the sentence is in the singular, but

the word is in the pleural, this is taken to mean the royal conjugation)

***Root word is "water"

— 93 —

In JCB-English, this becomes:

There exists one x such that for all y if it is not the case that

is x y then cause x y and both be x the event create 1 elohim

both the class space and the class land and both it is not the

case that form anything the class land is true and both void the

class land and for all z if elohim z then both god z and both

spirit z and monarch z

Thus, it has been shown that text can, in general, be translated to JCB-English.

— 94 —

CONCLUSIONS

The test results show a number of things about the JCB-English language, and the

program which implements much of it:

• The language is speakable.

• On a G4 laptop, running in Java, the current implementation is fast enough for a

single-user system.

• The current implementation is slow enough that someone paying close attention can

see the processing delays.

• The language can be understood with a minimum of description, but cannot be

understood by the uninitiated.

• The language can be spoken with some practice.

• Even with the logic not yet using RelFun, the system has already been known to

"outsmart" the author, in that some of the initial test input files led to conclusions

which the author had not noticed.

As with any project, taking a step forward shows that there are still many steps to be

taken. With this in mind, the following list represents improvements that could be made

to the project at a later time:

• First and foremost, completion of the RelFun interface.

• Addition of alternate input languages.

• Addition of alternate output languages.

• Addition of the option to output formally, or in normal English (or another language).

— 95 —

• Addition of "also" to the language, which would be an infix operator between sub-

utterances. It would have the same effect as "both"/"and", but would not require as

much forethought. Thus, items of the form "both love i 1 mom and both love i 1

dad and both love i 1 wife and love i 3 child" could be replaced with "love i 1

mom also love i 1 dad also love i 1 wife also love i 3 child".

• Addition of degrees, allowing things like "very", by changing "adjective preposition

affects preposition" to "adjective preposition affects [[with] degree

numericExpression preposition" and "adjective preposition degree affects

preposition", where degree could be any of "slightly", "somewhat", "greatly", or

"exceedingly".

• Although an adjectival capacity of the form already in the language is required, the

language could benefit from the addition of a simpler form, in which two consecutive

propositions would form an adjectival modifier, in which the preposition on the left

affects the one immediately on the right. So, the English phrase "pretty little girl

school" now translates (assuming it means a school for girls, when those girls are little,

where such school is pretty) as "adjective pretty affects adjective adjective

little affects girl affects school", but could with this addition, be phrased

"adjective pretty affects little girl school".

• Addition of context-mapping on output. This could include simple context, such as

changing a user name to "you" or the machine name to "i", or more complex

mappings, such as reducing items back to using "own" and "with property", then to

"your" and "my".

— 96 —

• The system could use a rewrite to a server configuration.

• The system could use a rewrite to a language designed for speed.

• Addition of list and set syntax.

• Addition of special predications for numbers and sets, such as equal, greater,

intersection, and the like.

• To simplify the input of logical notions, special tables could be used. For instance, the

addition of superset, equivalent, opposite, chain could simplify the knowledge base

and perhaps speed processing, too. For instance, "superset dinosaur brontosaurus"

would be the same as "for all x if brontosaurus x then dinosaur x". "equivalent

heavy weighty" would be the same as "for all x y if and only if heavy x y then

weighty x y". "opposite tall short" would be the same as "for all x y if and

only if tall x y then short y x". "chain old" would mean "for all x y z if both

old x y and old y z then old x z".

• Logic could be a bit better if, when percolating a construct, no new variables were

introduced if one of the terms was already a variable. For instance, currently "like i

my x" currently expands to "both be b sub 1000000 x and both own "operator"

b sub 1000000 and like "operator" b sub 1000000", but could be better

expressed as "both own "operator" x and like "operator" x".

— 97 —

Finally

In closing his first article on Loglan, Dr. Brown (1960) stated,

We are by no means certain yet that Loglan is a thinkable language, let

alone a thought-facilitating one. But there is some prospect that [it] will

facilitate experimental investigation…

We now know that Loglan is all these things.

— 98 —

VITA

Sheldon Linker

Education B.S. in Applied Science and Technology with an area of study in

Computer Science and Technology from Thomas Edison State College

Experience Scientific programmer for CalTech/NASA Jet Propulsion Laboratory

Systems programmer for U.C. Berkeley

Programming Advisor for U.C.L.A. Graduate School of Management

Programmer/Systems Analyst for TRW and their clients

Systems programmer for Alpha Microsystems

Programmer, Systems analyst, and supervisor for Linker Systems and

clients of Linker Systems; VP of Linker Systems

Coursework Fall 2006 CSC 479 - Introduction to Artificial Intelligence

CSC 582 - GUI Design

Spring 2007 CSC 574 - Distributed Computing

CSC 540 - Graduate Research Seminar

Summer 2007 CSC 470 - Biometrics

Fall 2007 CSC 570D - Artificial Intelligence

CSC 570S - Wireless/Mobile Networks

— 99 —

APPENDIX I

A LOGLAN PRIMER

Loglan is a predicate-based language. In Loglan, the difference between a verb, a

noun, and an adjective or adverb is where the predication is placed in the language

structure. For instance,

Loglan Literal

translation

Idiomatic

translation Functional parse

Cmalo Small Be small. Predicate("Cmalo")

Tu cmalo You small You have the

capacity to be small;

You are smaller than

[some x]

Predication(

Argument(

Pronoun("Tu")),

Predicate("Cmalo"))

Tu na cmalo You now small You are small Predication(

Argument(

Pronoun("Tu")),

Case("Na",Predicate(

"Cmalo")))

— 100 —

Loglan Literal

translation

Idiomatic


Bilti cmalo

ckela

Pretty small

school

Prettily small

school: A school

that is small, such

that the Smallness is

a pretty form of

smallness

Adjective(Adjective(

"Bilti","Cmalo"),

Predicate("Ckela"))

Bilti ge cmalo

ckela

Pretty type of

small school

Pretty small school:

A small school,

which is pretty

Adjective("Bilti",

Case("Ge",Adjective(

"Cmalo",Predicate(

"Ckela"))))

Bilti e cmalo

ckela

Pretty and small

school

Something which is

pretty, and a small

school

Operation("E",

Predicate("Bilti"),

Adjective("Cmalo",

Predicate("Ckela")))

Bilti e cmalo gu

ckela

Pretty and small

type of school

A school, which is

pretty and small

Adjective(Operation(

"E","Bilti","Cmalo"),

Predicate("Ckela"))

— 101 —

Loglan Literal

translation

Idiomatic


Le ckela ga

cmalo

The school is

small

The school is small Predication(

Argument(

Article("Le",

Predication(

Predicate("Ckela")))

),Case("Ga",

Predicate("Cmalo")))

Of course, one need not use the Loglan vocabulary to carry out Loglan's

functions. Loglan's vocabulary was designed to be unambiguously parseable in

continuous verbal stream. However, there is no reason that an English vocabulary could

not be used in a printed communication. For instance,

English (ambiguous): Pretty little girls' school

Loglan (unambiguous): Bilti ge cmalo nirli ckela

Hybrid (unambiguous): Pretty type of school for girls who are small

Loglan was designed by Dr. Brown to be unambiguous. By the time Michael

Urban and the author joined the project, Dr. Brown had a grammar, written in a BNF-like

notation. The grammar was then translated into YACC input format. With some hints

from Michael Urban and Dr. Brown, the author came up with a grammar which met the

— 102 —

requirements of Loglan, and which was provably unambiguous. Two versions of this

were published in The Loglanist (a.k.a. La Loglantan, Linker 1980 and 1981). Later,

Jeff Prothero (1990) and others (Prothero et al, 1994) made continuing improvements to

the Loglan grammar, and wrote a series of parsers for Loglan. Unfortunately, these

parsers never went past graphing the sentences, and stating whether a given "utterance"

of Loglan was legal or not.

— 103 —

APPENDIX II

TRANSFORMATIONS OF LOGLAN INTO FUNCTIONAL FORM

Step 1: The Loglan Grammar

Some say that the Loglan grammar was superceded by Lojban, but for the present

purposes, the simpler the better. The text shown in courier is as it is delivered by HTTP

and published by The Loglan Institute, Inc (Prothero et al, 1994). This code is used and

reproduced here with specific permission. Various "trials" are referenced. Trial 1 was

written by this author, with the extensive testing and modification help of Mike Urban

and James Brown. Trial 2 was also work the work of this author. The additional 78 trials

represent additions and changes to the work, done by others.

C-code and some other items have been stripped for clarity. Items shown in

Times New Roman italic typeface are the author's comments.

/* GRAMMAR 80 Loglan grammar as of Dec 94

Copyright ©1982, 1984, 1986-1995 by The Loglan Institute,

Inc.

Created in Jan-Feb 82 from JSP's Aug 81 grammar by SWL &

JCB, Modified in Mar 82, Dec 83, Mar 84, and Dec 86 - Jun

87 by JCB. and in 1987-90 by RAM.

— 104 —

Translation: Sheldon Linker and James Cooke Brown worked together on a

grammar, which was converted to a full parser by Jeff Prothero, and later improved by

Robert McIvor. By 1981, the author had left UCLA, and had begun to work for TRW.

TRW was kind enough to allow the author to continue the work on this project at their

facility, and cleared the work for publication.

Trial 80 was created in Dec 94, include luo and lou, mea,

nuo, fuo, and juo. The preparser was adjusted to allow for

the other Keugru-mediated changes. Still in abeyance is

whether duo, dui should go to the bi lexeme, whether fio,

foi and suo should be included in advance of approval.

Other comments on various trials ranging from 1987 through 1993 have been

stripped out.

*/

%token A1

%{/*: a1 zea */

%} /* used for A when connecting predicates */

%token A2

%{/*: a2 */

%} /* used for A when connecting linkargs or modifiers */

%token A3

%{/*: a3 */

%} /* used for A when connecting argmods */

%token A4

%{/*: ha a e o u */

— 105 —

%} /* also CPDs anoi, apa, noanoi, etc. Used for all

other A */

%token ACI

%{/*: */

%} /* recognized by CPD-lexer */

%token AGE

%{/*: */

%} /* recognized by CPD-lexer. */

%token BI

%{/*: bi bia bie cie cio */

%}

%token BAD

%{/*: */

%}

%token CA

%{/*: ca ce co cu */

%} /* also CPDs noca, canoi, nocanoi, etc. */

%token CI

%{/*: ci */

%}

%token CUI

%{/*: cui */

%}

%token DA

— 106 —

%{/*: ba be bo bu da de di do du mi tu mu ti ta tao tio

tua mia mie mii mio miu mua mue mui muo muu toa toi tue tui

tuo tuu suo */

%}

%token DIE

%{/*: die fie kae nue rie */

%}

%token DIO

%{/*: beu cau dio foa kao jui neu pou goa sau veu zua

zue zui zuo zuu lae lue */

%}

%token DJAN

%{/*: */

%} /* all C-final words found by lexer */

%{#define END 0

/*: . */

%}

%token FI

%{/*: fi */

%}

%token GA2

%{/*: ga */

%}

%token GE

— 107 —

%{/*: ge */

%}

%token GEU

%{/*: geu */

%}

%token GI

%{/*: gi goi */

%}

%token GO

%{/*: go */

%}

%token GU

%{/*: gu */

%}

%token GUE

%{/*: gue */

%}

%token GUI

%{/*: gui */

%}

%token GUO

%{/*: guo */

%}

%token GUU1

— 108 —

%{/*: guu */

%}

%token GUU2

%{/*: guu2 */

%}

%token HOI

%{/*: hoi */

%}

%token I

%{/*: i */

%} /* also CPDs ifa, inusoa, etc. */

%token ICA

%{/*: */

%} /* all eeskeks, recognized by lexer */

%token ICI

%{/*: */

%} /* ici & icaci-type words, all recognized by CPD-

lexer */

%token IE

%{/*: ie */

%}

%token IGE

%{/*: */

— 109 —

%} /* ige & icage-type words, all recognized by CPD-

lexer */

%token JE

%{/*: je */

%}

%token JI

%{/*: ji ja jie jae pe */

%}

%token JIO

%{/*: jio jao */

%}

%token JO

%{/*: jo */

%} /* also CPDs rajo, tojo, etc. */

%token JUE

%{/*: jue */

%}

%token KA1

%{/*: ka1 */

%} /* used for KA when connecting linkargs */

%token KA2

%{/*: ka2 */

%} /* used for KA when connecting predicates */

%token KA3

— 110 —

%{/*: ka ke ko ku */

%} /* also CPDs kanoi, nuku, nukunoi, kouki, nukouki,etc.

For the rest */

%token KOU

%{/*: kou moi rau soa */

%} /* these are pa words separated out for the lexer */

%token KI

%{/*: ki */

%} /* also the CPD kinoi */

%token KIE

%{/*: kie */

%}

%token KIU

%{/*: kiu */

%}

%token LAO

%{/*: lao */

%}

%token LAU

%{/*: lau lou */

%}

%token LE

%{/*: le la lo lea leu loe lee laa */

%}

— 111 —

%token LEPO

%{/*: */

%} /* recognized by CPD-lexer*/

%token LI

%{/*: li */

%}

%token LIE

%{/*: lie */

%}

%token LIO

%{/*: lio */

%}

%token LIU

%{/*: liu lii niu */

%}

%token LU

%{/*: lu */

%}

%token LUA

%{/*: lua luo */

%}

%token SOI

%{/*: soi */

%}

— 112 —

%token MA

%{/*: ma si */

%} /* to recognize initial vowels in acronyms, NI otherwise

*/

%token ME

%{/*: me mea */

%}

%token NI

%{/*: ho ni ne to te fo fe vo ve pi re ro ru sa se so su

mo kua gie giu hie hiu kue nea nio pea pio suu sua tia zoa

zoi */

%} /* also CPDs neni, nenisei, iesu, ietoni, etc. */

%token NO1

%{/*: no1 */

%} /* used for NO + mod shown by PA */

%token NO2

%{/*: no2 */

%} /* used for NO + markpred shown by PO, ZO or PA1 */

%token NO3

%{/*: no3 */

%} /* used for NO + argument */

%token NO4

%{/*: no */

%} /*For all other no's*/

— 113 —

%token NOI

%{/*: noi */

%}

%token NU

%{/*: nu fu ju nuo fuo juo */

%} /* also CPDs nufu, nufuju, nuto (=nu), nute (=fu), nufo

(=ju), nufe, nuso, etc. */

%token PA1

%{/*: pa1 */

%} /* used for PA and GA when inflecting a predicate */

%token PA2

%{/*: va vi vu pa na fa gia gua pia pua nia nua fia fua

via vii viu ciu coi dii duo gau kii lia lui mou hea peu rui

sea tie fio foi */

%} /* also CPDs pana, pazi, pacenoina, etc. For the rest

of PAs*/

%token PAUSE

%{/*: , # */

%}

%token PO

%{/*: po pu */

%}

%token PREDA

%{/*: he dua dui bua bui */

— 114 —

%} /* all preda-forms words; also all pred-wds found by

lexer, CPDs like rari, nenira, sutori, etc.; also acronyms

like ebai, baicai, ebaicai, ebaiocai, haitosaiofo, etc., */

%token RA

%{/*: ra ri */

%}

%token HUE

%{/*: hue */

%}

%token SUE

%{/*: sue sao */

%}

%token TAI

%{/*: gao */

%} /* forms like ama bai cai tai tei are recognized by

the lexer; CPDs like baicai, ebaicai, ebaiocai,

haitosaiofo, etc., belong to PREDA */

%token UI

%{/*: ua ue ui uo uu oa oe oi ou ia ii io iu ea ei eo eu

ae ai ao au bea biu buo cea cia coa dau dou fae fao feu gea

kuo kuu rea nao nie pae piu saa sui taa toe voi zou loi loa

sia sii siu cao ceu */

%} /* also CPDs nahu, vihu, kouhu, duohu, nusoahu, etc. */

%token ZE1

— 115 —

%{/*: ze */

%} /* also used by the preparser to recognize acronymic

PREDA's */

%token ZE2

%{/*: ze2 */

%} /* used for ZE + argsign */

%token ZI

%{/*: zi za zu */

%} /* used by the preparser to recognize pazi-CPDs and

acronymic PREDA's */

%token ZO

%{/*: zo */

%} /* used by the preparser to recognize acronymic

PREDA's; otherwise zo would be a member of PO */

%start utterance

%{

#define YYDEBUG 1

%}

%%

err : error

;

guo : GUO

| GU

— 116 —

| err

;

gui : GUI

| GU

| err

;

gue : GUE

| GU

| err

;

guu : GUU1

| GU

| err

;

lua : LUA

| err

;

geu : GEU

| err

;

gap : PAUSE

| GU

| err

;

— 131 —

uttD : uttC

| uttC ICI uttD

;

uttE : uttD

| uttE ICA uttD

;

uttF : uttE

| uttE I uttE

utterance : I

| freemod

| uttF

| I uttF

| ICA uttF

| uttE IGE utterance

;

%%

Not shown in these grammars, but very important, is that anywhere Gu is required, but

does not appear, that disappearance is forgiven, and Gu assumed. This is a context rule

similar to the usage of "else" in languages in the C and Cobol families. If statements

have an Else clause, but if the clause is missing, its absence does not affect anything.

— 132 —

Step 2: Change From YACC Input to BNF-Like Notation

Here, the grammar has been changed from YACC format to a more BNF-like

form, so that it can be more easily modified, and dealt with on a symbolic basis. The

items have also been rearranged based on their first reference. Herein, [ ] indicates an

optional production of the grammar.

Although it will not make any difference academically or mathematically, the

pronunciation scheme of Loglan words may aid in understanding. The consonants,

except C and J have their usual English sounds. The vowels have the usual Latin sounds.

C is pronounced as in English's "SH", and "J" is soft, sounding like the "s" in "treasure".

Thus, "jump shot" would be spelled "djump cot".

This section also corrects an error in the Loglan grammar. The production

"Predunit1 → Nu-class Ge-class DespredE Geu-class" is improper, in that if the item

following Ge is not trivial, then the Nu-class word has is too complicated to understand,

or has no meaning. Below, it is being dropped. The preferred production to take its place

is "Predunit1 → Nu-class DespredE".

— 133 —

Lexicon

A-class: A, E, Ha, O, U, Zea — These are infix connectors, such as And and

Or. Ha is special, in that it questions what the connection is. For

each item other than Ha, there are "no" forms. So, for A, there is

Noa, Anoi, and Noanoi.

Aci-class: Aci, Eci, Haci, Oci, Uci, etc — These are likewise infix connectors,

but with a different lexemic marking. The reason for the second

lexicon here is that it is required for unambiguous parsing. Note that

Haci is again a question-connector.

Age-class: Age, Ege, Hage, Oge, Uge, etc — Yet another set of infix

connectors.

Bi-class: Bi, Bia, Bie, Cie, Cio, etc — These are special predicates, respectively

"is", "is part of", "is a member of", "is less than", and "is more than".

Note than for each, there is a "no" form, such as Nobi and Nobia.

Ca-class: Ca, Ce, Co, Cu, etc — Yet another set of infix connectors.

Ci-class: Ci — Syntactically, this acts like a subscript. For instance, Da is "X"

and To is "2". Thus, Da Ci To, or Dacito, is "X2".

Cui-class: Cui — This is a marker denoting the start of a parenthetical infix

operation.

Da-class: Ba, Be, Bo, Bu, Da, De, Di, Do, Du, Mi, Mia, Mie, Mii, Mio, Miu, Mu,

Mua, Mui, Muo, Muu, Ta, Tao, Ti, Tio, Toa, Toi, Tu, Tua, Tue, Tui,

Tuo, Tuu, Suo — This class consists of pronouns, D_ being he/she/it,

— 134 —

referring back into the utterance, Hu being who/what/which, B_ being

"Some X", plus the usual collection of I, Me, You, We, and the like.

There is also M_i, "X and I/me" and Tu_, "You and X" Additionally,

there are demonstrative pronouns, and pronouns referring to stated

situations and remarks (for which English triples up on the use of

demonstratives).

Die-class: Die, Fie, Kae, Nue, Rie — These are various mood-setting attitudinal

indicators.

Dio-class: Beu, Cau, Dio, Foa, Goa, Kao, Jui, Lae, Lue, Neu, Pou, Sau, Veu,

Zua, Zue, Zui, Zuo, Zuu — These are "case tags", syntactical

indicators giving a slant to what follows, such as "Parts", "Values",

"Doers", "The addressee of", "Conditions", and a host of other,

related items.

Djan-class: Any word ending in a consonant — These are used as names. For

instance, Sheldon could be written as Celdn, but Jenny would by

convention pick up a trailing S, and become Djenis.

Ga-class: Ga — This is a syntactic marker, and has no meaning of its own.

Ge-class: Ge — "Type of". Actually a syntactic marker than resolves a

predicate string on its right before allowing the predicate on the left to

modify the list.

Geu-class: Geu — End marker for a Ge group.

— 135 —

Gi-class: Gi, Goi — These are end markers for displaced objects (objects not

following the predicate string in the normal location) and sentence

quantifiers.

Go-class: Go — "Such that", or inversion operator. Example, "X, such that X is

a man" is "Ba go ba mrenu".

Gu-class: Gu — End marker for many types of clauses

Gue-class: Gue — End marker for Je and Jue clauses

Gui-class: Gui — End marker for Ji and Ja clauses

Guo-class: Guo — End marker for Lepo clauses

Guu-class: Guu — End marker for Termset-rule clauses

Hoi-class: Hoi — "Hey" — Vocative mark

Hue-class: Hue — Introduces a predication as a vocative, as in "Hey, big guy!"

I-class: I, Ifa, Inodoa, etc — Loose sentence connectives, much like period,

semicolon, colon, em-dash, and the like.

Ica-class: Ica, Ice, Ico, etc — Logical sentence connectives, "And", "Or", and

the like.

Ici-class: Ici — The same logical sentence connectives, but with tighter

binding.

Ie-class: Ie — "Which" — Used to form a question where "A" or "The" would

otherwise be used.

Ige-class: Ige, Icage, etc — Logical paragraph connectives

— 136 —

Je-class: Je — Of/By/To — First connective link — Links first argument of

predication to another.

Ji-class: Ja, Jae, Ji, Jie, Pe — These are all lead-ins to continued

descriptives, such as "who/which is" (nonrestrictive and set

membership, respectively), "that is" (restrictive), "that is one of"

(membership), and "of" (possessive)

Jio-class: Jao, Jio — "Such that" (nonrestrictive and restrictive, respectively)

Jo-class: Jo, Rajo, Tojo, etc — Jo means to take things metaphorically. Rajo

means to take explicitly metaphorically. A number followed by -jo,

such as Tojo, means to take that many words metaphorically.

Jue-class: Jue — Of/to/by — Second descriptive link

Ka-class: Ka, Ke, Ko, Ku — These are prefix logical operators. For instance,

Ka… Ki is equivalent to "Either… Or".

Ki-class: Ki — Ki takes the place of And/Or/etc as the second word in a logical

prefix operation.

Kie-class: Kie — Left paren, the start of a parenthetical utterance.

Kiu-class: Kiu — Right paren, the end of a parenthetical utterance.

Lao-class: Lao — Signals a following non-Loglan name.

Lau-class: Lau, Lou — These words introduce unordered and ordered sets,

respectively.

— 137 —

Le-class: La, Laa, Le, Lea, Lee, Leu, Lo, Loe — These words are all like

"The". Their literal meanings are "The one named", "The unique

object, if any, which", "The", "The set of all", et cetera.

Li-class: Li — Left quotation mark.

Lie-class: Lie — Escape, or strong quotation mark.

Lio-class: Lio — "The number" — Turns a number into an object.

Liu-class: Lii, Liu, Niu — These are quotations of a single character, single

Loglan word, and single general word, respectively.

Lu-class: Lu — End of quotation

Lua-class: Lua, Luo — Close unordered and ordered sets, respectively.

Me-class: Me, Mea — Extensional markers

Ni-class: Hie, Hiu, Ho, Fe, Fo, Gie, Giu, Kua, Kue, Mo, Ne, Nea, Ni, Nio, Pea,

Pi, Pio, Re, Ro, Ru, Sa, Se, So, Sua, Suu, Te, Tia, To, Ve, Vo, Zoa,

Zoi — These are numbers, and include "All", "Most", "Some", and

the like, in addition to 0 through 9. Ho is special, in that it is the

numeric question, or "How many".

No-class: No — "No" and "Not"

Nu-class: Fu, Fuo, Ju, Juo, Nu, Nuo - These items serve to reverse two

arguments to a predicate. Their main use is that the first argument

only appears in sentences, but not in imperatives or predicate phrases.

Pa-class: Ciu, Coi, Dii, Duo, Fa, Fia, Fii, Foi, Fua, Gau, Gia, Gua, Hea, Kii,

Kao, Lia, Lui, Moi, Mou, Na, Nia, Nua, Pa, Pacenoina, Pana, Pazi,

— 138 —

Peu, Pia, Pua, Rau, Rui, Sea, Soa, Tie, Va, Vi, Via, Vii, Viu, Vu, etc

- These are tense markers. But in Loglan, the concept of tense goes

way past what we are used to. Pa, Na, and Fa are the familiar tenses.

Other tenses include "potentially", "instead", "since", "habitually",

and a large group of others. Note that Pa alone makes something past

tense. Pa with an argument says after when.

Po-class: Po, Pu, Zo — These words transform the following predication into

an event, a property, or an amount.

Pred-class: Bua, Bui, He, Dua, Dui, Nenira, Rari, Sutori, and all standard

predicate forms — In Loglan, predicates are recognizable, because

they have two or more syllables. The last syllable is consonant-

vowel. All but the last syllable is consonant-vowel-consonant, or

consonant-consonant-vowel. Words of 3 or more syllables are

compound words, and should be avoided for our purposes, since each

of them can be expressed as two or more atomic predicates. The

special short forms include "Is" and "Does". He is the questioning

word.

Soi-class: Soi — Marks a sound

Sue-class: Sao, Sue - Mark an onomatopoeia or a non-Loglan word.

Tai-class: Ama, Bai, Baicai, Cai, Ebaicai, Gao, Tai, Tei, etc — These are

examples of letters in other languages.

— 139 —

Ui-class: Ae, Ai, Ao, Au, Bea, Biu, Buo, Cao, Cea, Ceu, Cia, Coa, Dau, Dou,

Duohu, Ea, Ei, Eo, Eu, Fae, Fao, Feu, Gea, Ia, Ii, Io, Iu, Kouhu,

Kuo, Kuu, Loi, Loa, Nahu, Nao, Nie, Nusoahu, Oa, Oe, Oi, Ou, Pae,

Piu, Rea, Saa, Sia, Sii, Siu, Sui, Taa, Toe, Ua, Ue, Ui, Uo, Uu, Vihu,

Voi, Zou, etc — These are all attitudinal indicators, everything from

"Yes, hopefully" through "Annoyed".

Ze-class: Ze — "And jointly". In Loglan, we can translate a key objective

phrase from Genesis, "man and woman" as "Mrenu E Femna" or

"Mrenu Ze Femna". Translating this back to English, we get "man

and woman", two distinct people, or "man-and-jointly-woman", one

chimerical creature, not yet separated rib-wise.

Grammar

Utterance → I-class [ UttF ]

| Freemod

| Ica-class [ UttF ]

| UttE Ige-class Utterance

UttF → [ UttF I-class ] UttE

— 142 —

Mod → [ No-class ] Mod1

Kekmod → Ka-class Modifier Ki-class Mod

| No-class Kekmod

UttA → A-class

| Ie-class

| Mex

UttAx → Headterms Sen1

Links → [ Links A-class ] Links1

| Ka-class Links Ki-class Links1

Linkargs → [ Linkargs A-class ] Linkargs1

| Ka-class Linkargs Ki-class Linkargs1

Sen1 → Predicate

| Statement

| Keksent

Keksent → Ka-class [ Headterms ] Sentence Ki-class UttA1

| No-class Keksent

Barefront → Barepred

| Bareekpred Termset

Markfront → Markpred

| Markekpred Termset

Termset2 → [ Termset2 A-class ] Termset1

| Ka-class Termset2 Ki-class Termset1

Arg7 → Argx [ Aci-class Arg7 ]

— 143 —

Words → [ Words ] Word

Mod1 → Pa-class [ Argument ] Gu-class

Mex → [ Mex ] Ni-class

Headterms → [ Headterms ] Terms Gi-class

Linkargs1 → Jelink [ Links ] Gue

Barepred → Sentpred Termset

| Kekpred Termset

Bareekpred → Barefront A-class Backpred

Markpred | Pa-class Barepred

| Po-class Gu-class Sentence Gu-class

| No-class Markpred

Markekpred → Markfront A-class Backpred

Termset1 → Terms Guu

Argx → No-class Argx

| Arg6

Word → Arg1a Guu

| Ni-class Guu

| Ui-class Guu

| Pa-class Guu

| Dio-class Guu

| Predunit1 Guu

| Indefinite Guu

Jelink → Je-class Argument

— 146 —

Descpred → DescpredE [ Go-class Descpred ]

Name → [ Name [ Ci-class ] ] Djan-class

| Name Predunit

Descriptn → Le-class [ Mex ] Descpred

| Le-class Arg1 Descpred

| Le-class Mex Arg1a

Predunit → [ Predunit Ze-class ] Predunit4

Predunit4 → [ Po-class ] Predunit3

Predunit3 → Predunit2 [ Linkargs ]

Predunit2 → Predunit1

| No-class Predunit2

Links1 → Juelink [ Links1 Gue ]

Juelink → Jue-class Argument

Guo → Guo-class

| Gu-class

Argmod1 → Ji-class Argument

| Ji-class Predicate Gui

| Jio-class UttAx Gui

| Jio-class Sentence Gui

Gui → Gui-class

| Gu-class

DespredB → DespredA

| Cui-class DespredC Ca-class DespredB

— 147 —

DespredA → Predunit [ Ci-class DespredA ]

| Kekpredunit

DespredC → [ DespredC ] DespredB

Senpred4 → Senpred3

| Senpred4 DespredB


| Senpred3 Ca-class DespredB



Senpred1 → Predunit [ Ci-class Senpred1 ]

Sentence → [ Sentence Ica-class ] Sen1

Arg3 → [ Mex ] Arg2

Arg2 → Arg2 Argmod Guu

| Arg1a

Gasent → Pa-class Barepred Ga-class Terms

| No-class Gasent

Step 3: Simplification of the Representative Form

To further simplify the problem, the grammar will be converted from the form

shown above to one in which repeating sets are used. [ ]… represents an item or set of

items that may appear zero or more times, and { }… represents an item or items that

appear one or more times.

— 148 —

Lexicon

The lexicon is unchanged at this step.

Grammar

Utteramnce → I-class [ UttF ]

| Freemod

| Ica-class [ UttF ]

| UttE Ige-class Utterance

UttF → [ UttE I-class ]… UttE

Freemod → Ui-class

| Soi-class

| No-class Die-class

| Kie-class Utterance Kiu-class

| Hue-class Statement Gu-class

| Hue-class Terms Gu-class

| Jo-class

UttE → [ UttD Ica-class ]… UttD


| Terms Predicate

Terms → { Term }…

UttD → UttC [ Ici-class UttC ]…

— 150 —

Predicate2 → [ No-class ]… Barefront

| [ No-class ]… Markfront


| Guu

Arg8 → [ Arg7 A-class ]… Arg7

Argmod → Argmod A-class Argmod1 Guu

| Argmod1

Wordset → [ Words ] Lua-class

Mod → [ No-class ] Mod1

Kekmod → [ No-class ]… Ka-class Modifier Ki-class Mod

UttA → A-class

| Ie-class

| Mex






Sen1 → Predicate

| Statement

| Keksent

Keksent → [ No-class ]… Ka-class [ Headterms ] Sentence Ki-class UttA1

— 151 —

Barefront → Barepred

| Bareekpred Termset

Markfront → Markpred

| Markekpred Termset



Arg7 → Argx [ Aci-class Argx ]…

Words → { Word }…

Mod1 → Pa-class [ Argument ] Gu-class

Mex → { Ni-class }…

Headterms → { Terms Gi-class }…

Linkargs1 → Jelink [ Links ] Gue


| Kekpred Termset

Bareekpred → Barefront A-class Backpred

Markpred → Pa-class Barepred

| Po-class Gu-class Sentence Gu-class

| No-class Markpred

Markekpred → Markfront A-class Backpred


Argx → No-class Argx

| Arg6

— 154 —

Voc → Hoi-class [ Descpred ] Guu

| [ Hoi-class ] Name Guu

| Hoi-class Da-class

DespredE → { DespredD }…




Descpred → DescpredE [ Go-class DescpredE ]…

Name → [ Name [ Ci-class ] ] Djan-class

| Name Predunit




Predunit → [ Predunit Ze-class ] Predunit4

Predunit4 → [ Po-class ] Predunit3

Predunit3 → Predunit2 [ Linkargs ]

Predunit2 → [ No-class ]… Predunit1

Links1 → Juelink [ Links1 Gue ]

Juelink → Jue-class Argument

Guo → Guo-class

| Gu-class

— 155 —





Gui → Gui-class

| Gu-class

DespredB → [ Cui-class DespredC Ca-class ]… DespredA

DespredA → Predunit [ Ci-class DespredA ]

| Kekpredunit

DespredC → { DespredB }…


| Senpred4 DespredB


| Senpred3 Ca-class DespredB



Senpred1 → Predunit [ Ci-class Senpred1 ]

Sentence → [ Sen1 Ica-class ]… Sen1



| Arg1a

Gasent → Pa-class Barepred Ga-class Terms

| No-class Gasent

— 156 —

Step 4: An Increase in Formality

Loglan is designed as a fully speakable language. As such, an utterance is more

than an essay in some ways, and less in others. An essay is a collection of paragraphs

arranged into sentences. However, a real-language utterance (Loglan included) has

fractional sentences (such as an answer to a question, such as "Two blue elephants", "To

the mall", and "Yes"), attitudinal indicators (such as "Wow" and "Uh-oh"), and addresses

(such as "Hey" and "Bob"), among other constructs. Since the intent of the current

project is to engage only in formal-language conversation, all of the informal elements

can be dropped.

• Fractional sentences be eliminated because they are only used in short answers, the

computer will not be asking questions, and because the computer should answer all

question in complete sentences.

• Attitudinal indicators can each be converted to a sentence. For instance, "Loa",

"Hello", can be translated to "I greet you." "Ae", "May" can be translated to "I desire

the event remaining predication." "Oa", "Wow" can be translated to "I am amazed"

or "The event <remaining presentation> amazes me."

• Addresses and initial vocatives (such as "Hey!") are unneeded, since the

communication is point-to-point.

• Parenthetical remarks have no formal meaning, and should be separated off as

separate sentences, too.

— 157 —

• Metaphors should be replaced with sentences with direct meaning. One could always

use a form like "The event x is like the event y."`

Lexicon

The remaining lexical classes are A-class, Aci-class, Age-class, Bi-class, Ca-class,

Ci-class, Cui-class, Da-class, Dio-class, Djan-class, Ga-class, Ge-class, Geu-class,

Gi-class, Go-class, Gu-class, Gue-class, Gui-class, Guo-class, Guu-class, I-class,

Ica-class, Ici-class, Ie-class, Je-class, Ji-class, Jio-class, Jue-class, Ka-class, Ki-class,

Lao-class, Lau-class, Le-class, Li-class, Lie-class, Lio-class, Liu-class, Lu-class,

Lua-class, Ni-class, No-class, Nu-class, Pa-class, Po-class, Pred-class, Sue-class,

Tai-class, and Ze-class.

Grammar

Utterance → [ UttE I-class ]… UttE




| UttA1


UttA1 → UttAx

| Terms Keksent

| Sen1

— 158 —




Sen1 → Predicate

| Statement

| Keksent


Term → Argument

| Modifier


Predicate → Predicate2 [ Age-class Predicate2 ]…

| [ No-class ]… Bi-class Termset


| Terms Predicate

Argument → [ Argument Age-class ] [ Arg7 A-class ]… Arg7


| Lau-class [ Word ]… Lua-class

Modifier → Kekmod [ A-class Mod ]…




| Guu

Gasent → [ No-class ]… Pa-class Barepred Ga-class Terms

— 159 —

Argmod → Argmod1 [ A-class Argmod1 Guu ]…

Word → Arg1a Guu

| Ni-class Guu

| Pa-class Guu

| Dio-class Guu

| Predunit1 Guu

| Indefinite Guu


Mod → [ No-class ]… Pa-class [ Argument ] Gu-class

Barefront → Barepred [ A-class Backpred Termset ]…

Markfront → Markpred [ A-class Backpred Termset ]…



Guu → Guu-class

| Gu-class


| Kekpred Termset





— 160 —

Arg1a → Da-class

| Tai-class

| Arg1


| Sue-class

| Ge-class { DespredD }… Geu-class



Markpred → [ No-class ]… Pa-class Barepred

| [ No-class ]… Po-class Gu-class Sentence Gu-class



Kekpred → Kekpredunit [ DespredD ]…

Gui → Gui-class

| Gu-class

— 161 —




| Le-class Name Guu



| Liu-class

| Lie-class

| Lao-class





Backpred1 → [ No-class ]… Backpred

| [ No-class ]… Markpred

Senpred4 → Senpred3 [ DespredB ]…


Mex → { Ni-class }…


Name → [ Name [ Ci-class ] ] Djan-class [ Predunit ]…


Senpred3 → Senpred2 [ Ca-class DespredB ]…

Predunit → [ Predunit4 Ze-class ]… Predunit4

— 162 —


DespredA → [ Predunit Ci-class ]… Kekpredunit



Predunit4 → [ Po-class ] [ No-class ]… Predunit1 [ Linkargs ]

Senpred1 → Predunit [ Ci-class Predunit ]…



Linkargs1 → Je-class Argument [ Links ] Gue



Gue → Gue-class

| Gu-class

Links1 → Jue-class Argument [ Links1 Gue ]





Argx → [ No-class ]… Arg6

Arg6 → Arg5

| Dio-class Arg6

| Ie-class Arg6

— 163 —

Arg5 → Arg4






| Arg1a

Guo → Guo-class

| Gu-class

Step 5: Taking Advantage of a Written-Only Form

Again, since Loglan is designed to be lexed on the fly, verbally, there are a

number of syntactic features which are no longer needed after parsing, or not needed if

the input is to be made at the keyboard. Most notably, onomatopoeias can be replaced by

quoted strings, as can all forms of quotations and names. Names will have to be marked

to distinguish them from quoted strings. So that special characters can be included, some

lexical rule must be made. It does not actually matter whether the C/Java rules ("\"

before special characters) are used, the PL/1/Cobol rules are used (doubling special

characters), whether the Fortran rules are used (a count of the number of characters, an H,

then the characters), or some other rule is used.

Additionally, we get a lexical option here. The Loglan predicate set can be

retained, or a switch to English words can be used. If the idea is to have a string of

— 164 —

processes that starts with Loglan, then the Loglan predicate set should be retained.

However, if input starts as written predicate calculus, then English or any other natural

language can be the basis of the predicate lexicon. In forming such a lexicon, care must

be taken that:

• Definitions are made, such that each natural language noun, verb, adjective, and

adverb used as a predicate has a defined Loglan-like meaning. For instance, "small"

would be defined as "X is smaller than Y".

• Words which duplicate other words should be excluded, or should be stored as their

counterparts. For instance, "tiny" should be excluded or mapped to "small".

• Words which duplicate other words, but with arguments in another order, must be

mapped to the base word, or excluded. For instance, "large" must be excluded (using

"Fu small" instead) or mapped to "Y is smaller than X".

If a string appears in a context which must contain a string (rather than a context

which may contain a string), a single word, without quote marks may be used. It is

understand that this introduces a context sensitivity, but that is not uncommon even in

formal computer languages.

Lexical marking rules will be used as follows:

• "string" will be a string, representing quoted text.

• *"string" will be a predicate, formed from the Loglan, English, or other natural-

language lexicon. Example: *"go" or *go.

• @"string" will be a name. Example, @"Sheldon Linker" or @Sheldon

— 165 —

• #"string" will be a number, formed from the Loglan, English, or other natural-

language lexicon. Example: #"some" or #some.

Last, since the understanding of an utterance (or more accurately, a writing) does

not require certain limitations that the Loglan grammar enforces, they can be loosened.

That will appear below in the form of treating special predicates as normal predicates,

thus allowing them to have harmless modifiers they would not otherwise be allowed.

Also at this point, another error discovered in the published Loglan grammar will

be corrected at this point: The production "Argument → Lau-class [ Words ]… Lua-

class" should have been "Argument → Lau-class [ Arg1a ]… Lua-class", since things

(which may be abstract) must be the members of sets.

Lexicon

String-class: Any quoted string, normally with quote marks.

Number-class: Any number, including π and ∞.

The remaining word-classes, which are Aci-class, Age-class, Ca-class, Ci-class,

Cui-class, Da-class, Dio-class, Ga-class, Ge-class, Geu-class, Gi-class, Go-class,

Gu-class, Gue-class, Gui-class, Guo-class, Guu-class, I-class, Ica-class, Ici-class,

Ie-class, Je-class, Ji-class, Jio-class, Jue-class, Ka-class, Ki-class, Lau-class, Le-class,

Lio-class, Lua-class, No-class, Nu-class, Pa-class, Po-class, and Ze-class.

Grammar

Utterance → [ UttE I-class ]… UttE

— 167 —

Argument → [ Argument Age-class ] [ Arg7 A-class ]… Arg7


| Lau-class [ Arg1a ]… Lua-class

Modifier → Kekmod [ A-class Mod ]…




| Guu

Gasent → [ No-class ]… Pa-class Barepred Ga-class Terms

Argmod → Argmod1 [ A-class Argmod1 Guu ]…


Mod → [ No-class ]… Pa-class [ Argument ] Gu-class

Barefront → Barepred [ A-class Backpred Termset ]…

Markfront → Markpred [ A-class Backpred Termset ]…



Guu → Guu-class

| Gu-class


| Kekpred Termset

— 168 —





Arg1a → Da-class

| Arg1

Predunit1 → [ Nu-class ] * String-class

| * ?

| Ge-class { DespredD }… Geu-class



Markpred → [ No-class ]… Pa-class Barepred

| [ No-class ]… Po-class Gu-class Sentence Gu-class



Kekpred → Kekpredunit [ DespredD ]…

Gui → Gui-class

| Gu-class

— 169 —




| Le-class Name Guu


| String-class





Backpred1 → [ No-class ]… Backpred

| [ No-class ]… Markpred

Senpred4 → Senpred3 [ DespredB ]…


Mex → # String-class

| # ?

| Number-class


Name → @ String-class


Senpred3 → Senpred2 [ Ca-class DespredB ]…

Predunit → [ Predunit4 Ze-class ]… Predunit4


— 170 —

DespredA → [ Predunit Ci-class ]… Kekpredunit



Predunit4 → [ Po-class ] [ No-class ]… Predunit1 [ Linkargs ]

Senpred1 → Predunit [ Ci-class Predunit ]…



Linkargs1 → Je-class Argument [ Links ] Gue



Gue → Gue-class

| Gu-class

Links1 → Jue-class Argument [ Links1 Gue ]





Argx → [ No-class ]… Arg6

Arg6 → Arg5

| Dio-class Arg6

| Ie-class Arg6

Arg5 → Arg4


— 171 —





| Arg1a

Guo → Guo-class

| Gu-class

Step 6: Limiting the Choice of Word Order

Because Loglan is a spoken language, and one has no chance to edit before

pressing Enter when speaking, the language provides forethought and reversed forms,

because they are required for careful logic. The language must also provide afterthought

operators, because they are required by the way we think. With the advantage of the

written form, no such allowances are required. Below, variants are reduced to a single,

straightforward form.

This also means to eliminating the loose connectives. For instance "Statement A;

Statement B" is logically the same as "Statement A -and- Statement B".

These changes further expand the sentences accepted by the grammar.

Lexicon



— 172 —

The remaining word-classes, which are Ci-class, Da-class, Dio-class, Ga-class, Ge-class,

Geu-class, Gi-class, Go-class, Gu-class, Gue-class, Gui-class, Guo-class, Guu-class,

Ie-class, Je-class, Ji-class, Jio-class, Ka-class, Ki-class, Lau-class, Le-class, Lio-class,

Lua-class, No-class, Nu-class, Pa-class, Po-class, and Ze-class.

Grammar

Utterance → [ Argument ] Predicate [ Argument ]…

| Ka-class Utterance Ki-class Utterance

Predicate → [ No-class ] [ Pa-class [ Argument Gu-class ] Predicate

| Ka-class Predicate Ki-class Predicate

| Predunit [ Predicate ]

Predunit → [ Nu-class ] * String-class

| * ?

| Predunit Ge-class Predicate Geu-class

| Predunit Ze-class Predunit

— 175 —

Step 7: Converting to the Functional View

This allows us the step of leaving context behind, and moving to a strictly

mathematical, functional basis.

In Loglan, all of the pronouns are represented by the Da-class. Here, to foster

facile processing of logic, some changes must be made. First, pronouns which are

shorthand for sets of pronouns must be replaced by their literal meaning. So, Loglan

words like Mai, Mei, Tua, and the like, which mean "X and me", "Y and me", "you and

X", et cetera, must be replaced. For instance, Mai must be replaced by the literal

meaning, Ka Da Ki Mi, or in the functional form, logic(and,Da,Mi), or as will be

explained below, logic(and,/X,/me). The D— pronouns are specific variables. In the

functional form, they will be replaced by any text string which consists only of a single

capital consonant, or a single capital consonant followed only by digits (for instance, "X"

or "Z88"). Similarly, Loglan's nonspecific variables (used for solving logic, rather than

referring to a known quantity) are represented by strings consisting of only a lower-case

consonant, optionally followed by one or more digits, such as "x" or "z88". Other words

will be represented by English words, such as "you", "me", "this", "that", and the like will

be used. Note that "you" and "me" are special, in that their meaning changes in context.

Note also that a single word must be chosen for each context, since "he", "she", and "it"

are all the same thing, except for English's gender inflection, which does not appear in

Loglan. Last, a question mark indicates the question pronoun. Syntactically, a slash

character will be used to denote the pronoun type.

— 176 —

We already have the asterisk changing something to a predicate. Thus, the

Loglan's Lio, which does that to a number, is not needed. Thus, "the number 7" would be

*7. Odd forms, such as "the number Some" would be *#some.

@ has already been identified as a name marker. However, In the functional

form, marked names can be directly used as Arguments. Thus, Name is folded into

Argument.

Loglan's Je-class and Jue-class words are used for argument affiliation not

needed in this functional form's parenthetic binding, and so do not appear in this step or

subsequent ones.

Spoken and written Loglan use Subject-Verb-Object construction for sentences,

and Verb-Object construction for imperatives and certain other uses. As such, it needs to

be able to swap arguments. For instance "Cmalo", "x is smaller than y". As an

imperative, it means "be smaller than y", or "be small". If one wants to tell someone to

be large, a way is needed to reverse things. Enter the Nu-class words. "Fu", for instance,

reverses the meaning of the first and second arguments. Thus, "Fu Cmalo" means "y is

larger than x", and used as an imperative would mean "be larger than x", or "be large".

Loglan uses compound Nu-class words to drop arguments, by arranging unneeded slots to

the end of the list. In the functional form, unused slots are simply left unused. However,

when a predication is used as an adjective, we need a way to functionally state that the

predication is largish, rather than smallish. Thus, the adjective function, below, takes an

optional argument to tell us which argument of a predication is intended.

There is one more contextual problem that needs to be solved. Loglan has a

subclass of predicates which are the equivalent of he/him/she/her/it/they/them. These are

— 177 —

Da through Du and Daci… through Duci… In English, these words are entirely

contextual. "He" means what everyone knows it to mean. In Loglan, the meanings of

these words are extremely complex. Da, for instance, in its first use means the last item

which can be represented by a pronoun. After its first use, it stays assigned to that item.

De, the second available pronoun, means, in its first use, that one counts back two

arguments, less one if Da is assigned. Di counts back three, less the number of already

assigned pronouns before it. And so on. Rather than assign that sort of counting burden,

and since forethought is not an issue in a written language, the assignment operator ("Bi"

in Loglan, "be" herein) is used to accomplish this.

Lexicon



Grammar

Utterance → predication( Predicate [ , [ Argument ]]… )

| query( Utterance )

| logic( String-class , Utterance { , Utterance }… )

— 178 —

Predicate → not( Predicate )

| tense( String-class , [ Argument ] , Predicate )

| adjective( Predicate , Predicate [ , Number ] )

| logic( String-class , Predicate { , Predicate }… )

| * String-class

| * ?

| jointly( Predicate { , Predicate }… )

— 179 —

Argument → not( Argument )

| case( String-class , Argument )

| apply( Argument , Modifier )

| list( String-class [ , Argument ]… )

| logic( String-class , Argument { , Argument }… )

| / String-class

| / ?

| * Mex

| @ String-class

| String-class

| objectify( String-class , String-class , Predicate )

| objectify( ? , String-class , Predicate )

| argument( [ String-class ] , [ Mex ] , Predicate )

| argument( ? , [ Mex ] , Predicate )

| Predicate

| suchThat( String-class , Utterance )

| assign( String-class , Argument )

Modifier → not ( Modifier )

| logic( String-class , Modifier { , Modifier }… )

| description( String-class , Argument )

| tense( String-class [ , Argument ] )

— 180 —


| # ?

| Number-class

— 181 —

APPENDIX III

PREFERRED VERSUS OTHER EMBODIMENTS

Although this grammar as designed uses "Polish" notation, there is no reason that

this must be the representative form at this point. This notation is only a preferred

embodiment, and the form that will used in this particular project. It must be said,

however, that other embodiments of the method here can be in other transformations of

embodiment. A table of some of the notational embodiments available follows:

Embodiment General form Example

Full

functional

(function operand

operand)

both(predication(go, me), predication(girl,

pretty))

Infix operand function

operand

(go predication me) both (girl predication

pretty)

Reverse

Polish

operand operand

function

go me predication girl pretty predication both

Polish function operand

operand

both predication go me predication girl pretty

Lambda (function operand

operand)

(both (predication go me) (predication girl

pretty))

— 182 —

Embodiment General form Example

XML <tag>…</tag> <both>

<predication>

<predicate value="go"/>

<pronoun value="me"/>

</predication>

<predication>

<predicate value="girl">

<predicate value="pretty">

</predication>

</both>

The words chosen for the functions (or other types of operators in other notations)

have nothing magic about the words and symbols chosen. Other embodiments could just

as easily use other words and/or symbols.

— 183 —

APPENDIX IV

THE FIRST-CUT FUNCTIONAL FORM

This chapter defines the Functional Form, which is a language closely related to

Loglan. The relationship between the Functional Form and Loglan, with a derivation of

the Functional Form appears in Appendix I. Planned storage layout to represent the form

is shown in Appendix II. Notes on related functional forms appear in Appendix III.

The Functional Form allows us the step of leaving context behind, and moving to

a strictly mathematical, functional basis.

The following symbols will have special meanings:

Symbol Meaning

* When followed by a word or string, that word or words will be considered a

predicate. *go and *"go" would presumably mean "go", or "x goes to y over

path z". *7 would mean the number 7, or the numberness of 7.

@ Denotes a name. *Sheldon and *"Sheldon" would be names.

/ Pronoun marker. /I and /"I" would be pronouns.

# Indicates a number word. #All and #"All" would be All.

? Fill-in-the blank question. For instance, *? would be What, and #? would be

How Many.

— 184 —

The functions used in the Functional Form are as follow:

• predication: This function takes a Predicate argument, an optional Argument

argument (which represents the subject of the sentence or predication, if present), and

an optional collection of additional Argument arguments, which represent the objects

of the predication. For example, "I go to school" (Loglan "Mi Gotso Ga Ckela")

would be predication(*go,/mi,*school), and "Go to school" (Loglan "Gotso Ga

Ckela") would be predication(*go,,*school). The function forms an Utterance.

Because any of the arguments can be left out, there is no need to use the Nu-class

words to reposition arguments.

query: The query function asks whether a given Predication is true. This is

equivalent to asking "Is Streak a cat", but is phrased "Query: Streak is a cat." The

answer would be in the form, "Streak is a cat" or "not(Streak is a cat)". The function

takes an Utterance as an argument, and returns an Utterance, the latter being a

question.

— 185 —

• logic: This function takes a string argument, which defines which logical operation is

to be done. This controlling argument can be in Loglan ("A", "E", "O", and the like),

or in some natural language ("And", "Or", "Implies" and the like). Note that in

natural languages, we do not have the full set of logical operators. So, we will have

to add some — "Or ¬", for instance. The second and third arguments have this

operation applied to them. Operations which are order insensitive (And, Or, None of,

and All of) may have additional arguments. In performing and storing the logic this

way, the search logic which will appear below is greatly simplified, and we do not

have a process that will take forever to evaluate. For example, "A and B and C"

would be logic(and,A,B,C).

• not: This function takes an argument of any type, and negates it.

• tense: This function applies a tense to a predicate. The first argument is a string.

Again, this can be Loglan or a natural language. Loglan's Pa, for instance, means

"past tense", "did", or "before". If English words are to be used, care must be taken,

since an argument can be applied to the tense modifier. For instance, we can say "in

the past" or "before Monday". The same word must be used in both circumstances.

The Argument argument to this function is optional. The third argument is a

predicate, and so is the result. This function can also be used in Argmod object

context. In this latter circumstance, because the item being tense-modified is not

established yet, the third argument would not be present, and the tense acts

(generically) as a function which returns an Argmod object.

— 186 —

• adjective: This function applies its first argument as an adjective to the second. This

seems a very simple thing, but doing this through a function allows control of the

binding. Take the "Pretty little girls' school" problem (Loglan "Bilti Ge Cmalo Nirli

Ckela"). This comes out as adjective(*pretty,adjective(adjective(*small,

*girl),*school)). This alleviates the need for Ge and its rule. To use a predication

with an argument position other than the first as the meaning, such as using Cmalo's

second argument to indicate largeness, use a number as the third argument. Thus,

adjective(*small,*school) is a small school. Adjective(*small,*school,2) would be a

large school, since "small" is "x is smaller than y", and "2" picks out "y" (the larger

item) as the operand position of interest.

• jointly: This function takes two or more predicates, and merges them into a single

predicate of the form "A-and-jointly-B".

• case: This function applies a case-class (Dio-class) modifier (the first argument to the

function) to an Argument (the second argument to the function). Note that in Loglan,

cases are not what they are in other languages. Examples include "Parts", "Values",

"Doers", "The addressee of", and "Conditions". Again, for the string argument

defining the case-class modifier could be Loglan or any natural language. The

function returns the modified argument.

— 187 —

• apply: This function applies and Argmod argument modifier (its second argument)

to an Argument (its first argument). It might, at first glance, seem strange that it was

chosen to have argument modifiers formed and then so attached to an argument,

rather than having these modifiers include their modified Argument as an argument.

However, it is necessary that logic can be applied to argument modifiers before the

collected logical construct is attached to the Argument. The result of this function is

the modified Argument.

• list: This function forms a set or ordered list. Currently, (both in Loglan and in this

project), only two types of lists are defined, unordered sets, and ordered lists. The

first argument is a string defining the type of list. The Loglan Lau and Lou could be

used, or English's "set" and "list" can just as easily (if not more so) be used. Any

number of Argument objects are then specified, starting in the second argument

position. Note that no Argument arguments is valid, and results in an empty set or

list. The set or list so formed, as a new Argument, is the result of this function.

— 188 —

• objectify: This rather complicated function serves to make a predication into an

object. The most common case of this is in translating sentences like "I would like to

go." In order to fit this concept into the above minimized grammar, this needs to be

rephrased to "I desire the event: I go." So, the predication "I go" must be turned into

an event. Hence, the objectify function is born. The function takes three arguments.

The first represents Loglan's Le-class or Ie-class words. The function uses a string to

represent Le-class words, and the question mark to represent the Ie-class. If using

English, the Le-class words are replaced with things like "the unique object, if any,

which", "the", "The set of all", et cetera. The second argument represents Loglan's

objectifying operator, the Po-class words, used here as a string. Examples include

"event", "property", and "amount" (Po, Pu, and Zo, in Loglan, respectively). The

third argument to this function, of course, is the predicate to be objectified. The result

is an Argument object.

• argument: This function is used to form a standard argument from a predicate, or to

form an infinitive. First describe the form, then use of this function will be described:

The first argument to this function is a String-class item representing one of Loglan's

Le-class words, as above (such as "the"), or the question mark, or nothing at all. The

second argument to the function is a number, as a Mex object, which may also be

omitted. The third argument to the function is the Predicate. The function results in

an Argument object. Here is a table giving examples of the forms and their

associated meanings:

— 189 —

Form Meaning Example Translations

argument(Le-class,

Mex, Predicate)

This is a

qualified and

quantified item

argument(the, 2,

*school)

the two schools,

Le To Ckela

argument(Le-

class,, Predicate)

This is a

qualified item

argument(the,,

*school)

the school, Le

Ckela

argument(, Mex,

Predicate)

This is a

quantified

infinitive

argument(, 2,

*school)

to two schools,

[Gu] To Ckela

argument(,,

Predicate)

This is the simple

infinitive form

argument(*school) to school, [Gu]

Ckela

Predicate A simpler form

of the simple

infinitive

*school to school, Ckela

— 190 —

• suchThat: In logic (the basis of this endeavor and of Loglan), one sometimes must

refer to a variable, in a case where the variable has a defining constraint. (The astute

will notice that the preceding sentence meets its own requirement.) Here is an

example English-language example: "x such that x is greater than 1 and x is less than

8". In this phrase, "x" is the thing being referred to, and "such that x is greater than 2

and x is less than 8" is a description of x. In mathematics, this is "x: x>2; x<8". In

Loglan, ":" translates to Go., so the Loglan for this is Ba Go Ba Cio To E Ba Cia

Ne. In this functional form, this Argument further translates as suchThat(x,

logic(and, predication(*more, x, 2), predication(*more, 8, x))). So, the first

argument to suchThat is a String-class, which represents a nonspecific variable

(subset of Loglan's Ba words in the Da-class). The second argument is an Utterance,

which uses the variable in a logical equation, or set of logical equations, to define that

variable's value. The result is that nonspecific variable, which now has a defined

meaning, as an Argument object. This logical form obviates the need for Loglan's so-

called "nonrestrictive such that" operator, Jio.

First-order logic can be expressed as follows: Let's say that I wanted to say that

all girls are small. Loglan has two ways of doing this. One is the direct, class

approach, to say "All girls are small", or "Lo Nirli Ga Cmalo". The first-order

approach is to state that "For all x, if x is a girl, then x is small". In the functional

form, these translate to "predication(Cmalo, argument(Lo, *Nirli))" and

"predication(Bi, suchThat(Ba, predication(Nirli, Ba)), suchThat(Ba, predication(

Cmalo, Ba)))", respectively

— 191 —

• description: This function builds a descriptive Argmod object, for later attachment

to an Argument object as a modifier. The first argument to this function is a string

which represents a member of Loglan's Ji-class words, either in Loglan, or in some

other language. In English, these would be things like "which is", "that is", "that is

one of", "is a possession of", and similar items.

• Assign: This operator, which looks like a function, assigns a meaning to a pronoun.

If the pronoun had been in use in a previous utterance, then it is reassigned. Because

these logical formulæ are not order-sensitive, any given variable (pronoun) may not

be assigned more than once in the same utterance. The first argument to this operator

is the pronoun whose meaning is being set, and the second argument is an Argument.

The result is that Argument.

— 192 —

APPENDIX V

REDESIGN OF THE LANGUAGE

A note on the choice of font and style in this section:

• Plain type, such as this, is used for the normal discourse and description.

• Bold text, such as this, when used other than in a heading, is used to show text

defining a part of the language.

• Italics, such as this, is used to show a type of word or phrase, where a general item

can be replaced by a specific.

• Items in Chalkboard font, such as this, are used to represent things shown

as examples in this language, or in Loglan. The difference in the two

languages is striking enough that separate fonts are not required.

• Last, Courier typeface will be used for items showing

direct communication in another existing computer

language.

The interactive language is designed based on English, propositional grammar,

and Loglan. The language extends to higher-order logic, including the ability to extend

to modifiers of every sort allowed by every language. Below is the derivation.

— 193 —

The symbols of logic

Symbol Meaning Functional

∀ For all for all variable… expression

∃ There exists there exists variable… such that

expression

there exists quantifier numeric expression

variable such that expression

� There does not

exist

there does not exist variable such that

expression

∈, ∉, ∩,

∪, ⊂, ⊃, ⊆, ⊇, ⊄, �,

�, �, {…}, […]

Set and list

notation

(predicates for now; may add as primitives

later)

∧ And both logic expression and logic expression

∨ Or either logic expression or logic expression

neither logic expression nor logic

expression

<, ≤, =, ≥, >, ≠ Equality notation (predicates for now; may add as primitives

later)

(…) Grouping (not needed)

Px Predication (see below)

— 194 —

Symbol Meaning Functional

Fx Function (see below)

+,-,·,÷ Arithmetic the sum of numeric expression and

numeric expression

the difference between numeric

expression and numeric expression

the product of numeric expression and

numeric expression

the quotient of numeric expression and

numeric expression

⇐ Is implied by the statement expression is implied by

expression

⇒ Implies if expression then expression

⇔ If and only if if and only if expression then expression

⊕ Exclusive or exclusively logic expression or logic

expression

¬ Not it is not the case that logic expression is

true

true, false Logicals true

false

— 195 —

Items inherited, or not, from Loglan

Class Meaning Functional

Preda

Dio

Ga

Ge

Geu

Gu

Predicates

and

adjectives

*lexeme/

*lexeme argument … /

Note: "*" (handled lexically) and "/" can be omitted if doing so

would not contextually cause a problem. One predicate can

modify another:

adjective predication affects predication

Thus, to say "pretty little girls' school", having a primary

meaning of a school for girls who are little, and that such

school is pretty would be said (or written) as "adjective

*pretty/ affects adjective adjective *little/ affects

*girl/ affects *school"

Ze Jointly Let's say that I had a red-and-blue ball. It is not "a red ball and a

blue ball", not is it "a red ball in a blue way", nor "a blue ball

in a red way". It is "a ball in a way that is jointly red and

blue". You could also say that it is "a ball and it is jointly

red or blue. For this, we introduce "jointly", which is tightly

binding

jointly predication and predication

— 196 —


A Aci

Age

Bi Ca

Cui

Go

Guu I

Ica

Ici

Ige

Ka Ki

Lau

Lua

No

Operators

(Handled in the first-order logic section)

I Period A separation between two executables (utterances or queries),

even though they are delivered together

executable execute executable

Ha Question As a variable: what

Alternate form: which

As a predicate: blank

— 197 —


Nu Rearranger In Loglan, the Nu-class words rearrange arguments. We do not

need that here, because there is a simpler way to do this.

First, any place an argument can appear, the word

"anything" can appear in its stead, as an unconstrained

value. Second, when a predicate is used as an adjective or

adjectival phrase, we need to know how. For this, the word

"emphasis" is chosen. For instance, Go(x,y,z) means the

going from x to y over path z. Thus, "adjective *go/

affects *drive" would mean to drive in a going sort of way,

as would "adjective *go emphasis/ affects *drive".

However, "adjective *go anything emphasis/ affects

*drive" would mean to drive in a coming sort of way.

anything

emphasis

— 198 —


Da

Bi

It

Is

In English, "it", "he", "she", "him", "her", "they", and "them" all

have meanings that are ambiguous. You have to guess the

same meaning that the speaker is using. In Loglan, the

meanings for "Da" through "Du", and their subscripted forms

are unambiguous, but follow fairly complicated rules and are

hard to follow in conversation. Here, for simplicity and

formality, as well as ease of understanding, a special

predication (verb) will be used:

be argument argument

Rather than implying that "it" is "a school" through context rules,

one will say "x is a school" explicitly.

Ba x This class of word, in Loglan, represent true variables. They

appear in ∀ and ∃ situations. Thus, in this language, the

scope of each variable is only with its "for all" or "there

exists" phrase. These variables will be represented by

lower-case letters, other than "a" or "i".

— 199 —


Mi Me, I me

i

Either of these terms, used interchangeably, represents the

speaker. When used, these tokens will be replaced by the

known name of the user. On output, the name of the

particular knowledge-base computer system will be replaced

by "me" or "i". For instance, "I like you", translated as

"like i you" might be stored as "like "Sheldon Linker"

"hal.linker.com"". If this text were read out of the system,

it might be translated back as "*like you me/". If the data

were read back to a different user, or on a different system,

the "you" and "me" substitutions would not occur.

Tu You you

Operates similarly to "me" and "i". See above.

Ci -sub- variable name sub number

Since 24 variables may not be enough, subscripts are provided.

For instance, "x sub 2".

— 200 —


Miu We In Loglan, there are a number of words for "we" and other

compounds. In order to keep this language more English-

like, and at the same time more like logic, and easier to

follow, such compounds must be defined using "let". For

instance, "let W be you and me", or "let U be 'ted' and

i".

Li

Lie

Liu

Lu

Soi

Sue

Tai

Quoted

items

In Loglan, each of these syntactically marks a type of sound as a

quoted string. In this language, quoted strings will always

act as arguments. The meaning of the argument is "the literal

text…".

'literal text'

To allow a quotation mark inside a string, a pair of quotes will

do. Thus, the literal string "don't" would be represented as

"'don''t'". That may be a bit hard to read, so here is an easier

version: The string consisting of a single-quote character,

the letter D, the letter O, the letter N, a single-quote

character, another single quote character, the letter T, and a

final single-quote character.

— 201 —


Djan

Lao

Names Names representing a person, place, thing, or named concept

always act as arguments, and are represented as double-

quoted strings. Because these name strings are marked

names, and not literal strings, only letters and numbers

should be considered, with internal white space being

considered as a single space character. Thus, ""James

Cooke Brown"" would have the same meaning (and storage)

as "" james cooke brown "". Other examples of

names might be ""Shangri-la"", ""Fido"", and perhaps even

""The theory of Relativity"".

"name"

Die

Ui

! Attitudinal indicators are not needed, as each indication can be

just as easily expressed as a statement.

Hoi

Hue

Hey Vocative markers, used in Loglan to gain or redirect attention,

are not needed, as we are engaged in point-to-point

communication.

Jo

Kie

Kiu

metaphor Metaphors and parenthetic additions are better stated as separate

sentences, and so are not borrowed from English or Loglan.

Ie The, In English and Loglan, it is possible to say "the house".

— 202 —


Gue

Gui

Je

Ji

Jio

Jue

Le

connectives,

descriptives

However, for the purposes here, "the house" is still to

ambiguous, as it requires that the listener to understand

which house is meant by the speaker, using some form of

plausibility context. Thus, a direct "the" is inappropriate.

There are two ways around this. First, one could say that the

Whitehouse is a white house with qualification: "adjective

*white/ affects *house "Whitehouse"". Second, one

could declare that the Whitehouse is white and a house in

two separate clauses: "both *white "Whitehouse" and

*house "Whitehouse"". Third, one could assign a variable:

"let W be "Whitehouse" execute both *white W and

*house W". A form had been considered which would be

something on the order, "the house identified by…", but that

is (a) redundant with the above, and (b) a problem for

execution order. Thus, "the" and the various "which is" and

"known as" type words and clauses are rejected, and the

slightly wordier forms just mentioned will suffice.

However, a general form of "of" is provided:

the item argument with property predication

In this form, which is really a short-hand, a property can be

linked to a thing. This is best shown by example: If we take

— 203 —


a predicate Own to be Own(owner,owned), then "my house"

could be "the item 1 *house/ with property *own me".

"emphasis" will be used to point out other meanings. For

instance, Go is Go(traveler,whence,wither,path). Thus, "the

restaurant I am going to" is "the item 1 *restaurant with

property *go i anything emphasis". Internally, anything

of this form will split the predication into two components,

and introduce an unnamed variable. as shown above. Yet a

further short-hand is provided:

my argument

This is equivalent to "the item argument with property *own

me". Of course, we also need:

your argument

— 204 —


Ni #, all, some One way to turn a predication into an argument is to put number

in front of it. A literal number or numeric expression will

quantify the item. For instance, "1 *apple" would be an

apple. "2 *apple" would be two apples. "0.5 *apple"

would be half an apple. To get to "the apple", One would

need to first identify a particular item, using means described

above. When tempted to use "the", note that the item must

have already been fully qualified, and thus "1" will do.

numeric expression predicate expression

Loglan's Ni class also has other numeric forms. Special words

mean "all", "most", and "some". Thus, these words can be

used to quantify a predication into an argument.

all of predicate expression

most of predicate expression

some of predicate expression

little of predicate expression

This form can also be used in questioning.

how many predicate expression

Note that "most of *apple" means "most of an apple", and not

"most apples".

— 205 —


Lo class Items can be taken as a class. For instance, "the class *apple"

means "the class consisting of all apples", or just "apples" in

some uses.

the class predicate

Quantifiers can be applied with classes. So, "half of all apples"

would be "0.5 class of *apple". "some apples" (meaning

"a certain percentage of all apples", rather than "a certain

number of apples") would be "some of the class *apple".

numeric expression the class predicate expression

most of the class predicate expression

some of the class predicate expression

little of the class predicate expression

how many the class predicate expression

Guo

Po

event One may speak of an event. The loss of attitudinal indicators

requires it. For instance, rather than saying "May The Force

be with you", without the indicators, this would be "I desire

the event: The Force is with you", or "*desire i the event

*with "The Force" you". Likewise, properties can be

described, such as happiness.

the event predication

the property predicate expression

— 206 —


Lio number Using this phrasing, a number can be turned into an argument.

the number numeric expression

For instance, "the number 7"

Pa tenses Tenses in Loglan and in this language inherit from every

language in the world, including Hopi. Each tense modifies

everything to its right, and tenses can be stacked.

Unprivileged users get a default tense which tags an event as

their opinion. Time tenses are listed below, to be followed

by other tenses.

at time reference predication

on time reference predication

after time predication

on or after time predication

beginning time predication

beginning after time predication

before time predication

on or before time predication

ending time predication

ending before time predication

potentially predication

during time predication

This last tense is the "-ing" tense.

— 207 —


— time Time references can be a single time, or a period

time

time through time

— time date

date time

time

now

today

this period

last period

next period

offset… from time

offset… before time

tomorrow

yesterday

named date

Dates can be in the form yyyy, yyyy-mm, or yyyy-mm-dd. They

can be followed be ad, ce, bc, or bce. Times can be in the

form hh, hh:mm, or hh:mm:ss. All times are assumed to be

GMT.

Period names can be second, minute, hours, day, week, month,

— 208 —


year.

Offsets can be:

numeric expression period

a period

Periods may be in the pleural.

Named dates may include sunday through saturday and

january through december.

— 209 —


— Tenses Other tenses include:

certainly predication

on good authority predication

likely predication

as a belief predication

as a guess predication

according to argument predication

located at argument predication

located at a distance of distance from argument predication

located at a distance of up to distance from argument

predication

located at a distance of at least distance from argument

predication

located at a range of distance to distance from argument

predication

near argument predication

far from argument predication

— Distance a meter

numeric expression meters

— 210 —


— tenses? Questions can be asked as tenses. Some are specific, and the last

is general.

when

where

tense

The semantics of predicates

Each predicate is transparent. It does not matter to the language what the predicate

means to you. However, we need to understand what it means. An example would be

Go. Go(a,b,c,d) we will take to mean "A goes from B to C over path D". If we take

Come(a,b,c,d) to mean "A comes to B from C over path D", then we can define

"∀a,b,c,d, Go(a,b,c,d) ⇔ Come(a,c,b,d)". Missing arguments are assumed unspecified,

so that "∀x,P(x), P(x) ⇔ ∃y, P(x,y)".

Commands

A number of commands need to be present to control the system. These are separate and

distinct from statements and queries:

Command Syntax

Tell the system to trust a given user's statements from trust user to level number

— 211 —

Command Syntax

now on, either completely or to a given extent trust user

Tell the system to stop trusting a user's future

statements.

do not trust user

Add an authorized (untrusted) user. add user user

add user user password

password

name of user user is "name"

Remove further access for a user, without affecting

knowledge gained from that user.

drop user user

Forget a particular statement. forget predication

Log off bye

Log on i am user with password

password

i am user

Dump the knowledge base as a series of statements,

numbered.

list facts

list facts i control

Drop a particular knowledge item from the knowledge

base.

forget fact number

Drop all information from a particular untrusted user

(used as a maintenance item, or for malevolent users)

forget what user said

— 212 —

Command Syntax

Retroactively promote a user's statements to trusted

status

trust what user said

Speak in unprivileged state (the default, even for the

privileged)

commoner

Speak in privileged state (for those privileged) ex progmatica

Acceptance of various levels of veracity consider facts only

consider opinion

consider opinion to level level

— 213 —

APPENDIX VI

THE DERIVED RULES OF SYNTAX

The basic unit of work is the transmission. Lexically, an asterisk treats the following

word as a WORD lexeme, and not as a keyword. Brackets denote optional items. The

ERROR term is used to introduce a context-sensative shortcut.

transmission → [ transmission execute ] command

command → utterance

| trust WORD [ to level NUMBER ]

| do not trust WORD

| add user WORD [ password SINGLEQUOTEDSTRING ]

| name of user WORD is DOUBLEQUOTEDSTRING

| drop user WORD

| forget utterance

| bye

| i am WORD [ with password SINGLEQUOTEDSTRING ]

| list facts [ i control ]

| forget fact NUMBER

| forget what WORD said

| trust what WORD said

| commoner

— 214 —

(command, continued)

| ex progmatica

utterance → predication

| question

question → is predication value

| for which variableList is predication value

value → true

| false

variableList → [ variableList ] variable

variable → LETTER [ sub NUMBER ]

predication → for all variableList predication

| there exists variableList such that predication

| there exists [ at least ] number variable such that predication

| there exists at most number variable such that predication

| there does not exist variable such that predication

| both predication and predication

| either predication or predication

— 222 —

APPENDIX VII

ADDITIONAL CONCERNS

The real world

In a real-world knowledge system, most of what the system will be doing will be looking

up facts, and not trying to prove something. For instance, I may ask for the temperature

in New York today. That will not require much in the way of proofs. It will simply

require finding the data. So, any algorithm should assume that the data will look

something like "A(a) ^ B(b) ^ C(c) …", and that the query will look something like

"?B(b)", or like "B(_)", or like "_(b)".

The states of logic

The original proposal held that, rather than True and False, we are really dealing with

True, False, and Possible, plus a special form of Possible, which is Refinement.

Refinement means that one statement narrows things down, farther than was had. An

example is "X is a ball". If a second statement, "X is a blue ball", then the latter is a

refinement of the former. X being a blue ball entails X being a ball, so the latter is a

refinement on the former. Notice that this is not a two-way entailment.

It turns out that rather than maintaining these four states of logic as such, internally, only

the standard True and False states need be maintained. If a new statement X is made, and

— 223 —

X can be shown to be true, then X is true (and can be discarded). If a new statement X is

made, and ¬X can be shown to be true, then X is false (and can be rebutted and

discarded). If a new statement X is made, and neither X nor ¬X can be shown to be true,

then X is possible, and can be taken as a statement of fact on the part of the user. The

previously described logic held that if a refinement was held as fact, then the basis it

replaces should be immediately dropped from the data base.

Immediate dropping on receipt of a refinement is not actually necessary. Indeed, the

system may run faster in the short term without it. Responding to the user is a real-time

activity, but removal of redundant data need not be. Rather, a form of garbage collection

can be used. In the simplest form, ∀Factx, ∀Facty, ((Factx⇒Facty) ∧ (x≠y)) ⇒

Redundant(Facty). Note that because of the adjectival nature of this level of logic, this is

an N-squared problem, rather than the usual half-N-squared problem.

— 224 —

Methods used in the execution of a message

Mainline:

Mark no changes made

Read the data base

Loop

If changes have been made since the last completion of garbage collection

If there is input available

Read the input

Process the input

Else

Process a step in the garbage collection process

End-If

Else

Read the input, blocking

Process the input

End-If

End-Loop

End-Mainline

— 225 —

Garbage collection

Maintain a system-wide time of last knowledge-base change

Maintain a per-rule time of last complete garbage collection end

For each rule in the system,

If the time of last garbage collection end is not after the time of last knowledge

change

For each rule in the system

If the rules are not the same, and their primary predicates match

Do a low-level garbage collect using the inner and outer rules

If a rule was removed,

Insufficient work. Leave the garbage collector for now.

End-If

Do a low-level garbage collect using the outer and inner rules

If a rule was removed,

Insufficient work. Leave the garbage collector for now.

End-If

End-If

End-For

Set the rule as collected at this time

Sufficient work. Leave the garbage collector for now.

End-If

End-For

End-Collector

— 226 —

Low-level collector

Check whether the first rule completely and on its own entails the second

If so

Drop the second rule

End-If

Return a flag showing the state

End-Collector

Reading the input

Read the actual input

Parse it into an internal structure

End-Read

Process the input

Switch on the type of input

When a command

Execute the command

When a direct question

Evaluate the predication for True/False/Possible at 1st order

Report the result

When an indirect question (a statement form, but with 1+ question words)

Evaluate the question for possible answers at 2nd order

— 227 —

Report the result

When a direct statement

Evaluate the predication for True/False/Positive at 1st order

Switch on the type of result

When true

Discard the statement

When false

Contradict

Discard the statement

Otherwise (possible)

Add the statement to knowledge

Mark that garbage collection is required

End-Switch

Otherwise (not understood)

Complain

End-Switch

End-Process

— 228 —

Evaluating a predication for true/false/possible at 2nd order

Purpose: Answering for which predication an enclosing predication is true

For each predicate in the system (the fast loop)

Try the queries outer presentation using the predicate as the inner predication

If the trial predication is entailed

Report the rule

Done

End-If

End-For

For each predication (rule) in the system (the slow loop)

Try the queries outer presentation using the rule as the inner predication

If the trial predication is entailed

Report the rule

Done

End-If

End-For

End-Evaluate

— 229 —

Adding a statement to knowledge, with a "known possible" flag

Evaluate the statement

If proven true

Stop processing

End-If

If the "known possible" flag is not set

Evaluate ¬statement

If proven true

Complain that it is false

Stop processing

End-If

End-If

If the statement is a "both" clause

Add the left side to the knowledge base using this method recursively, with

"known possible"

Add the right side to the knowledge base using this method recursively, with

"known possible"

Else

Add the statement to the knowledge base

End-If

End-Add

— 230 —

Evaluating a predication for true/false/possible at 1st + modifiers order

Try simple proof

If succeeded (true or false)

Return result

End-If

Return result of complicated method

— 231 —

Simple method:

Comparing Knowledge with Statement

If the statement is Not

Compare Knowledge with Not Statement

Return that result

End-If

If the statement is a Compound

Return a result from the table (using 4 steps) below

End-If

If a direct-match item is found in Knowledge to Statement

If supporting

Return True

End-If

If denying

Return False

End-If

Return Too complicated

End-If

If the removal of one or more adjectives, arguments, or tenses from a statement in

Knowledge is a match

If supporting

Return True

End-If

— 232 —

If denying

Return False

End-If

End-If

Return Too Complicated

End-Simple

Operation

Result of

comparison of

left side

Action

Result of

comparison on

right side

Result

True Compare right Any result Return result

of 2nd

compare

True or

unknown

Return

unknown

Unknown Compare right

False Return False

Both

False Return False

— 233 —

Operation

Result of

comparison of

left side

Action

Result of

comparison on

right side

Result

True Return True

True Return True Unknown Compare right

Unknown or

false

Return

Unknown

Either

False Compare right Any result Return result

of 2nd

compare

True Return false

True Return False Unknown Compare right

Unknown or

false

Return

unknown

True Return False

Unknown Return

Unknown

Neither

False Compare right

False Return False

— 234 —

Operation

Result of

comparison of

left side

Action

Result of

comparison on

right side

Result

False Return True

True Return True Unknown Compare right

Unknown or

false

Return

unknown

Implies

True Compare right Any result Return result

of 2nd

compare

True Return True

True or

Unknown

Return

Unknown

Unknown Compare right

False Return True

False Return True

Unknown Return

Unknown

Implied by

False Compare right

True Return False

— 235 —

Operation

Result of

comparison of

left side

Action

Result of

comparison on

right side

Result

True Return False

Unknown Return

Unknown

True Compare right

False Return True

Unknown Return

Unknown

Excludes

False Compare right Any result Return result

of 2nd

compare

— 236 —

More complicated comparisons

Lay out Knowledge as a Prolog file, using these rules:

Translate predicates here as Prolog predicates

Translate arguments here as Prolog atoms

Translate Adjectives here as compound predicates. For instance, saying that "Streak

is a nice cat" would translate into this language as "adjective *nice modifies

*cat "streak"". One possible translation into Prolog for this type of construct

could be "a_nice_m_cat(streak).".

For each such compound predication, lesser implications would have to be stated.

For this example, "a_nice_m_cat(X) :- cat(X)."

Run the file through Prolog with Knowledge as the program and Statement as a

proposition.

If True

Return True.

End-If

Rerun the knowledge program, with ¬Statement as the preposition.

Return Prolog's result

End-Complicated

— 237 —

APPENDIX VIII

INTERNAL STRUCTURE

The knowledge is stored in a tree-structured form, and much resembles the grammar.

However, in some cases, several grammar rules will collapse into one storage rule. Also,

some grammar rules may translate into transient storage structures through a process of

"percolation", in which items are separated and/or constructed, and percolate up to the

proper level. That is, they may result in a short-lived structure which will only be used to

transform the data into another form. One example of this is "my", which will transform

into a structure using "*own".

The design shown below is not true Java. The intent is to show design elements, and how

they fit together. A subroutine is shown only once at its highest level of appearance.

Routines are described following the pseudocode. Although not a part of Java, C's

enumerations are used to add clarity. Constructors, since obviously required, are not

shown.

class JCB {

enum logic {FALSE, MAYBE, TRUE, ANSWERABLE, UNANSWERABLE

}; — States of logic

enum builtin {OWN, BE}; — Built-in verbs

static void main(); — Where execution starts

— 238 —

static void AddThree(String, int, String, int,

String int); — Adds three strings and their

corresponding parse-integers to a hash table

static void AddToSubstitutions(Vector<Integer>); — Adds a

list of variables (known as a vector of integers) to the list of

variables currently being substituted in For All or Exists

predications

static void RemoveFromSubstitutions(Vector<Integer>); —

Removes a list of variables (vector of integers) from the list

of substitution variables in use

static void AddToPercolatingPredicate(JCBPredication); —

Adds a predication to the list of predications which are

trying to bubble up to the regular predication level from

implications inside arguments

static JCBPredication FlushPercolatingPredicate(JCBPredi

cation); — Forms a conjunction between the given

predication and any percolating predicates

static String EnglishVariableName(int); — Translates a variable

number to the JCB-English representation

static String PrologVariableName(int); — Translates a variable

number to the Prolog representation

static int GetVariableValue(); — Parses out a variable number

— 239 —

static enum logic CompareTenses(Vector<Tense>,

Vector<Tense>); — Compares two tense vectors, and

returns the logical result

static boolean TenseEquals(Vector<Tense>,

Vector<Tense>); — Determines whether two tense

vectors are identical

static enum logic BestResult(enum logic, enum logic); —

Given two logic states, returns the best result for a proof

static enum logic LogicAnd(enum logic, enum logic); —

Performs a logical And, using 5-state logic

static enum logic LogicXor(enum logic, enum logic); —

Performs a logical Xor, using 5-state logic

static enum logic LogicOr(enum logic, enum logic); —

Performs a logical Or, using 5-state logic

static enum logic LogicalNot(enum logic); — Performs a logical

Not, using 5-state logic

static void OpenAndParse(String); — Opens an input stream, parses

it, and executes it

static void CategorizeLexeme(); — Categorizes a lexeme, saving the

result in lexemeInt

static void Lex(); — Lexes and categorizes, saving the result in

lexeme

— 240 —

static void ForceWord(String, String); — Requires the next word

to be a given word, or complains with an error message

static void ForceWords(String, String, String); — Requires

the next two words to be given words, or complains with an

error message

static void ValidateOperator(); — Requires that the current user have

Operator privilege

static int LookUpUser(); — Translates a user name to an account number

static int GetInteger(); — Parses out an integer

static double GetFloat(); — Parses out a floating-point number

static boolean GetValue(); — Parses out a boolean value

static void GetDoOwnerCommand(); — Parse and execute an Owner

command

static void GetDoTrustCommand(); — Parse and execute a Trust

command

static void GetDoDoCommand(); — Parse and execute a Do command

static void GetDoAddCommand(); — Parse and execute an Add command

static void GetDoNameCommand(); — Parse and execute a Name

command

static void GetDoDropCommand(); — Parse and execute a Drop

command

static void GetDoForgetCommand(); — Parse and execute a Forget

command

— 241 —

static void Remove(int); — Remove a given fact number from the

knowledge base

static void GetDoByeCommand(); — Parse and execute a Bye command

static void GetDoICommand(); — Parse and execute an I command

static void GetDoListCommand(); — Parse and execute a List command

static void GetDoCommonerCommand(); — Parse and execute a

Commoner command

static void GetDoExCommand(); — Parse and execute an Ex command

static void GetDoUtterance(); — Parse and deal with an utterance

static void GetDoIsQuestion(); — Parse and answer an Is question

static void GetDoForWhichQuestion(); — Parse and answer a For

Which question

static void GetDoConsider(); — Parse and execute a Consider

command

static void GetDoPredication(); — Parse and deal with a predication

static void AddToDataByComponents(JCBPredication); — Add a

predication to the knowledge base

static void DoIdle(); — Simulate idle time handling

static void GetDoCollectGarbage(); — Do a full garbage collection

immediately

static enum logic GlobalProve(JCBPredication, int,

boolean); — Attempt to prove a predication, which

— 242 —

may include the RelFun interface and converting the

knowledge base

static enum logic Reprove(JCBPredication); — As above, but

with the knowledge base already a RelFun program

static String ToEnglish(); — Convert the entire knowledge base to

JCB-English

static String ToXML(); — Convert the entire knowledge base to XML

}

class JCBUserData { — One such object per user

String accountName; — Log-in name

String password; — Log-in password, for secured accounts (can be null)

String actualName; — Actual name (defaults to log-in name)

double maxTrustLevel; — A number between 0 and 1

}

class JCBFact { — One such item per stored fact. A vector of these is a

knowledge base.

int controllingUser; — User index, or -1 for Ex Progmatica

JCBGrammar predication; — The actual fact

}

class JCBGrammar { — Here and below, each object represents a grammatical

construct

— 243 —

boolean Equals(JCBGrammar); — Determines whether two grammatical

constructs are identical

String ToProlog(); — Forms a Prolog representation of the item

String ToEnglish(); — Forms a JCB-English representation of the item

String ToXML(); — Forms an XML representation of the item, for

debugging

enum logic FastProve(JCBGrammar); — Determines whether the

argument proves the object, returning a 5-state result

JCBGrammar Refactor(); — Optimizes the object, which may cause

percolation of implied predicate terms

boolean Uses(int); — Determines whether a grammar item, or any sub-item,

uses a given variable

double Veracity(); — Determines the veracity of the given grammar item, in

the general case as the product of the veracities of its

components

boolean ContainsAQuestion(); — Determines whether a grammar item,

or any sub-item, contains a question

class JCBPredication { — The nearest equivalent of a sentence

int mainPredicate; — Predicate word index, or -1 if n/a or mixed

Vector<JCBTense> tense; — Tenses, if any

void AddArgToEndOfArgList(JCBArgument); — Adds the

argument to the end of the predication's list

— 244 —

String ToPrologPredicateOnly(); — Forms the predicate portion of

the Prolog representation of the current item

String ToPrologArgumentsOnly(); — Forms the argument portion of

the Prolog representation of the current item

String ToPrologNoTense(); — Forms the predication portion of the

Prolog representation of the current item

static String FillArgsOut(int); — Changes the Prolog

representation of a variable-length argument list to a fixed-

length list

enum logic FastProveGeneric(JCBGrammar); — Performs certain

items common to several different FastProve routines

void RefactorTense(); — Performs a Refactor on the tense vector, in

place

boolean TenseUses(int); — Determines if the tense vector uses the

specified variable

void MergeIntoTense(Vector); — Adds the contents of the specified

tense vector into the current object's tense vector

static JCBPredication Parse(); — Parses the object type

(whichever object type it's called for), returning a new such

object

double TenseVeracity(); — Returns the Veracity calculation for the

tense vector

— 245 —

boolean TenseContainsAQuestion(); — Returns the

ContainsAQuestion calculation for the tense vector

String TensesToEnglish(); — Returns the combined ToEnglish result

for the tense vector

String TensesToXML(); — Returns the combined ToXML result for the

tense vector

class JCBForAllPredication { — Contains items beginning "for

all"

Vector<Integer> codedVariable; — List of variables used

JCBPredication predication; — The predication true for all such

variables

}

class JCBThereExistsPredication { — Contains items beginning

"there exists"

enum atLeast {ATLEAST, ATMOST, EXACTLY}

quantityType; — The meaning of the number

specified

Vector<Integer> codedVariable; — The variables used

JCBNumber quantity; — The number of items existing

JCBPredication predication; — What exists

String ToPrologIsSuchThat(); — Formatter subroutine for the

linkage between numbers and predication

}

— 246 —

class JCBDiadicPredication extends JCBPredication { —

Contains compound predications and adjectival phrases

enum operation {BOTH, EITHER, NEITHER, IMPLIES,

IFF, EXCLUSIVELY, ADJECTIVE, JOINTLY,

SUM, PRODUCT, DIFFERENCE, QUOTIENT}

operation; — Defines the type of compound. Note

that the last 4 items are used in numerics only.

JCBPredication left; — The sub-predication appearing first

JCBPredication right; — The sub-predication appearing second

}

class JCBNotPredication extends JCBPredication { —

Negates its predication

JCBPredication predication; — The negated predication

}

class JCBSimplePredication extends JCBPredication { —

Contains the item most like a sentence

int emphasis; — When used as an adjective, this denotes the

argument position which conceptually modifies what

follows. For instance, in "go", argument 1 goes to

argument 2 to argument 3. An emphasis of 0 means "as a

traveler". An emphasis of 1 means "as a destination". An

argument of 2 means "as an origin".

— 247 —

Vector<JCBArgument> argument; — Arguments to the

predication. The vector itself may be null, and may contain

nulls.

}

class JCBConstantPredication { — Contains a true/false value,

normally just used during the Refactor process

boolean value; — The true/false value

}

}

class JCBArgument { — The subject or object of a sentence

static JCBWithPropertyArgument AssignProperty(String)

; — Used in parsing, uses the word as a propery of an item

class JCBWhatArgument {} — Acts as a fill-in-the-blank question

class JCBVariableRefArgument { — Allows a variable to act as an

argument

int variable; — Specifies the variable

}

class JCBDiadicArgument extends JCBArgument { — An

compound argument with connecting words, always

factored out through percolation

enum operation operation; — The logical connection between

the parts

JCBArgument left; — The sub-argument appearing first

JCBArgument right; — The sub-argument appearing second

— 248 —

}

class JCBLiteralTextArgument { — Holds a quoted literal as an

argument

String text; — The quoted text

static String StringToProlog(String); — Formats text for

use in Prolog (subroutine)

}

class JCBNameArgument extends JCBArgument { — Holds a

string as a name

String name; — The name string

}

class JCBHardQuantifiedArgument { — The most common form of

object, a number and a thing, such as "a cat"

enum some {LITTLE, SOME, MOST, ALL, HOW_MANY}; —

The meaning of the number. When HOW_MANY is used,

the number is not.

enum event {OBJECT, CLASS, EVENT, PROPERTY} type;

— The type of object. OBJECT is the standard form, and is

not voiced. PROPERTY is factored out through

percolation.

— 249 —

Object number; — The number of objects, or the portion of the object,

such as 0.5 for half of the class. If a JCBNumber, then

this is the actual number. If an Integer, then LITTLE

through HOW_MANY.

JCBPredication predication; — Usually, just a single word. "1

cat" would mean "a cat". "1 go anything 1 home" would

mean one who goes (to a) home.

static JCBHardQuantifiedArgument

QuantityParse(Object); — A subroutine used in

parsing quantities

}

class JCBWithPropertyArgument { — Holds an argument with a

property, always factored out using percolation

JCBArgument argument; — The actual argument which will remain

after percolation

JCBPredication predication; — The property which will be

expanded to a free-standing sentence

}

class JCBObjectifiedNumberArgument { — Allows the use of a

number as an argument

JCBNumber number; — The number so used

}

}

— 250 —

class JCBNumber { — Holds a number or numeric expression

class JCBVariableRefNumber { — Holds a variable number as a

numeric variable

int variable; — The number of the variable

}

class JCBHardNumber { — Holds an actual number

double number; — The number held

}

class JCBDiadicNumber { — Holds a numeric expression, an operator

and two operands

int operation; — The operator

JCBNumber left; — The first operand

JCBNumber right; — The second operand

static JCBNumber theParse(); — Parses and returns a numeric

expression, with "the" already seen

}

class JCBHowManyNumber {} — Numeric fill-in-the-blank question

}

class JCBTense { — Holds a single tense within the tense vector

static JCBNumber GetTimeReference(boolean); — Parses a

reference to a specific date and/or time, with the flag

stating whether we're in an After context

— 251 —

static JCBHardNumber MayTimeOfDay(Calendar, boolean);

— Parses out a particular time of day, if present

static JCBHardNumber NumericTimeOfDay(Calendar,

boolean); — Parses out a numeric time of day, known

to be present (as opposed to "noon" or the like)

static JCBHardNumber GetPeriod(int, Calendar); — Parses

out a period of time, often an offset within a broader time

specification

static void SetCurrentWidth(double); — Sets or limits the time

period under consideration, with the width of the period

specified in seconds

static JCBNumber GetDistance(); — Parses out a distance in tenses

static JCBNumber GetOffset(); — Parses out an offset, in seconds,

in tenses

class JCBQuestionTense {} — Represents a fill-in-the-blank question

class JCBTimeTense { — Holds the time or period of occurrence

class JCBSingleTimeTense { — Holds a literal time or period

boolean whenAt; — Whether at a time

boolean whenAfter; — Whether (possibly also) after a time

boolean whenBeginning; — Whether beginning at a time

boolean whenBefore; — Whether (possibly also) before a time

boolean whenDuring; — Whether during a time

boolean whenEnding; — Whether ending at a time

— 252 —

JCBNumber earliest; — The earliest time (null if beginning-of-

time) in the period, in seconds since the start of the Java

Calendar

JCBNumber latest; — The latest time (null if forever) in the

period, in seconds

static String ToEnglishWhen(JCBNumber); — Converts

a time in seconds to JCB-English

static boolean IsLeapYear(int); — Determines whether

a year is leap or not

double EarliestStart(); — Returns the earliest starting time

in a period

double LatestStart(); — Returns the latest starting time in a

period

double EarliestEnd(); — Returns the earliest ending time in a

period

double LatestEnd(); — Returns the latest ending time in a

period

}

class JCBWhenTimeTense {} — Holds a time question

class JCBPotentiallyTimeTense {} — "potentially" is a

special time, of sorts

}

class JCBVeracityTense { — Specifies how certain we are in general

— 253 —

class JCBCertaintyTense { — Specifies how certain we are in

particular

enum certainty {AS_A_GUESS, AS_A_BELIEF,

LIKELY, ON_GOOD_AUTHORITY, CERTAINLY}

certainty; — The certainty of the predication

}

class JCBAccordingToTense { — According to a person or other,

a type of veracity

JCBArgument argument; — Who or what is making the

statement

}

}

class JCBLocationTense { — Holds a generalized location

class JCBWhereLocationTense {} — Holds a location question

class JCBFromLocationTense { — Holds some sort of location,

with a precise or imprecise distance

JCBArgument base; — The place from which the distance is

measured

class JCBIndefiniteLocationTense { — Represents an

imprecise location from the base above

enum where {NEAR, FAR} where; — Whether near or far

from the base. English has only these two, but in Spanish,

for instance, there are the concepts of aquí, alli, and alla, so

additional items may be required.

— 254 —

}

class JCBDefiniteLocationTense { — Holds a definite

location, which may be a range

JCBNumber minDistance; — The minimum distance in

meters. Null is zero.

JCBNumber maxDistance; — The maximum distance in

meters. Null is infinite. If the item is at an exact distance,

then these two numbers match.

}

}

}

}

}

class JCBPrologInterface { — Used to interface to RelFun, stubbed out

currently

static JCBGrammar RetrievePrologResult(); — Get the result line's

argument values

static enum logic Compile(String); — Compile a program program

static enum logic Submit(String); — Submit a query against a

program

static enum logic RetrieveYesNoResult(); — Retrieve the

Yes/No/Maybe result from RelFun

}

— 255 —

REFERENCES

Agarwal & Shahshahani, patent application #2004-0085162, Method and apparatus for

providing a mixed-initiative dialog between a user and a machine, May 6, 2004.

Agichtein, Eugene et al. (2001). Learning search engine specific query transformations

for question answering. Proceedings of the 10th international conference on

World Wide Web, 2001, pages 169-178. ACM.

—, — et al. (2004). Learning to find answers to questions on the Web. ACM

Transactions on Internet Technology. May, 2004, pages 129-162. ACM.

Ahamed. Patent #5,809,493. Knowledge processing system employing confidence levels.

September 15, 1998.

Andrenucci, Andrea & Sneiders, Eriks. (2005). Automated Question Answering:

Review of the Main Approaches. Proceedings of the Third International

Conference on Information Technology and Applications, 2005. IEEE.

Appelt et al. Patent application #2003-0078766. Information retrieval by natural

language querying. April 24, 2003.

Armstrong. Patent #5,855,002. Artificially intelligent natural language computational

interface system for interfacing a human to a data processor having human-like

responses. December 29, 1998.

Bangalore et al. Patent application #2003-0130841. System and method of spoken

language understanding in human computer dialogs. July 10, 2003.

Baral, Chitta and Tari, Luis. (2006). Using AnsProlog with Link Grammar and WordNet

for QA with deep reasoning., 2006. IEEE.

— 256 —

Beauregard & Armijo-Tamez. Patent-related document #RE-39,090. Semantic user

interface. May 2, 2006.

Beeman, William et al. (1987). Hypertext and Pluralism: From Lineal to Non-lineal

Thinking. Hypertext Papers, November, 1987, pages 67-88.

Beierle, Christoph et al. (1993). Knowledge Representation for Natural Language

Understanding: The LLILOG Approach. IEEE Transactions on Knowledge and

Data Engineering, June 1993, Pages 386-401. IEEE.

Bennet. Patent application #2005-0080614. System & method for natural language

processing of query answers. April 14, 2005.

—. Patent application #2005-0086049. System & method for processing sentence based

queries. April 21, 2005.

Boley, Harold & Sintek, Michael. (1995). Open-World Datalog. <http://www.dfki.uni-

kl.de/vega/relfun+/extension/subsection3_3_1.html> [2007, March 14].

Bralich et al. Patent #5,878,385. Method and apparatus for universal parsing of

language. March 2, 1999.

Brassell & Miller. Patent #6,553,372. Natural language information retrieval system.

April 22, 2003.

Bratko, Ivan. (2001). Prolog Programming for Artificial Intelligence. Harlow, England:

Pearson Addison Wesley.

Brill, Eric, et al. (2002). An Analysis of the AskMSR Question-Answering System.

Proceedings of the Conference on Empirical Methods in Natural Language

Processing, July 2002, pages 257-267. ACM

— 257 —

Brody. Patent application #2004-0215612. Semi-boolean arrangement, method, and

system for specifying and selecting data objects to be retrieved from a collection.

October 28, 2004.

Brown et al. Patent #6,665,666. System, method and program product for answering

questions using a search engine. December 16, 2003.

Brown, James. (1960). Loglan. Scientific American. June, 1960. Pages 53-63.

Scientific American, Inc., Ney York, New York.

—, —. (1975). Loglan 1, Loglan: A Logical Language, Gainesville, Florida: The

Loglan Institute:

—, —. (—). Loglan 2, Loglan: A Logical Language, Gainesville, Florida: The Loglan

Institute:

—, —. (1978). Loglan 3, Loglan: A Logical Language. Xerox Press.

—, —. (—). Loglan 4, Loglan: A Logical Language. Xerox Press.

—, —. (—). Loglan 5, Loglan: A Logical Language. Xerox Press.

—, —. (1999). Loglan 1: A Logical Language.

<http://www.loglan.org/Loglan1/forward.html> [2007, March 1].

Burek, Gaston et al. (2005). Hybrid Mappings of Complex Questions over an Integrated

Semantic Space. Proceedings of the 16th International Workshop on Database

and Expert Systems Applications, 2005. IEEE.

Capek, Karel. Rossum's Universal Robots (Broadway play), 1920.

— 258 —

Cardie, Claire et al. Examining the role of statistical and linguistic knowledge sources in

a general-knowledge question-answering system, Proceedings of the sixth

conference on Applied natural language processing, 2000, pages 180-187.

Morgan Kaufmann Publishers Inc.

Carter, James. (1991). Guaspi, an Artificial Natural Language.

<http://www.math.ucla.edu/~jimc/guaspi/acmpaper.html>. [2007, March 1].

Chalupsky, Hans. (2006). PowerLoom Documentation.

<http://www.isi.edu/isd/LOOM/PowerLoom/documentation> [2007, March 14].

Chang. Patent application #2006-0123045. Natural language expression in response to

a query. June 8, 2006.

Chen, Wei et all. (2006). A User-Reputation Model for a User-Interactive Question

Answering System. Proceedings of the Second International Conference on

Semantics, Knowledge, and Grid, 2006. IEEE.

Coffman. Patent application #2003-0014260. Method and system for determining and

maintaining dialog focus in a conversational speech system. January 16, 2003.

Cooper, William. (1964). Fact Retrieval and Deductive Question-Answering

Information Retrieval Systems, Journal of the ACM, April 1964, pages 117-137.

ACM

Datig. Patent application #2002-0198697. Universal epistemological machine (a.k.a.

android). December 26, 2002.

—. Patent application #2005-0005266. Method of and apparatus for realizing synthetic

knowledge processes in devices for useful application. January 6, 2005.

— 259 —

Diederiks & Van De Sluis. Patent application #2001-0056364. Method of interacting

with a consumer electronics system. December 27, 2001.

Dixon et al. Patent #5,088,048. A method to speed up problem solvers and provers.

February 11, 1992.

Dusan & Flanagan. Patent application #2002-017805. System and method for adaptive

language understanding by computers. November 28, 2002.

Einstein, Albert. (1916). Die Gundlage der allgemein Relativitätstheorie (The Basis of

General Relativity Theory). Annalen der Physik (Annals of Physics), 1916 #7,

pages 769-821.

Ejerhed. Patent #7,058,564. Method of finding answers to questions. June 6, 2006.

Eldredge et al. Patent #6,697,801. Methods of hierarchically parsing and indexing text.

February 24, 2004.

Epstein. Patent application #2002-0123891. Hierarchical language models. September

5, 2002.

Fain & Fain. Patent application #2002-0169597. Method and apparatus providing

computer understanding and instructions from natural language. November 14,

2002.

Firman. Patent #5,377,303. Controlled computer interface. December 27, 1994.

Ford. Patent application #2003-0144831. Natural language processor. July 31, 2003.

Fuchs, Norbert et al. (1999). Attempto Controlled English Language Manual Version

3.0. Geneva, Switzerland: Institut für Informatik der Universität Zürich.

Fuchs, Norbert & Schwertel, Uta. (2002). Reasoning in Attempto Controlled English.

Technical Report, January, 2002. Institut für Informatik, Universität Zürich.

— 260 —

Fujisawa et al. Patent #5,404,506. Knowledge based information retrieval system. April

4, 1995.

— et al. Patent #6,182,062. Knowledge based information retrieval system. January 30,

2001.

— et al. Patent #5,555,408. Knowledge based information retrieval system. September

10, 1996.

Fung et al. Patent #6,687,689. System and methods for document retrieval using natural

language-based queries. February 3, 2004.

Goertzel, Ben. (2005). Potential Computational Linguistics Resources for Lojban.

<http://www.goertzel.org/new_research/lojban_AI.pdf> [2007, March 1].

—, —. (2006). Lojban++: An Efficient, Minimally Ambiguous, User-Friendly Natural-

Like Language for Human-Computer, Computer-Computer and Human-Human

Communication. <http://www.goertzel.org/papers/lojbanplusplus.pdf> [2007,

March 20].

Goss et al. Patent #4,667,290. Compilers using a universal intermediate language. May

19, 1987.

Gould et al. Patent #5,920,836. Word recognition system using language context at

current cursor position to affect recognition probabilities. July 6, 1999.

Green, C. & Raphael, Bertram. (1968). The use of theorem-proving techniques in

question-answering systems. Proceedings of the 1968 23rd ACM national

conference table of contents, 1968, pages 169-181. ACM.

Greetha, T. & Subramanian, R. (1990). Representing Natural Language with Prolog,

IEEE Software, March 1990, Pages 85-92. IEEE.

— 261 —

Guo et al. Patent application #2003-0144055. Conversational interface agent. July 31,

2003.

Hagen & Stefanik. Patent application #2005-0010415. Artificial intelligence dialogue

processor. January 13, 2005.

Hao, Tianyong et al. (2006). Semantic Pattern for User Interactive-Question Answering.

Proceedings of the Second International Conference on Semantics, Knowledge,

and Grid, 2006. IEEE.

Harrison et al. Patent application #2003-0069880. Natural language query processing.

April 10, 2003.

Hartley, Roger. (1986). An Overview of Conceptual Programming.

<http://www.cs.nmsu.edu/~rth/publications/overviewCP.pdf> [2007, March 14].

Haszto et al. Patent #6,192,338. Natural language knowledge servers as network

resources. February 20, 2001.

Hawkinson & Anderson. Patent application #2004-0122661. Method, system, and

computer program product for storing, managing and using knowledge

expressible as, and organized in accordance with, a natural language. June 24,

2004.

Hirtle, David. (2006). Translator: A Translator from Language to Rules.

<http://www.ruleml.org/translator> [2007, March 19].

Ho & Tong. Patent #6,498,921. Method and system to answer a natural-language

question. December 24, 2002.

Hogenhout & Noble. Patent #7,062,428. Natural language machine interface. June 13,

2006.

— 262 —

Hsu & Boonjing. Patent application #2002-0059069. Natural language interface. May

16, 2002.

Jennings, James, editor. (2006). Loglan.org. <http://www.loglan.org> [2006, December

23].

Joshi, Aravind. (1977). Some extensions of a system for inferencing on partial

information. ACM SIGART Bulletin, Deductive inference: question

answering/theorem proving, June 1977, page 7. ACM.

Jowel & Kessock. Patent #7,103585. System and method for logical agent engine.

September 5, 2006.

Jung. Patent #6,950,827. Methods, apparatus, and data structures for providing a

uniform representation of various types of information. September 27, 2005.

Kang, In-Su et al. (2002). Database Semantics Representation for Natural Language

Access, Proceedings of the First International Symposium on Cyber Worlds,

2002. IEEE.

Kasravi & Varadarajan. Patent #7,085,750. Method and system for mapping a

hypothesis to an analytical structure. August 1, 2006.

Kautz & Selman. Patent #5,259,067. Optimization of information bases. November 2,

1993.

Klipstein. Patent application #2001-0049597. Method and system for responding to a

user based on a textual input. December 6, 2001.

Knöll, Roman & Mezini, Mira. (2006). Pegasus: first steps toward a naturalistic

programming language. Companion to the 21st ACM SIGPLAN conference on

— 263 —

Object-oriented programming systems, languages, and applications, 2006, pages

542-559. ACM.

Kobayashi et al. Patent application #2004-0054519. Apparatus and methods for

developing conversational applications. March 18, 2004.

Kuhn, Roland and Di Mori, Renato. (1995). The Application of Semantic Classification

Trees to Natural Language Understanding. IEEE Transactions on Pattern

Analysis and Machine Intelligence, May 1995, Pages 449-460. IEEE.

Kupiec. Patent #5,519,608. Method for extracting from a text corpus answers to

questions stated in natural language by using linguistic analysis and hypothesis

generation. May 21, 1996.

—. Patent #5,696,962. Method for computerized information retrieval using shallow

linguistic analysis. December 9, 1997.

Laboreo, Daniel. (2005). Lógica y lenguajes (Logic and languages).

<http://www.danielclemente.com/apuntes/ales/hl/html/hl.es.xhtml> [2007, March

1].

Lamberti et al. Patent #5,377,103. Constrained natural language interface for a

computer that employs a browse function. December 27, 1994.

LeChevalier, Robert, editor. (2006). Lojban.org. <http://www.lojban.org> [2007,

March 1].

Linker, Sheldon. (1980). A Partial Machine Grammar of Loglan. The Loglanist (also

published under the name La Loglantan), June 1980, pages 21-32. Gainesville,

Florida: The Loglan Institute.

— 264 —

—, —. (1981). An Alternative 'MEX' Proposal. The Loglanist (La Loglantan),

February, 1981, pages 16 & 17. Gainesville, Florida: The Loglan Institute.

Lita, Luvian & Carbonell, Jaime. (2004). Unsupervised question answering data

acquisition from local corpora, Proceedings of the thirteenth ACM international

conference on Information and knowledge management table of contents, 2004,

pages 607-614. ACM.

Ljungberg & Holm. (1996). Speech acts on trial. Scandinavian Journal of Information

Systems. 1996.

Logical Language Group, Inc. (wiki contributor ship). (2007). Lojban.org Home Page.

<http://www.lojban.org/tiki/tiki-index.php?page=Home+Page&bl&bl=y> [2007,

March 1].

Loveland, D. (1986). Automated theorem proving: mapping logic into AI. Proceedings

of the ACM SIGART international symposium on Methodologies for intelligent

systems, 1986, pages 214-229. ACM.

Machihara et al. Patent #6,233,578. Method and system for information retrieval. May

15, 2001.

Marchiori, Massimo. (2004). Towards a People's Web: Metalog, Proceedings of the

IEEE/WIC/ACM International Conference on Web Intelligence, 2004. IEEE.

Matheson. Patent #7,024,368. Man-machine dialogue system, controls dialogue between

systems and user using dialogue specification employing augmented transition

networks propagating tokens. April 4, 2006.

— 265 —

Matzner, Tobias & Hitzler, Pascal. (2006). Any-World Access to OWL through Prolog.

<http://www.aifb.uni-karlsruhe.de/WBS/phi/resources/publications/prowlog.pdf>

[2007, March 14].

McConnell & Barklund. Patent #6,993,475. Methods, apparatus, and data structures for

facilitating a natural language interface to stored information. January 31, 2006.

Metcalf & Dingus. Patent application #2004-0044515. Automated natural language

inference system. March 4, 2004.

Miller et al. Patent #6,393,428. Natural language information retrieval system. May 21,

2002.

Minker, Jack. (1977). Control structure of a pattern-directed search system. Deductive

inference: question answering/theorem proving, June 1977, pages 7-14. ACM.

—, —. (1978). Search strategy and selection function for an inferential relational

system. ACM Transactions on Database Systems, March 1978, pages 1-31.

ACM.

Moldovan, Dan et al. (2003). COGEX: a logic prover for question answering.

Proceedings of the 2003 Conference of the North American Chapter of the

Association for Computational Linguistics on Human Language Technology,

2003, pages: 87-93. Association for Computational Linguistics

Moser et al. Patent #6,275,789. Method and apparatus for performing full bidirectional

translation between a source language and a linked alternative language. August

14, 2001.

Nakamura & Tate. Patent #6,941,295. Data access system. September 6, 2005.

— 266 —

Namba et al. Patent #5,555,169. Computer system and method for converting a

conversational statement to computer command language. September 10, 1996.

Ohlman, Herbert. (1961). Pro a Special IR Language. Design, Implementation and

Application of IR-Oriented Languages, 1961, pages 8-10. ACM.

Phillips, Web & Boroditsky, Lera. (2003). Can quirks of grammar affect the way you

think? Grammatical gender and object concepts. Proceedings from the 25th

Annual Meeting of the Cognitive Science Society, 2003, pages 928-933.

Pinto, David et al. (2002). QuASM: a system for question answering using semi-

structured data. Proceedings of the 2nd ACM/IEEE-CS joint conference on

Digital libraries, 2002, pages 46-55. ACM.

Prothero, Jeff. (1990). Design and Implementation of a Near-optimal Loglan Syntax.

<http://www.rickharrison.com/language/plan_b.html> [2007, March 1].

—, —, et al. (1994). Loglan Grammar as of Dec 94.

<http://loglan.org/Misc/grammar80.y> [2007, March 1].

Pustejovsky & Ingria. Patent application #2001-0039493. Answering verbal questions

using a natural language system. November 8, 2001.

Radev, Dragomir et al. (2001). Mining the web for answers to natural language

questions. Proceedings of the tenth international conference on Information and

knowledge management, 2001, pages 143-150. ACM.

Ramakrishnan, Ganesh et al. (2003). Question Answering via Bayesian inference on

lexical relations. Proceedings of the ACL 2003 workshop on Multilingual

summarization and question answering, 2003, pages 1-10. Association for

Computational Linguistics.

— 267 —

—, — et al. (2004). Is question answering an acquired skill?. Proceedings of the 13th

international conference on World Wide Web table of contents, 2004, pages 111-

120. ACM.

Reiter, Raymond. An approach to deductive question-answering systems. ACM SIGART

Bulletin, Natural Language interfaces, 1977, pages 41-43. ACM.

Romero. Patent application #2002-0111803. Method and system for semantic speech

recognition. August 15, 2002.

Ross et al. Patent application #2002-0138266. Method and apparatus for converting

utterance representations into actions in a conversational system. September 26,

2002.

— et al. Patent #6,950,793. System and method for deriving natural language

representation of formal belief structures. September 27, 2005.

Rosser & Sturges. Patent application #2006-0069546. Autonomous response engine.

March 30, 2006.

Roussinov, Dmitri & Robles, Jose. (2004). Self-learning web question answering

system. Proceedings of the 13th international World Wide Web conference on

Alternate track papers & posters, 2004, pages 400-401. ACM.

Salanha at al. Patent #6,714,939. Creation of structured data from plain text. March 30,

2004.

Scheneburg et al. Patent application #2002-0133347. Method and apparatus for natural

language dialog interface. September 19, 2002.

Schramm. Patent #4,670,848. Artificial intelligence system. June 2, 1987.

Schwartz. Patent #5,812,840. Database query system. September 22, 1998.

— 268 —

Schwartz et al. Patent #5,197,005. Database retrieval system having a natural language

interface. March 23, 1993.

Sekine, Satoshi & Grishman, Ralph. (2003). Hindi-english cross-lingual question-

answering system. ACM Transactions on Asian Language Information

Processing, September 2003, pages 181-192. ACM.

Sheu & Kitazawa. Patent application #2004-0088158. Structured natural language

query and knowledge system. May 6, 2004.

Sharon Small, Sharon et al. (2003). HITIQA: an interactive question answering system a

preliminary report. Proceedings of the ACL 2003 workshop on Multilingual

summarization and question answering, 2003, pages 46-53. Association for

Computational Linguistics.

Rob Speer, Rob & Havasi, Catherine. (2004). Meeting the Computer Halfway:

Language Processing in the Artificial Language Lojban, Proceedings of MIT

Student Oxygen Conference, MIT.

<http://sow.lcs.mit.edu/2004/proceedings/Speer.pdf> [2007, March 5].

Spiegler & Gelbard. Patent application #2002-0087567. Unified binary model and

methodology for knowledge representation and for data and information mining.

July 4, 2002.

Srihari, Rohini & Li, Wei. (2000). A question answering system supported by

information extraction. Proceedings of the sixth conference on Applied natural

language processing, 2000, pages 166-172. Morgan Kaufmann Publishers Inc.

Stier & Haughton. Patent #6,499,024. Method and system for development of a

knowledge base system. December 24, 2002.

— 269 —

Strong. Patent #6,311,157. Assigning meanings to utterances in a speech recognition

system. October 30, 2001.

—. Patent #6,704,710. Assigning meanings to utterances in a speech recognition system.

March 9, 2004.

Suda. Patent #5,282,265. Knowledge information processing system. January 25, 1994.

Suda & Jeyachandran. Patent application #2003-0144977. Information processing

system which understands information and acts accordingly and method therefor.

July 31, 2003.

Sukehiro et al. Patent application #2004-0205671. Natural language processing system.

October 14, 2004.

Tsourikov. Patent application #2002-0116176. Semantic answering system and method.

August 22, 2002.

Tunstall-Pedoe. Patent #7,013,308. Knowledge storage and retrieval system. March 14,

2006.

Yano et al. Patent #6,466,899. Natural language dialogue apparatus and method.

October 15, 2002.

Waltz, David. (1978). An English language question answering system for a large

relational database. Communications of the ACM, July 1978, pages 526-539.

ACM.

Wang. Patent application #2006-0190268. Distributed language processing system and

method of outputting intermediary signal thereof. August 24, 2006.

— 270 —

Wang et al. Patent application #2004-0225499. Multi-platform capable inference engine

and universal grammar language adapter for intelligent voice application

execution. November 11, 2004.

Wang, Chun-Chia et al. (2006). An Application of Question Answering System for

Collaborative Learning. Proceedings of the 26th IEEE International Conference

on Distributed Computing Systems Workshops, 2006. IEEE.

Weber. Patent #6,499,013. Interactive user interface using speech recognition and

natural language processing. December 24, 2002.

Williams & Hill. Patent application #2005-0105712. Machine learning. May 19, 2005.

Wyss et al. Patent application #2002-0026435. Knowledge-base system and method.

February 28, 2002.

Zhang & Yang. Patent application #2002-0077815. Information search method based on

dialog and dialog machine. June 20, 2002.

A Knowledge Base and Question Answering System Based on Loglan and English

Documents

Transcript of A Knowledge Base and Question Answering System Based on Loglan and English