You guys may be interested in this <[link]>.

== quote ==

We are happy to release a resource, spanning 7,560,141 concepts and 175,100,788 unique text strings, that we hope will help everyone working in [information retrieval and natural language processing].

KY,
Good luck at making impressions for Genifer and AGI at the start-up convention!!
-RS
______________________________ __
From: "YKY (Yan King Yin, 甄景贤)" <generic.intellige...@gmail.co m>
To: general-intelligence@googlegro ups.com
Sent: Thursday, May 17, 2012 9:28 PM

This is a good idea I think ... forward-chaining should be very suitable for this kind of processing.  It can also parse commands and give English explanations.  There's also fuzzy auto-complete in some IDEs...

this is one program that can compare similar code segments..

[link]

whether this happens in a command shell or IDE is pretty much the same
thing since this application would blur the lines between them.

for example, the strace/ltrace features Jim suggested would be analogous to

SeH,

I was actually thinking about a similar idea, in the context of programming
IDEs. It often happens that I write the same kind of structure twice or
more, either within the same function or in several functions. Usually when
I notice I'll make a function out of it, but not always. It's slightly

This is a good idea I think ... forward-chaining should be very suitable
for this kind of processing. It can also parse commands and give English
explanations. There's also fuzzy auto-complete in some IDEs...

I'm going to a local startup competition to introduce Genifer to some local
Hong Kong people... which lasts for the weekend... will get back to this

absolutely, command auto-completion suggestions could certainly be
involved.

i certainly recognize the relevant application of compression and also the
inductive logic solution applied in the mentioned paper.

yes! i think the strace or ltrace traces for a given command could indicate:

training against strace dumps of any program, shell or otherwise would be
trivial to provide for a stream of entity actions to classify

That's an interesting idea. One problem might be ending up with more
macros than you can remember. Another approach might be auto-complete
by comparing what you are typing with commands you entered previously.
In either case, it's similar to the problem of compressing your
command history.

i was thinking of a command shell, or an extension to existing shell like
BASH that analyzes your command history and automatically suggests macros
that cover frequently used command patterns.

for example, if i end up typing commands like:

find | fgrep '.c'
find | fgrep 'y'

it would suggest or create a new macro:

* and + may look isomorphic to AND and OR, but
a*b != b*a
whereas
a AND b = b AND a.

That makes the logic subtly different from Boolean algebra... otherwise
we'd be able to use database query optimizers to answer queries in Gen
logic.

In fact, Genifer's * and + can co-exist with Boolean algebra, resulting in

so far you've got something that looks like sparql test queries.

On Mon, May 14, 2012 at 1:14 AM, YKY (Yan King Yin, 甄景贤) <

May I be free to draw a parallel I was inspired to by you?

This strongly reminds me of induction / reverse induction, although it's
somewhat different from it

a+b+<something else> |= x

When we say x we are not sure does it imply back a, b, <something else>, or
some combination of thees. It would have to be at least one of thees, but

I just implemented some Clojure functions for context management. All the
contexts are stored in a big tree structure.

What I discovered is that contexts cannot deal with the problem of compound
sentences, so the logic really needs to have 2 operations: composition and
pairing. Their axioms look like addition and multiplication:

If equations are understood to work both ways, then clearly this is an
abuse, yes.

--Abram

On Sat, May 12, 2012 at 3:36 AM, YKY (Yan King Yin, 甄景贤) <

--
Abram Demski
[link]

PS:

It appears that one can use rewrite rules to perform inference involving
quantification, for example:
All man are mortal
can be rewritten in some way to give:
Socrates is mortal
but I've decided against this usage because it doesn't follow the original
principle, namely that the rewrite system is a set of *equations* relating *

Yes it should fail... I was playing around with some rules (I found "W
gives Z the creeps" to be a common English phrase on Google), but
unexpectedly it produced the above rewrite step.

I guess the natural reason for this is that X, Y, W and Z are supposed to
be people, but "X loves" is not a person. So it's the semantic information

YKY,

Apparently when both the term and the rewrite rule have multiple variables,

How is this in any way correct (even before the infinite loop problem)?

Shouldn't the rewrite rule just fail to apply here?

On Tue, May 8, 2012 at 7:17 AM, YKY (Yan King Yin, 甄景贤) <

--
Abram Demski

Any software documentation? What is it supposed to do?

On Tue, May 8, 2012 at 11:28 AM, YKY (Yan King Yin, 甄景贤)

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

A very basic Genifer interpreter is ready:
You can download this
jar<[link]>and
run it by:
java -jar genifer-1.0.1-standalone.jar

Clojure objects can mix freely with Genifer logic.
For example you can have Genifer logic statements like:

First version of narrowing completed... that was quite a lot of work =)
[link]

Narrowing is just a more sophisticated form of unification modulo a set of
equations.

Apparently when both the term and the rewrite rule have multiple variables,