Artificial Intelligence

 

Primary goal: To attain immortality by coding up an AI with all my thoughts, beliefs and values to be me after I die.

Secondary goal: To set myself up as world emporer using an army of robots, colonise space and have an awesome DVD collection.

Tertiary goal: To aid humanity... using an army of robots. Or destroy it. It depends on how I feel at the time. [Don't worry; I'm joking! I wouldn't let my feelings get in the way of destroying the world.]

 

Plan of Attack

1. Make a fish.
2. Make a smart fish.
3. Make a dog.
4. Make many dogs.
5. Make a robot army.
6. Conquer the world.

 

Step one: Make a fish. Make a very simple 2-D world with replenishing food. The fish needs to move and eat to live. The AI (a fish) will have basic sensors and a way of moving. This is a simple but first good step. The AI learns planning, passage of time, motives, controlling stuff (in this case, its tail and mouth), remembering stuff.

 

 

A fish would have:

• A 2-D vector-based world with food. More stuff can be added later.
• An eye; this would be 7 or so input sensors that detect the colour of whatever that sensor is pointed at. There should be a fog so that distant objects are less clear.
• A tail, which would have two outputs: speed and direction. Direction is relative to the direction of the fish. Speed affects hunger.
• A stomach: an input sensor that represents how much food is left.
• A mouth, which is just the fish's body. When the fish touches food, it gets it and the food is removed from the world.
• A sense of time, which would just be an input giving the number of seconds / milliseconds since 1970. This is just because it's easy to do.
• A random number generator as an input.

 

The fish is rewarded when it eats food. If the fish dies of hunger, the world is reset, the fish is punished and given a new body.

 

The expected behaviour is simple: the fish would swim randomly until it detects food, and then swims for that food. Repeat until dead.

 

Make a nice GUI or a screensaver :-).

 

Step two: Make a smart fish but still in the same simple 2-D world. The fish will need to be able to make higher level abstractions of the world. It should be able, in theory, to construct any concept that a human can. Enrich its world a bit with objects, goals and maybe a need to make and use higher-level concepts. Perhaps explore the idea of giving the fish commands and hints so that it understands interaction and language.

 

Perhaps add competitors, or puzzles.

 

Step three: Enhance the world. Make it 3-D and introduce physics. Give the fish brain a dog's body with legs, mouth (i.e. grabber) and more sensors. Perhaps experiment with other bodies, such as those with wheels and arms.

 

Step four: Make many dogs. The AI needs to learn to interact with others of its own kind to achieve goals, perhaps even developing its own language.

 

Step five: Actually build a physical body. Get it to wash dishes, fetch newspapers, do my housework.

 

Step six: Sell them. Become insanely rich. Enslave humanity and then eat cake and watch DVDs.

 

Simple Read-World Uses

 

An AI would be easiest to make if it could be self-funded.

 

Ideas for selling an AI:

• Traffic optimisation systems (watch approaching cars, pre-empt traffic lights).
• Other optimisation systems, e.g. power stations, production...
• Self-driving anythings - cars, trains, automated flying vehicles, mini automated courier bots, ...
• Spam filters.
• Programming aids, code optimisation.
• Driving tracters (e.g. ploughing), planting, harvesting.
• Factory work - production-line stuff.
• Defence forces, e.g. automated recon.
• Cleaning (e.g. Roomba).

 

An AI would would have a niche in:

• Jobs that are too dangerous for humans such as working in radioactive/hot/cold/toxic/dangerous environments.
  • Clean-up operations after toxic/radioactive accidents.
  • Construction in extreme environments such as Antarctica.
  • Bomb disposal, war, managing crazed gunmen.
• Jobs that are inaccessable to humans, e.g. small spaces, high places, outer space, deep sea.
  • Volcanic monitoring.
  • Mountain/bush/extreme environment search and rescue.
  • Deep sea mapping and exploration.
  • Sewage/drainage pipe maintanence.
  • Anything in space, Moon, Mars, etc, such as research, mining, construction.
• Jobs that are too boring for humans
  • Surveillance (especially in unpleasant environments) from the ground, in the air, under the sea.
  • Searching surveillance footage (can be hours and hours).
• Jobs that are too complex for humans, e.g. data mining, dynamic optimisation of complex systems.
  • Traffic optimisation - traffic light management?
  • Power station optimisation, optimisation of manufactoring or supply chain thingies.
  • Finding somebody in a city (CCTV footage, car numberplates, etc).
  • Categorisation: astronomy, melanoma spots, ...?
  • Sharemarket analysis, economic analysis.

 

AIs would not be suitable for:

• Jobs working with people: councillers, nurses/doctors, managers, politicians etc, although an AI might be used by them.
• Artistic jobs: music, art, architecture, advertising, fashion, etc.

 

Get a list of careers and see how many could be aided by using an AI.

 

Implementing AI

 

Like a brain

 

An AI would have a similar structure to a human brain:

• visual, auditory, sensory memory (i.e. 1ms - 1s duration before knowledge is GCed), like device driver buffers.
• working memory...? 7 items, kind of like a computer's bank of registers.
• short-term memory (1s - 100s before knowledge is GCed), like a computer's main RAM.
• long-term memory, like a computer's hard disk.
• other parts of brain - hippocampus, cerebellum, lobes etc... look up these on wikipedia.
• sleep - i.e. long-term GC, combining recent experiences to search for new ideas.

http://en.wikipedia.org/wiki/List_of_regions_in_the_human_brain

 

 

Statements and thoughts

 

• "thoughts" are encoded as logical statements.
• "Thinking" involves using an evolutionary algorithm to separate useful thoughts from useless thoughts and create conclusions from thoughts.

 

Multi-valued logic could be used. Each "thought" is a statement that has a certain amount of truth associated with it.

 

The level of truth is the amount of truth that can be applied to a statement. For example, referring to a chair, the statement "this is a chair" is likely to be quite near 1.0, whereas while referring to a tree stump, the level of truth would be lower. This concept of level of truth may or may not lead to a valid logical system; usually examples refer to a particular object's classification rather than to complex logical expressions. In such a case, the level of truth refers to the likelihood of something belonging in a particular set.

 

The certainty of truth of a particular statement is the error margin present. If a statement has been made with no accepted facts to base it on, the certainty would be zero. If a statement can be verified using accepted facts, then the certainty of truth would be higher.

 

The level of truth and certainty of truth can form two dimensions and can be plotted as a line on a graph having level and certainty of truth on its axis.

 

Alternatively, probabilities could be used, with confidence intervals (e.g. P(x) = 0.7 +/- 0.2). A more complex way of representing this is P(x) has a mean of 0.7 with the standard deviation equal to 0.1. You could also reason about P(P(x)).

 

The actual probability of a statements could be anywhere from 0.0 through to 1.0, and the probabilities the AI would deal with would be "subjective" probabilities that attempt to model those actual/objective probabilities as accurately as possible. For this reason, there must always be a possibility that the modelled probabilities are wrong and need updating.

 

The AI forms a database of statements. Each statement has metadata about it such as it's level of truth, certainty etc. These form the beliefs of the AI. Other metadata associated with each statement will include links to other relevant statements (for searching), how that statement was derived and when.

 

Metadata about a statement could include:

• What the source of that statement is (deduction from a list of other statements, direct observation, heresay from a person at a particular time).
• When that statement was derived.
• The truth value of that statement (i.e. "This is very chair-like", "This is only a bit chair-like"). I.e. using fuzzy logic.
• The certainty of that truth value (i.e. "I don't know", "I know for sure that...").
• The usefulness and certainty of usefulness of that statement.
• Links to other statements that would be good for considering next to solve a particular problem (i.e. adding search heuristics to statements).

 

Metadata about a statement would be stored as statements about statements. 

 

Statements should be thought of as a connected graph of some sort (e.g. mind map, parse tree, ...) rather than as a string of letters on the screen. The string of letters is only a linear encoding of that connected graph and the AI should not be limited by what can be encoded linearly as text.

 

Types of statements

Currently, forms of logic are not powerfull to encode any human thought.

 

Lojban is an artificial spoken language that can, supposidibly, be used to express any human thought. I define a language as "gulik-complete" if that language can encode and arithmetically manipulate any human thought. Lojban would be a good starting point for designed a format for storing these statements internally in the computer.

 

Problems to solve include:

• How to think about events.
• How to name objects.
• How to name abstract ideas.
• How to avoid naming collisions - use contexts?
• How to think abstractly about statements, statements about statements, statements about thinking about statements, etc.
• How to store properties of concepts, properties of properties of concepts, properties of thinking about properties, etc.
• more?

 

One idea is to have statements be applied to other statements to build up more detailed concepts, such as described here: Improving-Lojban

 

Certainties of truth

 

Traditionally, truth has been represented using two values: true and false. These two values don't represent truth as we humans use it.

 

For example, if I were to ask "Is this a ball", some answers would be:

 

"This is a ball" (true / false)

"This is a bit ball-like" (The ball-ness of the current object could be represented using 0.0 (not ball-like) through 1.0 (completely ball-like)).

"I don't know if this is ball-like" (A low certainty of the truth value).

"I can only barely see the object; it is vaguely round" (Inaccurate or incomplete sensory input makes for a low ball-ness of the object with a low certainty).

 

There are also many other possible answers taking time, conditions etc into account.

 

So far I have thought of the following ways of representing this uncertainty:

 

• Truth could be represented using two values: truth value, and certainty of that truth value.
• Truth could be represented as probabilities and probabilities of those probabilities ( i.e. p(p(x)) ).
• Truth could be represented as a probability and an error margin of that probability (i.e. p(x)= 0.5 +/- 0.1 ).

 

My thoughts:

 

Truth values could map directly to sensors. For example, an AI could note that the pixel at (x, y) has a value of 0.7 redness at time t. This would then become a charactoristic of the current environment which the AI would use to classify and make further inferences... somehow.

 

Probabilities are predicitions of an eventual distribution of samples. For example, for a dice roll, a probability is eventually realised when a number of experiments has taken place and the actual results are known - 1/6 of the results (more or less) were in fact when the die roll had a particular value. A probability is really a model to predict outcomes.

 

Say for example that experiment A is: "roll a die n times and count up the number of times the die results in 1.".

Say also that experiment B is "repeat experiment A many times and draw a distribution graph of the resulting probabilities of getting 1 as a result".

That distribution graph can then be analysed; it would have an average and a standard deviation.

 

If n is small, the standard deviation would be large. If n is large, the standard deviation is smaller. This standard deviation is a measure of certainty; as n increases, the standard deviation get smaller meaning that the results become better known.

 

The interesting case is when n=0; in this case, the standard deviation would be... infinity? (not sure; it may be undefined or something), and I hypothesize that the distribution graph would not have a peak anywhere. In this case, there is zero information so that no outcome can be predicted with any more bias than any other outcome.

 

For an AI, I need to research some way of representing this information in a concise format, such as two numbers (average probability, standard deviation), and the remake the arithmetic rules for probabilities to also use this certainty. When this is done, an AI can represent truth with certainty. This allows the AI to be certain or not about a particular piece of information.

 

Probabilities

 

Normally, a probability is represented by a single number between 0 and 1. I propose that it can be represented by two numbers: the expected value of that probability, and the standard deviation of that expected value.

 

If we roll a die, we intuitively know that the probability of getting the "1" face of the die is 1/6. Say x = "the result is the face 1", so p(x)=1/6. To calculate this, we roll the die n times and get n_1 occurances of the "1" face. The probability is n_1/n, which for large values of n will approach 1/6. However, for small values of n, the calculated probability ("cp" for this paragraph) can vary quite a lot. Mapped on a graph for a small particular value of n (e.g. 5) and with a large number of repeated experiments of this sample with n=5, the graph will represent a normal curve with a peak at p(n) (i.e. 1/6) and standard deviation of (I think) sqrt( (p(x)*p(not(x))) / n ). If there were a limited number of die rolls possible (which is not the case, but could be for other examples), we need to multiply this again by sqrt( (N-n) / (N-1) ), but we ignore this for simplicity for now.

 

As n increases, the standard deviation gets smaller. In other words, we get more certain about the result.

 

(okay, I haven't thought this through fully yet; the examples I tried don't add up.)

Fast probability calculation using fractions

 

Deduction

 

Examples of deduction include:

• If it walks, talks and looks like a duck, then it's a duck. Or a bird.
• If I do this, that happens (i.e. discovering cause/effect).
• If this happens after that, then this probably causes that.
• If I think in this manner or search down this tree of knowledge, I'm more likely to find an answer.

 

These statements all resemble horn clauses. Classification uses horn clauses.

 

Classification

Deduction can be made easier by using classfication. The process of deduction involves taking a bunch of events ("causes") and categorising them so that they have properties that cooincide with other properties from another bunch of events ("effects"). Events would be assumed from observations, again using classification.

 

The AI will need to do classification. Many statements would be of a the form a(x)^b(x)^c(x)->d(x), where a, b, c and d are properties of x. An example of this statement is "if it walks like a duck, talks like a duck and looks like a duck, then it's a duck". The classification algorithm looks for patterns and similarities between experiences to be able to re-use knowledge and apply aspects of one experience to another. TODO: how is this classification algorithm going to work?

 

Say for example that the AI sees a thingie. A trainer standing next to the AI points to it and says "duck". That thingie has webbed feet, a bill and wings. The AI sees another thingie. This thingie has other properties, and the trainer says nothing. At some stage, the AI must learn that things with webbed feat, a bill and wings are ducks ( has_webbed_feet(x) ^ has_bill(x) ^ has_wings(x) -> duck(x) ).

 

This would also apply to actions: the AI's thought process would be "if I do this, that happens", storing such statements for future use. It would also apply to meta-data and thought processes: "if I think in this way, I get better results".

 

It would probably use probabilities. p(a(x) ^ b(x) ^ c(x) -> d(x)) = 0.4 probably means that something with characteristics a, b and c has a probability of 0.4 of having property d. (TODO: learn more statistics)

 

An algorithm needs to be made such that when particular properties of something appear, the AI can efficiently search for possible classifications or inferences it could make. One way is to have a list of commonly searched statements attached to each statement as metadata, which can then be searched for possible inferences. Another way is to have a current context, which would limit the search space.

 

Using deductions

Once deductions have been made, they can be used.

 

The amount of certainty an AI has in a particular deduction would be carried through to any direct conclusions it makes using that deductions. If the AI is unsure about a particular deduction, it would also be unsure about the conclusions it makes. (The uncertainty here is the standard deviation of the probability of those statements).

 

Deductions would be used by a Prolog-like search algorithm. For this, Prolog typically uses a backtracking and unification algorithm which I consider to be a searching algorithm because it is "searching" for an answer. Improvements to the algorithm would include preventing the algorithm from looping indefinitely, putting statements in contexts to limit the search space a bit, and adding meta-data to statements to record previous search paths for re-use as short-cuts.

 

The goal of this search algorithm would be to directly achieve the AI's current goal. Alongside this, the AI would concurrently be making observations and trying to make useful deductions and theories to feed into the search algorithm.

 

Higher-level thought

Classification can also be applied to abstract concepts to aid in higher-level learning. The logic must be powerful enough to reason about itself. This could be done by adding more rules to the logical system to refer to particular clauses, or to parts of clauses, or the truth values of clauses, or the properties/meta-info of clauses and statements. For example:

 

"This sentence is false" becomes "14: not(clause(14))" where "14" is the clause ID.

"Ducks are red and the second part of this sentence will be false" -> "15: and%16(forall(x, implies(duck(x), red(x)), false(clause(16))" (the "%16" marks the "and(...)" sub-clause)

"This sentence is now true but will later be false" becomes "17: and( implies(equals(time(), "2pm"), clause(17)), implies(greaterthan(time(), "2pm"), not (clause(17))))"

"I don't know if ducks are red" becomes "18: certain( forall(x, implies(duck(x), red(x)), 0.5, 0.0)" (0.5 is the truth value, 0.0 is the certainty)

    or "18: forall(x, implies(duck(x), red(x)))" and "19: certain(clause(18), ...etc."

 

An AI would be able to make it's own higher-level thoughts using some genetic algorithm to recombine them. I don't know what heuristic should be used; perhaps each statement should have a usefulness value that gets incremented with each time the statement is used to generate a useful result elsewhere?

 

The AI must be able to reason about it's own thinking processes, thoughts and thought patterns. It should, for example, be able to choose to think about a particular thing and know how long it has been doing so.

 

Usefulness

 

An evolutionary algorithm being applied to logical statements must have some heuristic for determining the usefulness of a statement. Each statement would have metadata about it's usefulness. Usefulness would again have level of usefulness and certainty of that usefulness - i.e. how useful a given statement is, and how certain I am of that "usefulness value" I've assigned to that statement. One method of determining usefulness to increase the usefulness of a statement every time it is successfully used to attain an end goal (and thus a reward). Useless statements are pruned and forgotten as memory is filled. New statements are also made and evaluated (with usefulness set to 0.5?).

 

The AI should be persistent. It's memory is retained indefinitely (i.e. statements are stored in a big database) and it applies knowledge learned from past experience to its current situation.

 

Actions

 

Doing things: evaluating certain special statements will cause the AI to perform that action. The AI should evolve the level of usefulness on statements to make the evaluation algorithm only evaluate these statements when the AI has chosen to do so. Initially, the AI will look like a spasming duck, but will eventually evolve rules that give it some volition and control over what it does.

 

It would be good if the AI could also be manually coded in a way that also made it a logic-based programming language.

 

Training tasks for an AI

 

• Sort this list.
• Write code to sort this list.
• Write an AI that can sort this list better than you can.
• Find this element in a list.
• Play naughts and crosses against me or another instance of yourself.
• Play chess with me or another instance of yourself.
• Goals in a 2-D playfield. The AI has several things it can do: move N / S / E / W, pick up something, drop something. Tasks include picking up a ball and putting it in a box, stacking things, making a line of objects.
• Follow my English instructions. I provide English instructions telling the AI what to do, the AI can work out what these instructions mean to achieve its current goal.
• Talk to me: repeat what I say (teaches passage of time).

 

Drawing conclusions

 

The AI needs to be able to draw conclusions. Examples include:

• This technique that I've created (...) achieves this goal (...) with effectivity n.
• Generalisation / induction: Every object I've seen with property y had property x, so every object with property y has property x (with probability n).
• Standard logical techniques: direct proof, proof by contradiction, etc.
• Creation of new concepts. Each concept is a logical statement. Statements contain objects (which can be other concepts) and properties of objects. This means that new objects and properties can also be created.
• Unification, learning about persistence of objects. If object a and object b are very similar, then maybe they're the same object.
• Temporal reasoning. Properties of objects may have different values for different values of time.

 

Example: sort this list: [ a d e b c ].

Objects: ListItem, List, Movement

Properties:

    position(ListItem, position),

    timeOf(Movement, time),

    before(Movement, Movement, bool),

    size(List, size),

    sorted(List, bool),

    greaterThan(ListItem, ListItem, bool),

 

Actions:

    swapPositions(Item, Item, ..time?..).

 

The AI would start by making random theories:

goodMove( move(before(a, d, false), ...), 0.5).

goodMove( move(size(l, N),sorted(...), 0.5).

...etc...

 

These theories would be manipulated using an evolutionary algorithm. The swapPositions() action would be randomly evaluated. When swapPostitions() is evaluated, the List is changed. When a reward is gained (when the "orderedness" of the list increases), it reenforces the steps of evaluation that it made to achieve that state.

 

The AI would also add its own predicates and theories. In this way, it can define new concepts for itself.

 

Random thoughts.

 

The AI could iterate over the scientific method - make hypothesis, gather evidence, draw conclusions. It would use statistics to determine probabilities of hypothesii being true.

 

I need to master Prolog.

 

What is needed is a "Turing Complete" sort of system for knowledge representation. A knowledge representation system is "Gulik complete" if it can represent anything that humans could express, and be able to be worked with (by rewriting terms) to potentially produce the same conclusions that humans would. Substitute "intelligent being" for humans if you want. How would you express this concept in more detail? How would you prove it?

 

Implementing the Fish

The fish swims in a 2-D grid. Some grid entries have food, some have obstacles. The fish has an eye which is a 2-D string of sensors which can detect an obstacle or food in a particular direction from the fish and with a particular strength that matches the distance of that object. The fish has two outputs: direction and speed, which makes the fish move. The fish also has a random number generater (for fun) and a timer as inputs. Other inputs such as sine-wave generators might also produce interesting results.

 

The fish also has a level of hunger as input. The fish gets slowly more hungry over time. When the fish starves to death, it is remade (with the same network) in a safe place in the network; this is so that the fish does not get "stuck". Every time food is eaten, more food is regenerated on the grid somewhere. The goal of the fish is to be as well fed as possible.

 

The fish would have a list of statements as it's memory. For starters, no differentiation would be made between short term and long term memory.

 

Statements are typically deductions made from observations. They have a level of certainty attached to them. Statements form a network; Every time a deduction is made, it is connected with a bidirectional link with the statements it was made from. Statements can also make "search shortcuts" between themselves for when the prolog-style search algorithm has followed a particular path.

 

The inputs and outputs are special statements. When an input statement is "read", the value of the sensor is retrieved. When an output statement is unified with a particular value (somehow), that is what the output will do.

 

This network of statements is searched using a prolog-style searching algorithm. Deduced statements are added to memory. Unused statements are forgotten when memory is full.

 

Statements are horn clauses:

a(x) :- b(x), c(x).

a(x) :- d(x), c(x).

 

The fish can make new statements, properties and variables. Each property would represent a categorisation of some sort. Each statement would represent a deduction of some sort.

 

A deduction algorithm will also run concurrently, adding statements to memory.

 

One deduction algorithm would be to continually make new random deductions, and as evidence for that deduction arrives, increase or decrease the certainty of that deduction. There is a lot of scope for optimisation here. One problem to solve would be to work out how to determine if evidence has already been counted towards a particular deduction, or if the algorithm works without worrying about this.

 

Syntax

This section describes a syntax for a prolog-like programming language.

 

I prefer S-expressions from LISP to prolog's syntax.

 

Instead of writing:

grandfather(X, Z) :- father(X, Y), father(Y, Z).

we could write:

( (grandfather X Z) :- ( (father X Y) , (father Y Z) ) ).

or with a less prolog-like syntax:

( (grandfather X Z) if ( (father X Y) and (father Y Z) ) ).

 

There are possibilities for improving the syntax: some of the parenthesis could be made redundant.

 

Using an S-expression syntax, we could have prefix, infix or postfix operators simply by putting the operator in the appropriate location within the S-expression. The first element in the expression has no more significance than any other. For example, we could write the father rule as any of:

(father x y).

(x father y).

(x y father).

 

x and y (in lower case) are names of actual objects, whereas capitalised names such as X and Y act like prolog variables. The logic engine would pick out the atoms and try to apply rules. Say for example we have the following rules (excusing the biblical names, I can't think of any other examples right now):

 

(father abraham isaac).

(father isaac jacob).

 

Then we could do any of the following queries:

(father X isaac)? "Who is the father of isaac?"

(father isaac X)? "Who is isaac the father of?"

(X isaac jacob)? "What is the relationship between isaac and jacob?"

 

That last example currently cannot be done in Prolog as far as I'm aware. This makes for a very expressive and powerful system; not only can you reason about values in each expression, but you can also reason about the relationships.

 

I like using a full-stop at the end of a sentence to make it an informative statement, a question mark for a question and an exclamation mark for a command.

 

The AI would then contain a database of statements which it has asserted as being true (assuming a binary true/false system rather than a probability- or fuzzy logic-based system). There would need to be some context or module system to organise these statements. Some module or closure system would also be needed to make proofs by contradiction and so forth.

 

The AI would need rules which it can apply to statements to create new statements. These statements could also be asserted as being true.

 

For example, assuming a rewrite operator of "-->" and variables which could represent compound statements:

((A and true) --> A).

((A and false) --> false).

((A and B) --> (B and A)).

((not true) --> false)

 

and so forth. The AI could apply any of these rules to create new statements that it assumes are true.

 

A probability logic could be built up using these rules and the binary true/false system:

 

(father abraham isaac 0.6 0.7). "Abraham is likely (0.6) the father of isaac, and I'm mostly (0.7) sure about that."

 

I like the idea of replacing the prolog "is" statement for executing algebraic expressions with a different bracket, in this case { and }. For example:

(fibonacci 0 0).
(fibonacci 1 1).
((fibonacci N {F1+F2}) :- (
  (N > 1) and
  (fibonacci {N-1} F1) and
  (fibonacci {N-2} F2)

).

When evaluating a program like this, the AI could very well store any deductions it makes as it executes if it finds those deductions useful. It could also execute the rewriting rules in any non-deterministic order it wants to; the AI is searching for a solution rather than executing a program in a deterministic manner.

 

Programming Language Features

 

Needed Features

• Persistence: the AI must be able to aquire, remember and forget new facts and theories.
• Purity: Logical statements should not have cuts, asserts or contain assumptions about the evaluation order of clauses.
• Negation must not be by failure.

 

Prolog

• Many implementations, well understood.
• Impure. Contains cuts, asserts. not/1 implementation is hacky. Prolog applications commonly assume a backtracking algorithm and take advantage of the unification order of clauses.
• Not particularly persistent. New clauses can be added using assert/1 but this is a hack. Clauses typically are loaded from files.
• Can get stuck in an infinite loop.

 

Mercury

• http://en.wikipedia.org/wiki/Mercury_(programming_language), http://www.cs.mu.oz.au/research/mercury/
• Made for software engineering. It's a compiled language that's designed for pragmatism and speed. Meh.

 

Goedel

• Experimental language: http://www.scs.leeds.ac.uk/hill/GOEDEL/expgoedel.html. All links are broken, no downloads or examples available.
• Code looks good though: http://en.wikipedia.org/wiki/G%C3%B6del_(programming_language)
• Maybe research papers could be found?

 

COQ

• Theorum prover. I've done a course on it, but I need to learn more.
• If it could be automated, it could make hard deductions about the world. Randomly generated theories could be proven and then applied.

 

 

Reading material

 

http://en.wikipedia.org/wiki/Dempster-Shafer_theory

http://en.wikipedia.org/wiki/Epistemology

http://en.wikipedia.org/wiki/Bayes%27_rule

http://en.wikipedia.org/wiki/Bayesian_inference

 

http://nars.wang.googlepages.com/gti-summary

Cédrick Béler is porting NARS to Squeak: http://blog.summer.squeak.org/2008/05/opennars-port-to-squeak-using-seaside.html

Wang's Ph.D thesis on NARS has the most info, and valuable references to other research. Start reading at page 100 (chapter 6), then go back for theoretical explanations.

 

 

Artificial general intelligence Research Institute: http://www.agiri.org/wiki/Main_Page

Singularity Institute: http://www.singinst.org/

An afternoon's light reading: http://www.yudkowsky.net/bayes/bayes.html

 

 

http://www.opencog.org/wiki/Main_Page [opencog.org]

http://www.agiri.org/OpenCog_AGI-08.pdf [agiri.org]

http://justingibbs.com/how-to-make-singularity-bearable-in-its-infancy [justingibbs.com]

http://www.innergybv.biz/blog/?p=175 [innergybv.biz]

http://ieet.org/index.php/IEET/more/goertzel20080620/#When:22:49:00Z [ieet.org]

http://xlaurent.blogspot.com/2008/06/opensim-for-opencog.html [blogspot.com]

There's a number of GSoC projects for OpenCog currently underway also:

http://code.google.com/soc/2008/siai/about.html [google.com]

 

http://aima.cs.berkeley.edu/ai.html - more links than I could ever imagine.

 

 

(Comment from somebody on Slashdot:)

http://en.wikipedia.org/wiki/Constraint_logic_programming

 

http://cbcl.mit.edu/cbcl/courses/index.html - MIT lecture notes.

 

Reddit has an "Artificial Intelligence" category.

http://www.aaronsw.com/weblog/newcausation - Causality.

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=0521773628 - Causality, the book.