[ivan.moony]

Today I thought of a simple way of how to implement genetic algorithm. I'll need it for new formula generation. The idea is to randomly generate left and right side, then to check do they yield the same result with the same input variables. If they do, we put equal sign between them and there is a new furmula. To do this, we need to systematically generate possible candidates for left and right side.


The first thought I had was to cycle combinations of expressions like in following example (if we have expressions e1, e2 and e3 and super-expression that holds these 3):


e1,e1,e1
e1,e1,e2
e1,e1,e3
e1,e2,e1
e1,e2,e2
e1,e2,e3
e1,e3,e1
e1,e3,e2
...


This is easy, but it gets complicated to track combinations with multiple level expression depth and recursion. The genetic algorithm would be in that we first try combinations of those expressions which was more successful in finding new formulas (i.e. when a new formula is found to be true, expressions that built it get indexed up in future expression picking order).


Simpler way would be by utilizing random numbers, so the pattern of upper noted expression would be:



e1 if random(percent of e1) | e2 if random(percent of e2) | e3 if random(pecent of e3),

e1 if random(percent of e1) | e2 if random(percent of e2) | e3 if random(pecent of e3),

e1 if random(percent of e1) | e2 if random(percent of e2) | e3 if random(pecent of e3)


With each call we would get a randomly generated triple of expressions without need to track each combination and to cycle through all possible combination. We just pass percents of success (the more the percent is, the more possibility of picking that option) and each time we get a different randomly generated expression (well, it is possible to get the same expression twice or more times, but those are solvable details).


I think that random-approach is a lot simpler than cycling through all possible combinations. More, imagine if we had multiple levels of expressions with recursions and stuff. All that is solved easily with random-approach.


I just wanted to share this with you, such an complex combinatorial task, yet so easily solved with random expression picking.
 

[ivan.moony]

This is basically how an art could be artificially generated. You have to supply computer with i.e. valid English grammar and computer fires up random sentences. If we could steer those sentences to match some semi-planned result, we could have a machine - novel writer.

[ranch vermin]

I dont get it,  why would you need 2 equations that yeild the same result, why wouldnt you just need one of them?

[ivan.moony]

I dont get it,  why would you need 2 equations that yeild the same result, why wouldnt you just need one of them?

Actually it is two expressions in one equation, not two equations. I.e. one generated expression would be:

Code

A or B

and second:

Code

not ((not A) and (not B))

If the result in all cases for A and B, in the both expressions is the same, we can memorize equation:

Code

(A or B) <-> not ((not A) and (not B))

We can extrapolate  this to another example:

Code

seagull is bird
swan is bird
seagull has wings
swan has wings

If we imagine these two: "X has wings" and "X is bird", we can easily calculate that both hold for each example, thus:

Code

(X has wings) <-> (X is bird)

Voilé, also two expressions to check. I think it is all about comparing two expressions, and by comparing two by two we can get any count. When a match is found, we can use the "<->" operator to note the new discovery.

[ivan.moony]

Please note that induction explained in my last post is not the same as genetic algorithm. Induction could use expressions built by a genetic algorithm.

Edit: And genetic algorithm could use the number of successful matches of induction as a reference for where to focus future generated expressions.

[Korrelan]

If I understand correctly...

Cool idea but... Choosing the formula to be checked at random is no different to cycling through all possible combinations, if you are wanting to cover all possible permutations. The total possible number of combinations is the same, plus the extra time for duplicate checking.  I think you are just as likely to come across x+y <-> y+x either way. Once a expression/ formula has been discovered, indexing or moving to the top of the stack should be easy, kin to implementing a genetic algorithm.

[ranch vermin]

I thought this alot,  and I actually am even trying to do automatic extraction of symbols myself.

But just to you->
how are you going to extract these 'variables' from the sensor?
How did you know a seagulls wings are the same as a penguins wings.

Im sorry I dont understand the point of your idea, because ive put thought into this myself and came out with no cigar.

I dont see how the algorythm could be validated without knowing what the data was to begin with.   If there was anything generated from the genetic algorythm, unfortunately this extra information isnt possible to be assessed, judged, as correct or incorrect.

Only waiting till if it arised in the sensor, could you know if it was correct,  and by then its too late, it could have been assigned already by something that wasnt randomizing itself.   Anything that was used before judgement, is nothing but a noisy fantasy from the machine.

[ivan.moony]

I thought this alot,  and I actually am even trying to do automatic extraction of symbols myself.

Depending on  your requirements, you would need a description language first. I'll use this one: parser.moonyweb.com

how are you going to extract these 'variables' from the sensor?

In advance I would put paths to symbols that would be considered as variables.

How did you know a seagulls wings are the same as a penguins wings.

nohow

Im sorry I dont understand the point of your idea, because ive put thought into this myself and came out with no cigar.

The point is finding new rules that hold on experimental data.

I dont see how the algorythm could be validated without knowing what the data was to begin with.   If there was anything generated from the genetic algorythm, unfortunately this extra information isnt possible to be assessed, judged, as correct or incorrect.

Beside grammar you would need a way to explicitly assert work data (examplars) before running inductor. This data would be after checked with inductor. When a new rule is found, it holds until a data that does not fit into that rule shows up.

Induction is a complex matter and I've tried to roughly explain it in paper already published here. Note the version of Synth in this paper (it is 0.1. The newest version is 0.3, but it isn't explained yet on the paper, just in my mind (I thought to program it first). In version 0.3 mostly there are cosmetic changes, but there are behavior difference too).

[ranch vermin]

If you fully believe in the idea, definitely implement it,  it might work,  I wouldnt know for sure.    Just I thought about logic paradigm and GA's before and I couldnt really think how they could possibly be validated, other than given the exact answer to the question in the first place,  defeating the purpose of having it.

[ivan.moony]

After a bit of thinking I realized that I should clearly differ guessing from checking and induction.

Guessing can be done with genetic algorithm or by generalization from an example (not explained in this thread, but this is really intuitive).

Checking is done by induction as far as I'm concerned, by comparing one by one example until we check it all.

Some say that induction is actually something else: if two happenings always come together they are in condition-consequence relation. But I think that that is also guess-check cycle: we guess (either from examples, either by genetic algorithm) two happenings from a palette and then check (by induction) whether they always come together.

(Now becomes interesting) this together-thing works in a following way:
We conclude:

Code

A -> B

- if B is always there when A is there.
- which means that A can not be there without B

We conclude:

Code

A <-> B

- if B is always there when A is there and A is always there when B is there.
- which means that A can not be there without B and other way around

This is a way to form conditions and consequences from a list of plain data (maybe from a stream from input sensors). I believe they call all of this as induction, but I'd rather split it to guess and check steps.

[ranch vermin]

but what new have you discovered?

and I said, its impossible.  its not how machines work,  machines dont think, they can only be programmed,  simple shit.  ai or no ai, so if you try to come up with something that isnt in the dataset, then its just random bullshit that makes no sense, and is completely nonvalidatable, until the point where you would have known it without the genetic algorythm.

PS
But you did say, generalization,  and i think that would work, but it requires no genetic algorythm, hence me not thinking of it.

PS
i could be wrong, hence me telling you if you know something I dont, dont believe my bullshit.

[ivan.moony]

Let's say we have a formula over boolean a:

Code

not(not(a)) -> a

How did we get to that formula? We imagined it first with some kind of genetic algorithm in our mind. Then we checked every possibility to find out if the formula holds. i.e:

Code

not(not(true)) -> true
not(not(false)) -> false

and we concluded that the formula is valid

Genetic algorithm is about imagination. Generalization is also, but it's different from pure genetic imagination that attaches no bounds to imaginable particles. I think that genetic algorithm is more creative than generalization.