------------------------------------http://en.wikipedia.org/wiki/List_of_artificial_intelligence_projects -----Main

AIML OverviewBy Dr. Richard S. Wallace

AIML, or Artificial Intelligence Mark-up Language enables people to input knowledge into chat-bots based on the A.L.I.C.E free software technology.

AIML was developed by the Alicebot free software community and I during 1995-2000. It was originally adapted from a non-XML grammar also called AIML, and formed the basis for the first Alicebot, A.L.I.C.E., the Artificial Linguistic Internet Computer Entity.

AIML, describes a class of data objects called AIML objects and partially describes the behavior of computer programs that process them. AIML objects are made up of units called topics and categories, which contain either parsed or unparsed data.

Parsed data is made up of characters, some of which form character data, and some of which form AIML elements. AIML elements encapsulate the stimulus-response knowledge contained in the document. Character data within these elements is sometimes parsed by an AIML interpreter, and sometimes left unparsed for later processing by a Responder.

CATEGORIES

The basic unit of knowledge in AIML is called a category. Each category consists of an input question,an output answer, and an optional context. The question, or stimulus, is called the pattern. Theanswer, or response, is called the template. The two types of optional context are called "that" and"topic." The AIML pattern language is simple, consisting only of words, spaces, and the wildcard symbols _ and *. The words may consist of letters and numerals, but no other characters. The pattern language is case invariant. Words are separated by a single space, and the wildcard characters function like words.

The first versions of AIML allowed only one wild card character per pattern. The AIML 1.01 standard permits multiple wildcards in each pattern, but the language is designed to be as simple as possible for the task at hand, simpler even than regular expressions. The template is the AIML respons or reply. In its simplest form, the template consists of only plain, unmarked text.

More generally, AIML tags transform the reply into a mini computer program which can save data, activate other programs, give conditional responses, and recursively call the pattern matcher to insert the responses from other categories. Most AIML tags in fact belong to this template side sublanguage.

AIML currently supports two ways to interface other languages and systems. The <system> tag executes any program accessible as an operating system shell command, and inserts the results in the reply. Similarly, the <javascript> tag allows arbitrary scripting inside the templates. The optional context portion of the category consists of two variants, called <that> and <topic>. The <that> tag appears inside the category, and its pattern must match the robot’s last utterance. Remembering one last utterance is important if the robot asks a question. The <topic> tag appears outside the category, and collects a group of categories together. The topic may be set inside any template.

AIML is not exactly the same as a simple database of questions and answers. The pattern matching "query" language is much simpler than something like SQL. But a category template may contain the recursive <srai> tag, so that the output depends not only on one matched category, but also any others recursively reached through <srai>.

RECURSION

AIML implements recursion with the <srai> operator. No agreement exists about the meaning of the acronym. The "A.I." stands for artificial intelligence, but "S.R." may mean "stimulus-response," "syntactic rewrite," "symbolic reduction," "simple recursion," or "synonym resolution." The disagreement over the acronym reflects the variety of applications for <srai> in AIML. Each of these is described in more detail in a subsection below:

    (1). Symbolic Reduction: Reduce complex grammatic forms to simpler ones.

    (2). Divide and Conquer: Split an input into two or more subparts, and combine the responses to each.

    (3). Synonyms: Map different ways of saying the same thing to the same reply.

    (4). Spelling or grammar corrections.

    (5). Detecting keywords anywhere in the input.

    (6). Conditionals: Certain forms of branching may be implemented with <srai>.

    (7). Any combination of (1)-(6).

The danger of <srai> is that it permits the botmaster to create infinite loops. Though posing some risk to novice programmers, we surmised that including <srai> was much simpler than any of the iterative block structured control tags which might have replaced it.

(1). Symbolic Reduction

Symbolic reduction refers to the process of simplifying complex grammatical forms into simpler ones. Usually, the atomic patterns in categories storing robot knowledge are stated in the simplest possible terms, for example we tend to prefer patterns like "WHO IS SOCRATES" to ones like "DO YOU KNOW WHO SOCRATES IS" when storing biographical information about Socrates.

Many of the more complex forms reduce to simpler forms using AIML categories designed for symbolic reduction:

<category><pattern>DO YOU KNOW WHO * IS</pattern><template><srai>WHO IS <star/></srai></template></category>

Whatever input matched this pattern, the portion bound to the wildcard * may be inserted into the reply with the markup <star/>. This category reduces any input of the form "Do you know who X is?" to "Who is X?"

(2). Divide and Conquer

Many individual sentences may be reduced to two or more subsentences, and the reply formed by combining the replies to each. A sentence beginning with the word "Yes" for example, if it has more than one word, may be treated as the subsentence "Yes." plus whatever follows it.

<category> <pattern>YES *</pattern> <template><srai>YES</srai> <sr/></template> </category>

The markup <sr/> is simply an abbreviation for <srai><star/></srai>.

(3). Synonyms

The AIML 1.01 standard does not permit more than one pattern per category. Synonyms are perhaps the most common application of <srai>. Many ways to say the same thing reduce to one category, which contains the reply:

<category> <pattern>HELLO</pattern> <template>Hi there!</template> </category>

<category><pattern>HI</pattern> <template><srai>HELLO</srai></template></category>

<category><pattern>HI THERE</pattern> <template><srai>HELLO</srai></template></category>

<category><pattern>HOWDY</pattern> <template><srai>HELLO</srai></template></category>

<category><pattern>HOLA</pattern> <template><srai>HELLO</srai></template></category>

(4). Spelling and Grammar correction

The single most common client spelling mistake is the use of "your" when "you’re" or "you are" is intended. Not every occurrence of "your" however should be turned into "you’re." A small amount of grammatical context is usually necessary to catch this error:

<category><pattern>YOUR A *</pattern><template>I think you mean "you’re" or "you are" not "your." <srai>YOU ARE A <star/></srai></template></category>

Here the bot both corrects the client input and acts as a language tutor.

(5). Keywords

Frequently we would like to write an AIML template which is activated by the appearance of a keyword anywhere in the input sentence. The general format of four AIML categories is illustrated by this example borrowed from ELIZA:

<category><pattern>MOTHER</pattern> <template> Tell me more about your family. </template></category>

<category><pattern>_ MOTHER</pattern> <template><srai>MOTHER</srai></template></category>

<category><pattern>MOTHER _</pattern><template><srai>MOTHER</srai></template></category>

<category><pattern>_ MOTHER *</pattern><template><srai>MOTHER</srai></template></category>

The first category both detects the keyword when it appears by itself, and provides the generic response. The second category detects the keyword as the suffix of a sentence. The third detects it as the prefix of an input sentence, and finally the last category detects the keyword as an infix. Each of the last three categories uses <srai> to link to the first, so that all four cases produce the same reply, but it needs to be written and stored only once.

(6). Conditionals

It is possible to write conditional branches in AIML, using only the <srai> tag. Consider three categories:

<category><pattern>WHO IS HE</pattern><template><srai>WHOISHE <get name="he"/></srai></template></category>

<category><pattern>WHOISHE *</pattern><template>He is <get name="he"/>.</template></category>

<category><pattern>WHOISHE UNKNOWN</pattern><template>I don’t know who he is.</template></category>

Provided that the predicate "he" is initialized to "Unknown," the categories execute a conditional branch depending on whether "he" has been set. As a convenience to the botmaster, AIML also provides the equivalent function through the <condition> tag.

TARGETING

Bot personalities are created and shaped through a cyclical process of supervised learning called Targeting. Targeting is a cycle incorporating client, bot, and botmaster, wherein client inputs that find no complete match among the categories are logged by the bot and delivered as Targets the botmaster, who then creates suitable responses, starting with the most common queries. The Targeting cycle produces a progressively more refined bot personality.

The art of AIML writing is most apparent in creating default categories, which provide noncommittal replies to a wide range of inputs. Here is a very nice example provided found on the alicebot-general mailing list:

User: Where do I find the webpage with Australopithecus?

Alice: Where do you want to find it?

User: Bad Answer Alice, time to Learn a new Line

Alice: How would you answer "Where do I find the webpage with Australopithecus?"

User: I would say: "http://www.ancientskulls.net/australopithecus.html"

Alice: Thanks, human. Try asking me again.

User: Where do I find the webpage with Australopithecus?

Alice: http://www.ancientskulls.net/australopithecus.html

This is a very nice example. This is exactly the same as targeting when the botmaster is the teacher. Or I should say, it is an AIML interface to targeting. Of course this scenario raises many problems, such as how to weed out hackers and other garbage givers, which might mean only turning on the Learn function while in a restricted sandbox, though it is the free labor of many chatters the web that could help the bot grow wise quickly.

That is the crux of the learning problem in a nutshell. It all comes down to editing. Either the botmaster edits good quality replies to begin with, or if the bot is "open to the public" then the teacher has to edit out all the crappy answers supplied by all that "free" labor. My personal view is that, compared with a hypothetical learning machine capable of learning language like a child, the AIML targeting approach is more efficient.

CONTEXT

The keyword "that" in AIML refers to the robot’s previous utterance. Specifically, if the robot responds with a multiple sentence paragraph, the value of that is set to the last sentence in the sequence. The choice of the keyword "that" is motivated by its use in ordinary language:

R: Today is yesterday.

C: That makes no sense.

R: The answer is 3.1412926 approximately.

C: That is cool.

In AIML the syntax <that>...</that> encloses a pattern that matches the robot’s previous utterance. A common application of <that> is found in yes-no questions:

<category><pattern>YES</pattern><that>DO YOU LIKE MOVIES</that><template>What is your favorite movie?</template></category>

This category is activated when the client says YES. The robot must find out what is he saying "yes" to. If the robot asked, "Do you like movies?," this category matches, and the response, "What is your favorite movie?," continues the conversation along the same lines.

One interesting application of <that> are categories that enable the robot to respond to knock-knock jokes. The categories:

<category><pattern>KNOCK KNOCK</pattern><template>Who is there?</template></category>

<category><pattern>*</pattern><that>WHO IS THERE</that><template><person/> who?</template></category>

<category><pattern>*</pattern><that>* WHO</that><template>Ha ha very funny, <get name="name"/>.</template></category>

produce the following dialogue:

C: Knock knock.

R: Who’s there?

C: Banana.

R: Banana who?

C: Knock knock.

R: Who’s there?

C: Banana.

R: Banana who?

C: Knock knock.

R: Who’s there?

C: Orange.

R: Orange who?

C: Orange you glad I didn’t say banana.

R: Ha ha very funny, Nancy.

Internally the AIML interpreter stores the input pattern, that pattern and topic pattern along a single path, like: INPUT <that> THAT <topic> TOPIC.  When the values of <that> or <topic> are not specified, the program implicitly sets the values of the corresponding THAT or TOPIC pattern to the wildcard *.

The first part of the path to match is the input. If more than one category have the same input pattern, the program may distinguish between them depending on the value of <that>. If two or more categories have the same <pattern> and <that>, the final step is to choose the reply based on the <topic>.

This structure suggests a design rule: never use <that> unless you have written two categories with the same <pattern>, and never use <topic> unless you write two categories with the same <pattern> and <that>. Still, one of the most useful applications for <topic> is to create subject-dependent "pickup lines," like:

<topic name="CARS">

<category><pattern>*</pattern><template><random><li>What’s your favorite car?</li><li>What kind of car do you drive?</li><li>Do you get a lot of parking tickets?</li><li>My favorite car is one with a driver.</li></random></template>

Considering the vast size of the set of things people could say that are grammatically correct or semantically meaningful, the number of things people actually do say is surprisingly small. Steven Pinker,in his book How the Mind Works wrote, "Say you have ten choices for the first word to begin a sentence, ten choices for the second word (yielding 100 two-word beginnings), ten choices for the third word (yielding a thousand three-word beginnings), and so on. (Ten is in fact the approximate geometric mean of the number of word choices available at each point in assembling a grammatical and sensible sentence). A little arithmetic shows that the number of sentences of 20 words or less (not an unusual length) is about 1020."

Fortunately for chat robot programmers, Pinker’s calculations are way off. Our experiments with A.L.I.C.E. indicate that the number of choices for the "first word" is more than ten, but it is only about two thousand. Specifically, about 2000 words covers 95% of all the first words input to A.L.I.C.E.. The number of choices for the second word is only about two. To be sure, there are some first words ("I" and "You" for example) that have many possible second words, but the overall average is just under two words. The average branching factor decreases with each successive word.

We have plotted some beautiful images of the A.L.I.C.E. brain contents represented by this graph (http://alice.sunlitsurf.com/documentation/gallery/). More than just elegant pictures of the A.L.I.C.E. brain, these spiral images (see more) outline a territory of language that has been effectively "conquered" by A.L.I.C.E. and AIML.

No other theory of natural language processing can better explain or reproduce the results within our territory. You don’t need a complex theory of learning, neural nets, or cognitive models to explain how to chat within the limits of A.L.I.C.E.’s 25,000 categories. Our stimulus-response model is as good a theory as any other for these cases, and certainly the simplest. If there is any room left for "higher" natural language theories, it lies outside the map of the A.L.I.C.E. brain.

Academics are fond of concocting riddles and linguistic paradoxes that supposedly show how difficult the natural language problem is. "John saw the mountains flying over Zurich" or "Fruit flies like a banana" reveal the ambiguity of language and the limits of an A.L.I.C.E.-style approach (though not these particular examples, of course, A.L.I.C.E. already knows about them). In the years to come we will only advance the frontier further. The basic outline of the spiral graph may look much the same, for we have found all of the "big trees" from "A *" to "YOUR *". These trees may become bigger, but unless language itself changes we won’t find any more big trees (except of course in foreign languages). The work of those seeking to explain natural language in terms of something more complex than stimulus response will take place beyond our frontier, increasingly in the hinterlands occupied by only the rarest forms of language. Our territory of language already contains the highest population of sentences that people use. Expanding the borders even more we will continue to absorb the stragglers outside, until the very last human critic cannot think of one sentence to "fool" A.L.I.C.E..

 

*********************http://www.pandorabots.com/pandora/pics/wallaceaimltutorial.html -------1a

Alicebot Technology History

This is a summary of all of the major development streams of the Alicebot technology, in chronological order. You can read some interesting essays about how A.L.I.C.E. came to be here.

Program A

The first edition of A.L.I.C.E. was implemented in 1995 using SETL, a widely unknown language based on set theory and mathematical logic. Although the original A.L.I.C.E. was available as free software (often misnamed "open source"), it attracted few contributors until migrating to the platform-independent Java language in 1998. The first implementation of A.L.I.C.E. and AIML in Java was codenamed "Program A".

[Visit the SETL home page at http://cs.nyu.edu/~bacon.]

Program B

Launched in 1999, Program B was a breakthrough in A.L.I.C.E. free software development. More than 300 developers contributed to A.L.I.C.E. Program B. AIML transitioned to a fully XML-compliant grammar, opening up a whole class of editors and tools for AIML development. A.L.I.C.E. Program B won the Loebner Prize, an annual Turing Test, in January 2000. Program B was the first widely adopted free AIML software.

Program C

Jacco Bikker created the first C/C++ implementation of AIML in 2000. This was followed by a number of development threads in C/C++ that brought the Alicebot engine to CGI-scripts, IRC (Anthony Taylor),WxWindows (Philippe Raxhon), AOL Instant Messenger (Vlad Zbarskiy), and COM (Conan Callen). This collection of code has come to be known as "Program C", the C/C++ implementations of the Alicebot engine and AIML.

Program D

Program B Java edition was based on pre-Java 2 technology. Although the program ran on many different platforms, it did not take advantage of newer Java features such as Swing and Collections. Jon Baer recoded Program B with Java 2 technology, and added many new features. This giant leap in the interface and the core, plus the fact that Jon named his bot "DANY", justified granting the next code letter "D" to his latest Alicebot Java edition. Beginning in November 2000, Program D is the only the Java edition of the Alicebot engine actively supported.

*************************************http://www.alicebot.org/history/technology.html --------1b

A.L.I.C.E. (Artificial Linguistic Internet Computer Entity), also referred to as Alicebot, or simply Alice, is a natural language processing chatterbot—a program that engages in a conversation with a human by applying some heuristical pattern matching rules to the human's input, and in its online form it also relies on a hidden third person. It was inspired by Joseph Weizenbaum's classical ELIZA program. It is one of the strongest programs of its type and has won the Loebner Prize, awarded to accomplished humanoid, talking robots, three times (in 2000, 2001 and 2004). However, the program is unable to pass the Turing test, as even the casual user will often expose its mechanistic aspects in short conversations.

Development

Richard Wallace began development of the program in 1995, while at Lehigh University. The name of the

bot was chosen because the computer that ran the first version of the software was called Alice.

The program was rewritten in Java beginning in 1998. The current incarnation of the Java implementation

is Program D. The program uses an XML Schema called AIML (Artificial Intelligence Markup Language)

for specifying the heuristic conversation rules.

Subsequent to Richard Wallace's 2001 publication of an AIML specification, numerous other developers

have taken up where Wallace left off, implementing free and open sourceAIML interpreters in a variety of

programming languages, publishing AIML sets in various human languages, and continuing the spread of

the technology as a free/open source venture.

****************http://en.wikipedia.org/wiki/Artificial_Linguistic_Internet_Computer_Entity --------2a

ELIZA is a computer program and an early example of primitive natural language processing. ELIZA

operated by processing users' responses to scripts, the most famous of which was DOCTOR, a

simulation of a Rogerian psychotherapist. Using almost no information about human thought or emotion,

DOCTOR sometimes provided a startlingly human-like interaction. ELIZA was written at MIT by Joseph

Weizenbaum between 1964 and 1966.

When the "patient" exceeded the very small knowledge base, DOCTOR might provide a generic

response, for example, responding to "My head hurts" with "Why do you say your head hurts?" The

response to "My mother hates me" would be "Who else in your family hates you?" ELIZA was

implemented using simple pattern matching techniques, but was taken seriously by several of its users,

even after Weizenbaum explained to them how it worked. It was one of the firstchatterbots in existence.

Overview

Weizenbaum said that ELIZA, running the DOCTOR script, provided a "parody" of "the responses of a

nondirectional psychotherapist in an initial psychiatric interview."[1] He chose the context of psychotherapy

to "sidestep the problem of giving the program a data base of real-world knowledge",[2] the therapeutic

situation being one of the few real human situations in which a human being can reply to a statement with

a question that indicates very little specific knowledge of the topic under discussion. For example, it is a

context in which the question "Who is your favorite composer?" can be answered acceptably with

responses such as "What about your own favorite composer?" or "Does that question interest you?"

ELIZA was named after Eliza Doolittle, a working-class character in George Bernard

Shaw's play Pygmalion, who is taught to speak with an upper-class accent.[3]

First implemented in Weizenbaum's own SLIP list-processing language, ELIZA worked by

simple parsing and substitution of key words into canned phrases. Depending upon the initial entries by

the user, the illusion of a human writer could be instantly dispelled, or could continue through several

interchanges. It was sometimes so convincing that there are many anecdotes about people becoming

very emotionally caught up in dealing with DOCTOR for several minutes until the machine's true lack of

understanding became apparent.[citation needed]

In 1966, interactive computing (via a teletype) was new. It was 15 years before the personal computer

became familiar to the general public, and three decades before most people encountered attempts

at natural language processing in Internet services like Ask.com or PC help systems such as Microsoft

Office Clippy. Although those programs included years of research and work, ELIZA remains a milestone

simply because it was the first time a programmer had attempted such a human-machine interaction with

the goal of creating the illusion (however brief) of human-human interaction.

In the 1976 article "Computer Power and Human Reason," an excerpt of which is included in The New

Media Reader edited by Noah Wardrip-Fruin and Nick Montfort, Weizenbaum notes how quickly and

deeply people became emotionally involved with the computer program, taking offence when he asked to

view the transcripts, saying it was an invasion of their privacy, even asking him to leave the room while

they were working with the DOCTOR script.

Influence on games

ELIZA had an impact on a number of early computer games by demonstrating additional kinds

of interface designs. Don Daglow wrote an enhanced version of the program calledEcala on a PDP-

10 mainframe computer at Pomona College in 1973 before writing what was possibly the second or third

computer role-playing game, Dungeon (1975) (The first was probably "dnd", written on and for the PLATO

system in 1974, and the second may have been Moria, written in 1975). It is likely that ELIZA was also on

the system where Will Crowther created Colossal Cave (Adventure), the 1975 game that spawned

the interactive fiction genre. Both these games appeared some nine years after the original ELIZA.

The 2011 action-RPG Deus Ex: Human Revolution includes among its cast a news media personality

named "Eliza Cassan", who is shown interviewing other prominent characters at various points in the

game's plot. After the main character, Adam Jensen, hunts her down, she is revealed to be a highly

advanced AI.

Response and legacy

Lay responses to ELIZA were disturbing to Weizenbaum and motivated him to write his book Computer

Power and Human Reason: From Judgment to Calculation, in which he explains the limits of computers,

as he wants to make clear in people's minds his opinion that the anthropomorphic views of computers are

just a reduction of the human being and any life form for that matter. In the independent documentary

film Plug & Pray (2010) Weizenbaum said that only people who misunderstood ELIZA called it a

sensation.[4]

The Israeli poet David Avidan, who was fascinated with future technologies and their relation to art,

desired to explore the use of computers for writing literature. He conducted several conversations with

an APL implementation of ELIZA and published them - in English, and in his own translation to Hebrew -

under the title My Electronic Psychiatrist - Eight Authentic Talks with a Computer. In the foreword he

presented it as a form of constrained writing.[5]

There are many programs based on ELIZA in different programming languages. For example, in 1980, a

company called "Don't Ask Software", founded by Randy Simon, created a version called "Abuse" for

the Apple II, Atari, and Commodore PCs, which verbally abused the user based on the user's input.[6] Other versions adapted ELIZA around a religious theme, such as ones featuring Jesus (both serious

and comedic) and another Apple II variant called I Am Buddha. The 1980 game The

Prisoner incorporated ELIZA-style interaction within its gameplay. George Lucas and Walter Murch

incorporated an Eliza-like dialogue interface in their screenplay for the feature film THX-1138 in 1969.

Inhabitants of the underground future world of THX would retreat to "confession booths" when stressed,

and initiate a one-sided Eliza-formula conversation with a Jesus-faced computer who claimed to be

"Omm". In 1988 the British artist and friend of Weizenbaum Brian Reffin Smith created and showed at the

exhibition 'Salamandre', in the Musée du Berry, Bourges, France, two art-oriented ELIZA-style programs

written in BASIC, one called 'Critic' and the other 'Artist', running on two separate Amiga 1000 computers.

The visitor was supposed to help them converse by typing in to 'Artist' what 'Critic' said, and vice versa.

The secret was that the two programs were identical.

Implementations

Using Java, and based very closely on Weizenbaum's published description of the

program: http://www.chayden.net/eliza/Eliza.html

Using Z80 assembly language on the TI-83 Plus: ticalc.org

Trans-Tex Software has released shareware versions for Classic Mac OS and Mac OS X: Trans-Tex

Software

doctor.el (circa 1985) in Emacs lisp: http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/areas/

classics/eliza/emacs/0.html.

Source code in Tcl: http://wiki.tcl.tk/9235

Source code in BASIC: http://www.atariarchives.org/bigcomputergames/showpage.php?page=22

Used in AGT: Automatic Goblin Therapist (World of

Warcraft addon) http://www.wowinterface.com/downloads/fileinfo.php?id=9780#info

Written in TDBS for the Kakadu Konnection BBS in Darwin Australia and widely distributed to

other TBBS Bulletin Boards in 1989.

Source code in Guile Scheme: https://github.com/apgwoz/chatter

----------------------------------------------------------------------------------http://en.wikipedia.org/wiki/ELIZA ------3a

Jabberwacky is a chatterbot created by British programmer Rollo Carpenter. Its stated aim is to "simulate natural human chat in an interesting, entertaining and humorous manner". It is an early attempt at creating an artificial intelligence through human interaction.

Purpose

The stated purpose of the project is to create an artificial intelligence that is capable of passing the Turing

Test. It is designed to mimic human interaction and to carry out conversations with users. It is not

designed to carry out any other functions.

Unlike more traditional AI programs, the learning technology is intended as a form of entertainment rather

than being used for computer support systems or corporate representation. Recent developments do

allow a more scripted, controlled approach to sit atop the general conversational AI, aiming to bring

together the best of both approaches, and usage in the fields of sales and marketing is underway.

The ultimate intention is that the program move from a text based system to be wholly voice operated—

learning directly from sound and other sensory inputs. Its creator believes that it can be incorporated into

objects around the home such as robots or talking pets, intending both to be useful and entertaining,

keeping people company.

Cleverbot

Cleverbot is an alternative bot to Jabberwacky, also created by Rollo Carpenter.

Timeline

1981 – The first incarnation of this project is created as a program hard-coded on a Sinclair ZX81.

1988 – Learning AI project founded as 'Thoughts'

1997 – Launched on the Internet as 'Jabberwacky'

October 2003 – Jabberwacky is awarded third place in the Loebner Prize. It was beaten by Juergen

Pirner's Jabberwock (A German based chat program)

September 2004 – Jabberwacky is awarded second place in the Loebner Prize. It was beaten by

computer chat program A.L.I.C.E

September 2005 – George, a character within Jabberwacky, wins the Loebner Prize

September 2006 – Joan, another Jabberwacky character, wins the Loebner Prize

October 2008 – A new variant of Jabberwacky is launched, more fuzzy and with deeper context,

under the name Cleverbot

-----------------------------------------------------------------------http://en.wikipedia.org/wiki/Jabberwacky -------4a

KAR Intelligent Computer© (Katia Automatique Robot Intelligent Computer©) is a software with 2 main functions: 1. It enables companies to drastically reduce their energy bill and carbon footprint of their information technology infrastructure (- 48 %). 2. It is a human machine interface based on artificial intelligence for disability based on head movements, magnifying glass, text-to-speech, home automation, automatical execution, voice recognition… 

It can also answer more than 450 000 questions in French, English, German and Spanish! It has more than 630 functions (webbrowser, writer, burn cds, drivers update...) All these solutions are combined into a single interface.

We can sort all these functions in 4 categories :

- Family- Education- Professionnal- Disability

--------------------------------------http://www.chatbots.org/chatbot/kar_intelligent_computer1/------6a

PARRY was an early example of a chatterbot, implemented in 1972 by psychiatrist Kenneth Colby.

History

PARRY was written in 1972 by psychiatrist Kenneth Colby, then at Stanford University.[1] While ELIZA

was a tongue-in-cheek simulation of a Rogerian therapist, PARRY attempted to simulate

a paranoid schizophrenic.[1] The program implemented a crude model of the behavior of a paranoid

schizophrenic based on concepts, conceptualizations, and beliefs (judgements about conceptualizations:

accept, reject, neutral). It also embodied a conversational strategy, and as such was a much more serious

and advanced program than ELIZA. It was described as "ELIZA with attitude".[2]

PARRY was tested in the early 1970s using a variation of the Turing Test. A group of experienced

psychiatrists analysed a combination of real patients and computers running PARRY through teleprinters.

Another group of 33 psychiatrists were shown transcripts of the conversations. The two groups were then

asked to identify which of the "patients" were human and which were computer programs.[3] The

psychiatrists were able to make the correct identification only 48 percent of the time — a figure consistent

with random guessing.[4]

PARRY and ELIZA (also known as "the Doctor"[5][6]) "met" several times.[1]RFC 439[5] The most famous of

these exchanges occurred at the ICCC 1972, where PARRY and ELIZA were hooked up

over ARPANET and "talked" to each other.[5]

--------------------------------------------------------------------------------http://en.wikipedia.org/wiki/PARRY -------7a

SHRDLU was an early natural language understanding computer program, developed by Terry

Winograd at MIT in 1968-1970. In it, the user carries on a conversation with the computer, moving

objects, naming collections and querying the state of a simplified "blocks world", essentially a virtual box

filled with different blocks.

SHRDLU was written in the Micro Planner and Lisp programming language on the DEC PDP-6 computer

and a DEC graphicsterminal. Later additions were made at the computer graphics labs at the University of

Utah, adding a full 3D rendering of SHRDLU's "world".

The name SHRDLU was derived from ETAOIN SHRDLU, the arrangement of the alpha keys on

a Linotype machine, arranged in descending order of usage frequency in English.

Functionality

SHRDLU was primarily a language parser that allowed user interaction using English terms. The user

instructed SHRDLU to move various objects around in a the "blocks world" containing various basic

objects: blocks, cones, balls, etc. What made SHRDLU unique was the combination of four simple ideas

that added up to make the simulation of "understanding" far more convincing.

One was that SHRDLU's world was so simple that the entire set of objects and locations could be

described by including as few as perhaps 50 words: nouns like "block" and "cone", verbs like "place on"

and "move to", and adjectives like "big" and "blue". The possible combinations of these basic language

building blocks were quite simple, and the program was fairly adept at figuring out what the user meant.

SHRDLU also included a basic memory to supply context. One could ask SHRDLU to "put the green cone

on the red block" and then "take the cone off"; "the cone" would be taken to mean the green cone one

had just talked about. SHRDLU could search back further through the interactions to find the proper

context in most cases when additional adjectives were supplied. One could also ask questions about the

history, for instance one could ask "did you pick up anything before the cone?"

A side effect of this memory, and the original rules SHRDLU was supplied with, is that the program could

answer questions about what was possible in the world and what was not. For instance, SHRDLU would

deduce that blocks could be stacked by looking for examples, but would realize that triangles couldn't be

stacked, after having tried it. The "world" contained basic physics to make blocks fall over, independent of

the language parser.

Finally, SHRDLU could also remember names given to objects, or arrangements of them. For instance

one could say "a steeple is a small triangle on top of a tall rectangle"; SHRDLU could then answer

questions about steeples in the blocks world, and build new ones.

------------------------------------------------------------------------------http://en.wikipedia.org/wiki/SHRDLU -------8a

START, the world's first Web-based question answering system, has been on-line and continuously operating since December, 1993. It has been developed by Boris Katz and his associates of the InfoLab Group at the MIT Computer Science and Artificial Intelligence Laboratory. Unlike information retrieval systems (e.g., search engines), START aims to supply users with "just the right information," instead of merely providing a list of hits. Currently, the system can answer millions of English questions about places (e.g., cities, countries, lakes, coordinates, weather, maps, demographics, political and economic systems), movies (e.g., titles, actors, directors), people (e.g., birth dates, biographies), dictionary definitions, and much, much more. Below is a list of some of the things START knows about, with example questions. You can type your question above or select from the following examples.

---------------------------------------------------------------------------------------------http://start.csail.mit.edu/ -------9a

SYSTRAN, founded by Dr. Peter Toma in 1968,[1] is one of the oldest machine translation companies.

SYSTRAN has done extensive work for the United States Department of Defense and the European

Commission.

SYSTRAN provides the technology for Yahoo! Babel Fish among others. It was used by

Google's language tools until circa 2007.[2] SYSTRAN is used by the Dashboard Translation widget

in Mac OS X.

Commercial versions of SYSTRAN can run on Microsoft Windows (including Windows Mobile), Linux,

and Solaris. Historically, SYSTRAN systems used Rule-based machine translation (RbMT) technology.

With the release of SYSTRAN Server 7 in 2010, SYSTRAN implemented a hybrid rule-based/Statistical

machine translation (SMT) technology which was the first of its kind in the marketplace.[3]

As of 2008, the company had 59 employees of whom 26 are computational experts and 15 computational

linguists.[4] The number of employees decreased from 70 in 2006 to 65 in 2007.[4]

History

With its origin in the Georgetown machine translation effort, SYSTRAN was one of the few machine

translation systems to survive the major decrease of funding after the ALPAC Report of the mid-1960s.

The company was established in La Jolla in California to work on translation of Russian to English text for

the United States Air Force during the Cold War. Large numbers of Russian scientific and technical

documents were translated using SYSTRAN under the auspices of the USAF Foreign Technology

Division (later the National Air and Space Intelligence Center) at Wright-Patterson Air Force Base, Ohio.

The quality of the translations, although only approximate, was usually adequate for understanding

content.

The company was sold in 1986 to the Gachot family, based in Paris, and is now traded publicly on the

French stock exchange. Its company headquarters is in Paris, while its US headquarters is in La Jolla,

California.

During the dot-com boom, the international language industry started a new era, and SYSTRAN entered

into agreements with a number of translation integrators, the most successful of these being WorldLingo.[citation needed]

[edit]Business situation

Most of SYSTRAN's revenue comes from a few customers. 57.1% comes from the 10 main customers

and the three largest customers account for 10.9%, 8.9%, and 8.9% of its revenues, respectively.[4] Revenues had been declining in the early 2000s: 10.2 million euros in 2004, 10.1 million euros in 2005,

9.3 million euros in 2006, 8.8 million euros in 2007, and 7.6 million euros in 2008,[4] before seeing a

rebound in 2009 with 8.6 million euros.[5]

---------------------------------------------------------------------http://en.wikipedia.org/wiki/SYSTRAN-----------10a

Kreator, an optimization problem solving software by Intelligentics that uses A.I. techniques.

OpenAIR, a routing and communication protocol based on a publish-subscribe architecture, built

especially for A.I. research.