uses of ai

[IvanV]

For a while I'm aware that from semantic tables like these for boolean stuff

¬ T -> F

¬ F -> T

T & T -> T

T & F -> F

F & T -> F

F & F -> F

T | T -> T

T | F -> T

F | T -> T

F | F -> F

you could by total induction completely automatically induce axiom rules like

¬¬ x -> x

x & y -> ¬(¬x | ¬y)

x | y -> ¬ (¬x & ¬y)

by systematically blind combining and then testing if expressions hold for all semantic table data. Gigahertzes and gigabytes should do the magic with some genetic algorithms.

I was wandering where could this be used, specifically what science branch could benefit from this system. For example, I could imagine new math formulas coming out of beginning semantic table (or beginning set of axioms) by induction. Now, Math is well explored artificial composition, so I predict nothing new in this field.

Actually I am searching for use of induction in any scientific branch, but I don't know what branch would be the most fruitful?

[IvanV]

I got it! It is medicine area that could benefit from this.

I am thinking of a system of knowledge, something like Wikipedia, where users would build a database and ask questions, so results and answers would be calculated. If there is a missing data, question could move on to-do list and popup when data arrives. For more interesting questions and more processing intensive calculations users could build grapes of processing stations and share processing power.

For a start, there exists DBpedia, selected articles from Wikipedia in database format that can be parsed to gather starting data.

Imagine all cures for illnesses that can be induced and deduced from database. Imagine healthy artificial food that would enable us to survive without killing living beings. Imagine new scientific formulas induced from experimental tables. This is definitely on mine to-do list where this parser would gather knowledge.

[SeH]

www.dreliza.com by steve richfield has this mostly figured out. i think the user-interface could be improved, because now it responds only to e-mails back and forth.  if it was more interactive, in particular, the knowledge entry system, it might accumulate solutions more easily.  note that dr. eliza is designed as a medical condition solver but it could also be extended to solve ANY problem.

--
You received this message because you are subscribed to the Google Groups "Genifer" group.
To unsubscribe from this group and stop receiving emails from it, send an email to general-intellig...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

[YKY (Yan King Yin, 甄景贤)]

Ivan,

Glad to see you back =)

I guess you should get more familiar with the distinction between propositional logic and (first order) predicate logic, as your post seems to be a bit confusing...

Propositional logic is good for things like digital circuit design (that is often called "logic design").  But most people in the AI field recognize that it's inadequate for  knowledge representation.  This is the issue of so-called "expressive power".

[Ivan Vodišek]

I am familiar with 1st order logic, but I find it not enough expressive and that's not it, although I'm familiar with resolution rule.

I have thrown a look at propositional logic and that is not either what I'm thinking of.

What I have in mind is near to some kind of Type Theory system, but the one that could express state transitions too (dynamics).

Actually we would have a tree structure for defining and holding data elements or sets of data. In this structure it would be possible to define also math formulas, logic formulas, etc (like: (a V b, ¬a V c) => introduce b V c, or: a^2 - b^2 => introduce (a + b) * (a - b)).

Besides simple storing data inside this tree structure, there would also be possible to express dynamics of data, like some kind of "system" for which is defined how it changes through time.  This changes would be simple events fired upon checking Boolean expressions. When specifically noted Boolean expression satisfies, it invokes a certain data change to a certain data node (like: apple.state = falling ON apple.x > table.x + table.width). I'm talking about a complete programming language capable of describing states of the Universe in a way that is simpler and more readable than in regular programming languages.

This way we would have a tool for describing any system in the Universe. Only problem now would be how to translate paragraphs of text into "description system" that reflects states (and their changes) described by the paragraph. The other side of the medal would be "how to explain specific 'description system' (or a part of it) in human words upon 'what, where, when, how, ...' query".

With this resolved, we would get smart encyclopedia and a jump board for induction and deduction.

2014-02-08 YKY (Yan King Yin, 甄景贤) <generic.in...@gmail.com>:

--

[YKY (Yan King Yin, 甄景贤)]

On Sun, Feb 9, 2014 at 1:56 AM, Ivan Vodišek <ivan....@gmail.com> wrote:

I am familiar with 1st order logic, but I find it not enough expressive and that's not it, although I'm familiar with resolution rule.

I have thrown a look at propositional logic and that is not either what I'm thinking of.

What I have in mind is near to some kind of Type Theory system, but the one that could express state transitions too (dynamics).

Actually we would have a tree structure for defining and holding data elements or sets of data. In this structure it would be possible to define also math formulas, logic formulas, etc (like: (a V b, ¬a V c) => introduce b V c, or: a^2 - b^2 => introduce (a + b) * (a - b)).

Besides simple storing data inside this tree structure, there would also be possible to express dynamics of data, like some kind of "system" for which is defined how it changes through time.  This changes would be simple events fired upon checking Boolean expressions. When specifically noted Boolean expression satisfies, it invokes a certain data change to a certain data node (like: apple.state = falling ON apple.x > table.x + table.width). I'm talking about a complete programming language capable of describing states of the Universe in a way that is simpler and more readable than in regular programming languages.

This way we would have a tool for describing any system in the Universe. Only problem now would be how to translate paragraphs of text into "description system" that reflects states (and their changes) described by the paragraph. The other side of the medal would be "how to explain specific 'description system' (or a part of it) in human words upon 'what, where, when, how, ...' query".

With this resolved, we would get smart encyclopedia and a jump board for induction and deduction.

​What you described (using a programming language as knowledge representation) is exactly what Seh described to me before -- though he used Java as an example =)

​There may be some merits of such a scheme... in the sense that a knowledge representation can be executed as code.​  But what would be the advantages... ?  Interesting idea =)

[SeH]

maybe these are relevant:

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

http://arxiv.org/abs/0802.3492

(i havent used either though)

[Matt Mahoney]

It is not a new idea. Many early AI attempts used Lisp to encode knowledge.

--
-- Matt Mahoney, mattma...@gmail.com

[Ivan Vodišek]

what do U guys think of this one, this is what I'm working on, a parser with rule transformations:

Sum {

    Fact {

        Exp (

            {@WhiteSpace | @Null},

            Sign {'-' | @Null},

            Value {

                Num {@Number} |

                Var {@Variable} |

                Bra (Left {'('}, In {@Sum}, Right {')'}) // @Sum vars like this one inherit <...> code from initial Sum var

            },

            {@WhiteSpace | @Null}

        ) |

        MulDiv (Left {@Fact}, In {'*' | '/'}, Right {@Exp})

    } |

    AddSub (Left {@Sum}, In {'+' | '-'}, Right {@Fact})

}

<   x * u + x * (y * v - y * w) // this is initial value of Sum - to be parsed by upper rules

    INSERT <@s.a * (@s.x @s.in @s.y)> // this segment inserts a * (x +- y)

        ON INSERTED Sum AND INSERTED MATCHES Sum <?a * ?x ?in ?a * ?y> AS s // upper is inserted when matching 'a * x +- a * y'

>

// after all magic Sum would also contain <x * (u + y * (v - w))>

2014-02-09 Matt Mahoney <mattma...@gmail.com>:

[Ivan Vodišek]

How about this one:

1. There would be one central web page where whole knowledge base is stored. Knowledge base might be distributed across Internet

2. Scientists freely enter data about different sciences into knowledge base, so there would be math, physics, chemistry, biology, geography, history, or anything else. It would be completely formalized and algorithmized set of different scientific fields, like a big united scientific theory.

3. Computer automatically deduces and induces new, yet unknown conclusions and helps scientists to build new and advance existing theories. We all know that a good definition of a problem is a half solution to it, and automated induction and deduction would be a great help for scientists, I think.

Wow, this shouldn't fail that easily. Sooner or later someone will make this gate to scientific singularity. We already have all needed stuff, namely Internet and different theories about theories.

[Matt Mahoney]

Would you care to translate Wikipedia to Cycl? Or specify a new formal
language to represent scientific knowledge, translate to that, and
build a new inference engine?

[Ivan Vodišek]

I have something new in mind. I'm thinking of storing knowledge in this format: http://synth.wink.ws/moonyparser/. If this format can parse any string, then it is capable of storing any knowledge. I like its tree structure comparing to plain, one level deepness of languages in existing theories about theories. On top of that would be basic inference engine that would accept formulas like:

A -> B

where A and B would be anything definable in mentioned Moony grammar extended with pattern matching variables. Specific inference formulas (consisted of -> operator and Moony left and right side) would look like these:

((a -> b), a) -> b;

a * x + a * y = a * (x + y);

(a = b) -> (a <-> b);

(a <-> b) -> (a -> b, b-> a) 

and they would serve to deduce consequent knowledge. Here could be defined logic inference formulas too. Besides deduction, which I think humans handle very well, there would also be an induction engine. Induction is a hard nut, very slow stuff even for computers (consider combinatorial explosion of imaginable rules). Induction would be used to find new formulas of which existence we are not aware. You can call induction as generalization, as it describes finding a new inference rule that holds on some general population of existing sentences. Once that a new rule is found, the new rule could serve as basis for inferring new stuff, opening a new area of knowledge (did anyone mentioned Big United Theory here?). This slow part could be distributed among online users which would choose where they want to invest their processor time. So, given enough time and processor power, induction algorithm would occasionally popup with a new formula for, say, quantum physics, calculated from electrical imagination (remember combinatorial explosion?) and examples of experimental data.

Basic program would be knowledge base inputer that would look somewhat like office math expression creator, but the base inputer would be extendable to any scientific language, say, chemistry. Basic inputer would be also extendable by plugins which users could make available for public use. Induction could be programmed as plugin. Also DBPedia knowledge or natural language processing could be achievable through plugins. Behavior mechanism could also be a plugin, which would make the system acts like a human. Computer vision would also do as a plugin. All in slow javascript and php. But computers are getting faster and faster and that distributed computing is thrilling me entirely.

[Matt Mahoney]

You could use Moonyparser to parse the millions of assertions in
OpenCyc I suppose. Or are you proposing to write something from
scratch? I mean, Cyc is unfinished after 30 years, so they are
obviously taking the wrong approach to AI.

[Ivan Vodišek]

Sometimes the most simple solution is the most hidden one. No one says that OpenCyc wouldn't get finished already tomorrow.

Nevertheless I'm writing a framework from the scratch. Simple and clean, easy to program in it, easy to reason in it. I've taken a look at OpenCog and I find it complicated with all smart buzzwords that only small amount of people understand after thorough investigation. I like simple solutions. Something like: 

1. "this A" is how U define system

2. "this B" is how system can transform itself by rules XYZ

3. "this C" is how to find transformation sequence which lead the system from initial state A to wanted state B

I believe that simplicity is also a way to general intelligence, although it might pop up that considerable amount of complexity is necessary for such a task. But the task might be so simple that we cannot see solution because of our expectations of complexity and that's what I'm counting on.

[Matt Mahoney]

Let us know how it works.