Hi,
I'm interested in combining the simplest, "most derivable" operations
( eg operations that cannot be defined by other operations) for creating
seed AGI's. The simplest operations combined in a multitude ways can
form extremely complex patterns, but the underlying logic may be
simple.
I wonder if varying combinations of the smallest set of operations:
{ ">" , memory ("=" for memory assignment), "==", (a logical way to
combine them), (input, output), () "brackets" }
can potentially learn and define everything.
Assume all input is from numbers.
We want the smallest set of elements, because less elements mean less
combinations which mean less chance of hitting combinatorial explosion.
">" helps for generalisation, reducing combinations.
memory(=) is for hash look ups, what should one remember? What can be
discarded?
"==" This does a comparison between 2 values x == y is 1 if x and y are
exactly the same. Returns 0 if they are not the same.
(a logical way to combine them) Any non-narrow algorithm that reduces
the raw data into a simpler state will do. Philosophically like
Solomonoff Induction. This is the hardest part. What is the most optimal
way of combining the above set of operations?
() brackets are used to order operations.
Conditionals (only if statements) + memory assignment are the only valid
form of logic - ie no loops. Just repeat code if you want loops.
If you think that the set above cannot define everything, then what is
the smallest set of operations that can potentially define everything?
------------------------------------------------------------------
Some proofs / Thought experiments :
1) Can ">", "==", (), and memory define other logical operations like &
("AND" gate) ?
I propose that "x==y==1" defines "x&y"
x&y x==y==1
0&0 = 0 0==0==1 = 0
1&0 = 0 1==0==1 = 0
0&1 = 0 0==1==1 = 0
1&1 = 1 1==1==1 = 1
It means "&" can be completely defined using "==" therefore "&" is not
one of the smallest possible general concepts. "&" can be potentially
"learnt" from "==".
-----------------------------------------------------------------
2) Write a algorithm that can define "1" using only >,==, ().
Multiple answers
a) "discrete 1 could use"
x == 1
b) "continuous 1.0 could use this rule"
For those not familiar with C++, "!" means "not"
(x > 0.9) && !(x > 1.1) expanding gives ( getting rid of "!" and "&&")
(x > 0.9) == ((x > 1.1) == 0) == 1 note "!x" can be defined in terms
of "==" like so x == 0.
(b) is a generalisation, and expansion of the definition of (a) and can
be scaled by changing the values "0.9" and "1.1" to fit what others
would generally define as being 1.
-------------------------------------------
agi
Archives: https://www.listbox.com/member/archive/303/=now
RSS Feed: https://www.listbox.com/member/archive/rss/303/
Modify Your Subscription:
https://www.listbox.com/member/?member_id=8660244&id_secret=8660244-6e7fb59c
Powered by Listbox: http://www.listbox.com
