HOME


Autonomous Artifacts That Think - AI Agents

Version 1.004 2022-11-10
Version 1.003 2021-08-01
Version 1.002 2020-04-24
Version 1.001 probably during 2015

Author:
Richard Weyhrauch (IBUKI)
Note:
This is an original personal document of Richard Weyhrauch hosted by IBUKI at http://rww.ibuki.com . This document is not in the public domain. The copyright is held by him and anyone wanting to reprint it must get his permission in writing. This document was written while he was employed by IBUKI but on his own time, at at his own expense.

Abstract

This document addresses five aspects of building an AI agent: what is a though/'mental image'; what constitutes a 'mental state'; what does it mean to think; what does it mean to make a judgement; and how does an artifact interact with the world and modify its 'mental state' as a result. This document makes specific proposals about each issue. These ideas have been tested at IBUKI in the following programs: IBML, SEUS, Mindbuilder, HEAD and FRED, but IBUKI has not yet released these and their documentation is proprietary.

Introduction

"The purpose of Language is to communicate our thoughts"
             John Horne Tooke, "The Diversions of Purley" (1857)

Can a computer 'think'? What would be needed. I began thinking about this question over 40 years ago with the development of the FOL system at the Stanford AI Lab. It has developed into a collection of three systems that are defined 'mutually recursively' that integrate notions of representing 'objects', (a system of 'types'), representing change (computation systems), and a new look at logic as a tool for carrying out (rather than explaining) reasoning (the logic NEWFOL). Taken together, these three systems can be used to build an AI agent that can think. NEWFOL uses the objects of the type system and programs of computation systems as replacements for parts of the original FOL system that had theoretical deficiencies and answer questions left vague in the original FOL semantics. These three systems together support building software that can 'think'.

Can we build az AI agent —one who can talk to us and have their own 'independent' thoughts about the world, one that listens, speaks and interacts with the world using sensors and affectors and can bridge the gap between perceptual and cognative data? NEWFOL explains how to draw boundries between a 'thinking' system and its exterior opening the possibility for genuine autonomy.

The Building of Mind

Here we are interested in both metaphysics and architecture. We want to understand what it means to think and what machinery is needed to make thinking happen, including what are the data structures of thought?. Our answer is to define 'types', a collection of data structures that can be used as 'mental models', i.e., thoughts.

Thoughts

We propose [type]s, as formalized in The Theory of IBML (a Word file) as the data structures used as the 'mental images' of things. In our HEAD each thought is a [type]. A 'mental state' is just a collection of thoughts. The ambitious claim is that these [type]s are rich enough to describe any thought, but even if that claim falls short, they are semantically cleaner and more expressive then any of the current 'object' systems (JAVA, CLOS, RDF, ... ). One main difference is that [type]s do not have instances, i.e., all objects can be subtyped!!! The semantics of types is information theoretic rather than set theoretic, meaning that in all cases knowing more about an object takes you down the type hierarchy. This mimics 'real life' where we can always attribute more properties to some object (a red 3 or a round square!!!). [type]s are also updatable, meaning that an object can maintain its identity even when our 'mental image' of it changes (our 'mental image' of a person may change if we discover they have a dog or if we suddently come to know who their mother is - we really don't imagine that this is a 'new' person!!!!). The IBUKI system IBML (IBUKI Modeling Language) was designed to be used either as a stand alone library of data structures in any application or as part of a HEAD, IBUKIs implementation of 'mind'.

These [type]s are a decendent of the type theory described by Luca Cardelli for the programming language AMBER. They were first enhanced to be used as a modeling language for solving configuration problems. It's current invocation is in the spirit of SKOS and RDF languages (e.g., Protege) but they have a much richer semantics.

Mental Activity

Computation Systems were formalized in Computation Statems with Restartable Computations an unpublished paper of Talcott and Weyhrauch. A computation system is what does the 'thinking'. The restartable computations of a computation system is what allows HEAD to not get caught 'thinking' to long about something or being in an 'infinite loop' of thought. The computations of a computation system are used in the definition of the simulation structures of NEWFOL, rather than the programs of some programming language. This also introduces updating operations and restartable computation into NEWFOL (logic) and thus into HEAD in a semantically rigorous way.

Computation systems and SEUS starts with the LISP 1.5 Manual, owes its style to Scheme as described in xxx, to RUM in CLTs thesis and to the abstraction of it all in an unpublished paper xxx by Talcott and Weyhrauch.

Making Judgements - Predication

The proposal here is to use NEWFOL to organize thinking and reasoning into NEWFOL contexts. NEWFOL 'fixes' 'fixes' the hole in the theory of the old FOL system which left the semantics of the data used in the construction of simplification structures vague. The use of [type]s as the representation of objects of the 'domain' and SEUS programs to represent 'function' and 'predicate' symbols in simulation structures guarentees both: that NEWFOL has a definable semantics; and, that it is realizable as data in the memory of a modern competer. The semantics of NEWFOL (found here) was developed by Richard Weyhrauch. NEWFOL (the program) is a reimplementation of the original FOL. 

-------------------------------------------------------------------------------
History

The original FOL 'finitized' model theory using simulation structures,
which used LISP s-expressions for objects in the domain and LISP programs to
as the 'predicates' and 'functions' of a model. But the understanding of what
object was represented by what s-expression was still in the head of the FOL
system developers and the LISP interpreter falls well short of a computation
system. This was OK when FOL was used as a 'proof assistant' but falls short
as part of a cognative architecture. IBML and SEUS (as a computation system)
address these issues.

-------------------------------------------------------------------------------

Software that Thinks - the HEAD of our Thinker

The three systems outlined above form a coherent mutually recursive set of finite data structures with a clean semantics. The mutual recursive nature of these structures becomes apparent as soon as we realize that, if the three systems and their semantics are to be understandable to our thinker then there is: a 'mental image' (a [type]) of each od the three systems and every associated notion; a NEWFOL context describing each system, including NEWFOL itself (this context is called Meta in the old FOL), and the computation system must be able to compute on both [type]s and NEWFOL contexts. We call the joined systems HEAD. A version of HEAD has been coded in Allegro LISP by IBUKI.

Meet FRED - The BODY

Just having a HEAD that thinks thinks, without interacting with the world is pretty 'self centered'. BODY also includes sensors and effectors (perpherals) We describe FRED, a full blown autonomous artifact (containing both a HEAD and BODY) who can communicate with others in its world, learn (or be taught or told) new things, think about what it hears, tell you about its thoughts and make decisions about its behavior (From now on I will personify FRED as male and use 'he', 'him' and 'his' to refer to him). Like us, he can forget things and change his focus when he encounters a new situation.

Conversation: Listening and Speaking

Fred can have conversations with others by 'listening' and 'speaking'. These conversations can either be in a very structured languages (like programming languages or the sentences of some logic) with strict semantics or in some form of more 'natural Language' where 1) 'the purpose of language is to communicate ones thoughts' (Horne Tooke) and, as a practical matter, 2) it's likely that the participants in a conversation share a common 'domain of consensus' (Maturana).

Change over time

The fact that hearing something changes us (without loosing our identity) means that, at the lowest structural level, people are constantly updating themselves. For the usual semantics of logic this is a problem. Functions cannot 'change' their arguments and on the same arguments always return the same value. Set theoretic objects do not change over time. Computer programmers, on the other hand, make systems that change and update their state all the time. FRED (and any person) as a thinking entity must also change their state/ideas. This is one of the mose radical part of NEWFOL from the point of view of logicians. The models of a NEWFOL context are not sets but simulation structures build out of programs and computations that allow the 'meaning' of statements to change over time - without there being a 'new' context. This is the seed of how FRED can turn his experience of the world (perception) into cognative structure (cognition).

Details

What's in FRED (or any autonomus thinking artifact)

There are several high level requirements that can be stated as challanges to systems which claim they understand 'a lot'.

  • Theoretical Requirements
    1. FRED must be capable of having a rich world model [ONTOLOGY]
    2. HEAD must be finite [FINITE-HEADS]
    3. FRED must be conversational [CONVER]
    4. The system must be autonomous [AUTONOMOUS]
    5. It must be able to understand some of its own metatheory [METATHEORY])
    6. It must implement some form of 'the gossip principle' (RWW [GOSSIP])
    7. The system must be 'in the world' where inputs arrive and effects happen asynchronously

  • Practical Requirements
    1. Every part of FRED must exist as a finite thing
    2. Every part of FRED must a physical purchasable compenent

This note is about 1) and 2) and the practical requirements 8) and 9). It outlines strictures we believe are capable of being used to 'build a mind' and justify this claim by using it to 'solve' many of the problems of NLP, philosophy and AI in a unified framework. It has a reference implementation we use to try experiments. We hope IBUKI makes this available to everyone soon.

This work is the current state of my thinking about reasoning systems that started with the FOL system [FOL] developed at the Stanford Artificial Intelligence Labratory (SAIL) in the late 1970s and which was continued by many people and is still actively persued by R. Weyhrauch and C. Talcott at heir weekly meetings.

World Modeling

NEWFOL Contexts

A NEWFOL context makes explicit both the language that is used to talk about things, the things the context is talking about and the connection between the two. It also contains information about what it knows about the objects.

We use NEWFOL contexts as the basic building blocks of world models.

This dscription leaves vague the details of 'whay is an object' and the difference between a 'programs of a computetion system' a 'progran written in a programming language'. These details are explored below.

A NEWFOL context, C, has three parts 

  C=<L,SS,F>

A language, L, a simulation structure, SS, and finite collection of facts, F. To satisfy 8) Each of these pieces needs to be realizable as a finite data structure. For building world models, NEWFOL contexts (which are finite structures) are a replacement for the usual (ie, the logician's) notion of theory (which are infinite structures).

The Language

A NEWFOL language specifies a set of symbols (words (possibly containing spaces)) and the roles that they play when writing sentences of the language. To satisfy the requirement that an NEWFOL context be a 'formal system' (again, in the sense of logicians) we also require that there is a way of recognizing an expression and a program that can tell us if an expression is well-formed.

The Simulation Structure

A NEWFOL simulation structure is collection of individuals, and programs on them that determine the how the symbols in the language naming functions, predicates, and relations are 'computed.. At first you could imagine these as being defined in the usual way using set theory. For building world models and NEWFOL contexts in general we need to be more careful and replace set theoretic ideas with computer data and programs. When building HEAD, NEWFOL the things in the simulation structuress are the 'mental images' of things.

The Facts

An NEWFOL fact does not have meaning outside a NEWFOL context. The facts, F, of a NEWFOL context is a the finite set of facts (of C). Each fact of C has at least two attributes: a well-formed formula of L and a justification, that encodes the reason why the fact is 'in' C.

Discussion: We know that the notion of justification is vague but it is an important idea. When dealing with theories, it is common to think of the facts of a theory as just a (usually deductively closed infinite) collection of well-formed formulas. A NEWFOL fact is more like the end formula ith its derivation as proofs of natural deduction as described by Prawitz. Each fact comes (at the least) with an associated reason for being in its context. [see JUSTIFICATIONS ]

Signatures and Interpretations

We use the ordinary mathematical notion of 'signature' is the tool to describe the content and relation between languages and simulation structures. For C to be a NEWFOL context, L and SS must have the same signature, which defines an implicit map between them. We say that the simulation structure, SS, is an interpretation of the symbols of the language L.

Types - Objects - 'mental images'

Computation Structures

Content Independent Notions Involving NEWFOL Contexts

This section describes how the ordinary notions of logic can be restated for contexts eliminating any hidden commitments to infimite structures. we describe the changes NEWFOL makes to our understanding of theories without losing basic logical ideas.

In addition, we begin (informally) to write down expressions that we later use for wffs of facts in the languages of NEWFOL contexts. The infrastructure described is not reductionist but rather is described by interdependent definitions and takes a little bit of getting used to.

Generality and Uniformity

A NEWFOL context can name and contain facts about other contexts. Since NEWFOL contexts will themselves be represented as finite data structures They can appear in the simulation structures of contexts. This hierarchical organization means that a single context can itself refer to many other contexts (which in in turn can refer to others ... ). If you think of a NEWFOL context as a theory then they directly formalize metatheory. If you think of a NEWFOL context as the belief structure of an agent then they can be used to formalize relations among the belief structures of multiple agents. If you imagine that the structures in the model of a NEWFOL context are the 'mental images' of the things that the context mentiones, then we can build contexts that 'know about', for example, Frege's notions of sense and reference (Zinn und Bedeutung) as well as use and mention. ... .

These ideas and more are expanded in tbe NEWFOL docs and notes.

Inference

The fact that we can interpret the symbols of the language of an NEWFOL context in its simulation structure allows us introduce the notion of inference.

Consider the NEWFOL context C=<L,SS,F>.

Satisfaction

We extend the notion of interpretation to all the well-formed expressions of L. We call this extended function 'SATISFIES' and use it to decide, for any [wff] of L whether or not it holds or not - relative to C. We introduce a relation 

  (1) (SATISFIED-BY wff C) =def= (SATISFIES wff SS)

where wff is in L.

Consistency

We say a set W of [wff]s of L is consistent and write 

  (2) (WFF-LIST-CONSIST W) =def= (FORALL w in W (CONTEXT-SATISFIES w C))

Let 

  (3) (context-get-wffs C) =def= 
    {w |(AND (list-member f F) (= (fact-get-wff f) w)))}

The consistency of a NEWFOL context as 

  (4) (CONTEXT-CONSIST C) =def= (WFF-LIST-CONSIST (context-get-wffs C))

We say a [wff], w, of L is consistent with C if 

  (5) (WFF-LIST-CONSIST (set-union {w} (content-get-wffs C)))

The exact meaning of 'definition' is described below. Note that 

 (context-get-wffs-of C)
is always finite set. We also remark here that there may be 'implicit' facts of C not explicitly in the F, eg [sort] information. The NEWFOL language documentation explains this. The 'implicit' [wff]s will be included by context-get-wffs.

Conclusions

The notion that a wff of L can be concluded from C simply means that the wff is consistent with C,

Discussion: Unlike tradional theories a [wff] does not need to be the wff of a fact in C to be concluded from C. With respect to a NEWFOL contexts, C, we distinguish 'a conclusions of C' from the 'facts of C'. Thus we seperate the operation of concling a [wff], f, from and the operation of 'adding' f as the wff of a fact of C. The new fact will have f as its wff and will reference why f was a conclusion in its justification. See [SATvsVAL]

Rule of Inference

We define a rule of inference on contexts as any function, r, that maps an NEWFOL context (with possible additional arguments) to an NEWFOL context that preserves consistency, ie 

  (6) (IMPLIES (CONTEXT-CONSIST C) (CONTEXT-CONSIST (r C ...)))

There are several options here for the meaning of INPLIES. This is discussed in [BEFORE-AFTER].

These notions are 'just like' those of classical logic, i.e., have the same definitions, but when they refer to NEWFOL contexts they acquire more nuanced meanings. This is an indication that the analysis by logicians of these notions has been 'correct' but the logician's notion of theory has been wrong.

To summarize: NEWFOL replaces the notion of theory with that of a NEWFOL context. The proof of the pudding will be artifacts like FRED. Until we actually can chat with FRED (using contexts in his HEAD) and the differences are actually make him viable. 


77777777777777777777777777777777777777777777777777

Here we justify our claim that FOL contexts is powerful enough to model
everything in one unified way. Even if this claim eventually proves overly
optimistic, we show below that the use of FOL contexts makes a qualative
leap over existing systems for realizing goals above.

------------------------------------------------------------------------

Cognative Systems - Software that Thinks

One of IBUKI's goals it to build software that can think. This effort was started by Richard Weyhrauch over 40 years ago with the development of the FOL system at the Stanford AI Lab. Today it survives as an integration system based on IBML, SEUS, NEWFOL, three mutually recursively defined systems that implement RWWs current understanding of what is needed to build a software system that can think. NEWFOL uses IBML and SEUS as replacements for parts of the original FOL system that had theoretical deficiencies and answer questions left vague in the original FOL semantics. HEAD combines these three IBUKI Systems into an app that can 'think'.

The system FRED implements the conversational requirements of a cognative system. It listens, speaks and interact with the world using sensors and effectors. FRED uses HEAD to think. This is a full cognative system that spans the gap between perceptual and cognative data.

HEAD - The Building of Mind

This system is called HEAD rather then MIND because we are interested in architecture not metaphysics. The goal here is not to end up with some abstract ideas about what and how people might think, but to write software that can think. This forces us to ask: what data structures are used in HEAD?. IBUKI's answer to this question is the system IBML, an implementation of the type theory of Richard Weyhrauch (XXX).

IBML

IBML [type]s define HEAD's 'mental images' of things. We implement each thought in HEAD as a [type] as defined in IBML. The ambitious claim is that IBML [type]s are rich enough to describe any thought, but at the very least they are semantically cleaner and more expressive then any of the current 'object' systems (JAVA, CLOS, RDF, ... ). One unexpected property of IBML is that [type]s do not have instances, i.e., all objects can be subtyped!!! The semantics of IBCL is information theoretic rather than set theoretic, meaning that in all cases knowing more about an object takes you down the type hierarchy. This mimics 'real life' where we can always attribute more properties to some object (a red 3 or a round square!!!). IBML [type]s are also updatable, meaning that an object can maintain its identity even when our 'mental image' of it changes. (our 'mental image' of a person may change if we discover they have a dog or if we suddently come to know who their mother is - but we really don't usuall imagine that this is a 'new' person!!!!). As a stand alone system IBML can be used in any application that models information.

IBML [type]s are an extension of the type theory described by Lucca Cardelli for the programming language AMBER. It was then enhanced to be used as a modeling language for solving configuration problems. Its current invocation is in the spirit of SKOS and RDF languages (e.g., Protege) but it has a richer semantics.

SEUS

SEUS is what make 'thinking' happen.

SEUS is not just a programming language but is a full blown computation system. The use of SEUS programs to define the semantics of NEWFOL, rather than functions, whose definitions as set theoretic objects require the availability of 'infinite objects' as the interpretations of 'function' and 'predicate' symbols allows us to 1) replace functions (infinite things) with SEUS programs (whose semantics only contains finite objects) and 2) to introduce updating operations into logic in a semantically rigorous way.

NEWFOL

NEWFOL organizes HEAD's thinking and reasoning into first order contexts. It implements a version of the original FOL which 'fixes' the semantics of FOL to guarentee that tures to part of the system, i.e., so that it can be implemented in the memory of a computer. It is based on the a logic system also called NEWFOL by Richard Weyhrauch. IBML and SEUS implement 'finite' fixes to the semantics of the original FOL. 

-------------------------------------------------------------------------------
History

The original FOL 'finitized' model theory using simulation structures,
which used LISP s-expressions for objects in the domain and LISP programs to
as the 'predicates' and 'functions' of a model. But the interpretation of an
s-expression was still in the head of the FOL system developers and the LISP
interpreter falls well short of a computation system. This was OK when FOL
was used as a 'proof assistant' but falls short as part of a cognative
architecture. IBML and SEUS (as a computation system) address these issues.

-------------------------------------------------------------------------------

Meet FRED

Just thinking, without interacting with the world is pretty 'self centered'. FRED is a full blown (but extendable) autonomous system who can communicate with others in its world, learn (or be taught or told) new things, think about what it hears, tell you about its thoughts and make decisions about its behavior. Like us, it can forget things and change its focus as it encounters a new environment. (for details see Meet Fred)

Conversation: Listening and Speaking

Fred has conversations with others by 'listening' and 'speaking'. These conversations can either be in a very structured languages (like programming languages or the sentenses of some logic) with strict semantics or in some form of more 'natural Language' where 1) 'the purpose of language is to communicate ones thoughts' (Horne Tooke) and, as a practical matter, 2) the participants in a conversation share a common 'domain of consensus' (Maturana).

Change over time

The fact that hearing something changes us (without loosing our identity) means that, at the lowest architectural level, people are constantly updated. For current logical thought this is a problem. Functions cannot 'change' their arguments always return either the same object or somethging 'new'. Set theoretic objects do not change over time. Computer programmers, on the other hand, make systems that change and update their state all the time. FRED (and any person) as a thinking entity must also change their state/ideas. This is one of the mose radical part of NEWFOL from the point of view of logicians. The models of an FOL context are not sets but simulation structures build out of programs and computations allowing the 'meaning' of statements to change over time. (for details see Programs that Update)