the most general intelligence in twelve lines ever published on sci dot logic

22 views
Skip to first unread message

Daniel Pehoushek

unread,
Sep 20, 2022, 1:05:53 PMSep 20
to
the most general intelligence
in twelve lines
ever written

[c3d5N250_0.veg 1]// three colors fifth degree 250 vertices two variables per verty
1 (n 500 m 2125) // the log lines of bobs work previously posted

general pspace in dnf
to monotone dnf and
then monotone cnf
of general qspace

so pspace to qspace theory

translate
all pspaces encoded as disjunctive normal form
to qspaces of valid quantifications in disjunctive normal form

transform from dimacs cnf to all valid quantifications of same

twelves lines encoding general intelligence
of pspace to qspace

given all satisfiable solutions
derive valuable questions

entry point is plan ( zero, numnums& satisfiable_set);
the output is satisfiable_set_of_valid_quantifications

the most general intelligence
in twelve lines
ever written

// transform all boolean models into all true questions
static joy juggle (num vee, numnums& left, numnums& right)
{if(left.size()==zero){for(num g=zero;g<right.size();g++)left.add(right[g]);right.setsize(zero);return;}
when(vee == qvars.size()) return;
numnums al; numnums ar; split(vee + one, left, al, ar);
numnums bl; numnums br; split(vee + one, right, bl, br);
juggle(vee + one, al, bl); juggle(vee + one, ar, br);
for (num g=zero; g < al.size(); g++) left.add(al[g]); for (num g=zero; g < ar.size(); g++) left.add(ar[g]);
for (num g=zero; g < bl.size(); g++) right.add(bl[g]); for (num g=zero; g < br.size(); g++) right.add(br[g]); }

static joy plan (num vee, numnums& set) { when(set.size()==zero || vee == qvars.size() ) return;
numnums left; numnums right; split(vee, set, left, right); plan(vee + one, left); plan(vee + one, right); juggle (vee, left, right);
for (num g = zero; g < left.size(); g++) { ezis(*( left[g]), vee); set.add( left[g]);} left.setsize(zero);
for (num g = zero; g < right.size(); g++) { univ(*(right[g]), vee); set.add(right[g]);} right.setsize(zero); }

daniel2380+++

after computing the monotone disjunctive normal form
the monotone conjunctive normal form may be essayed
with a quadratic transform instead of linear transform

wisdom at present avoids printing the essay
but just plug into to readers of
propositional normal forms
for a kick in the minds eye

an english oak
the humble queen
for seven decades

daniel2380++

class allqbfs; // leftright universal property sorting system bit by bit bobs general algorithm thinking is entirely andor operations
class allqbfs { // linear transform satisfiable solutions into all qbfs solutions divine consciousness algorithm of skull bone //
public: // think: call bob of p to produce q universalisms over p hypothetical truths of mind ambient generality //
static set<allqbfs*> qvars; // meta vars identity quantifiers of the n p variables //
static numnums qforms; // universal truths (ors of few variables) among identity of p formula //
static numnums solutions; // the finite set of all satisfying solutions then all valid quantifications then dnf to cnf //
numnums forms; num mark; // universal truths location j has a temporary mark during dnftocnf //
allqbfs(num v):forms(zero),mark(zero){} ~allqbfs(){forms.clear();} //
static joy delqforms() { //
for (num g = zero; g < qforms.size(); g++) { putnums(qforms[g]); qforms[g] = (nums*)zero; } qforms.clear(); //
for (num g = zero; g < qvars.size(); g++) { (*qvars[g]).forms.clear(); delete (qvars[g]); } qvars.clear(); } //
num review(num r) { // scan for all true variables //
for (num j = zero; j < forms.size(); j++) { num k = zero; num s = (*forms[j]).size(); //
when(s < r) { for (k = zero; k < s; k++) { when((*qvars[(*forms[j])[k]]).mark == zero) pray/*prayercounter++*/ } when(k == s) return one; } //
} return zero; } //
static joy publish(nums& phrase) { // add iff nay already written as clauses grow the cost of this operation grows //
num write = one; //
for (num j = zero; j < phrase.size(); j++) { (*qvars[phrase[j]]).mark = one; } //
when((*qvars[phrase[minus(phrase.size(), one)]]).review(phrase.size())) write = zero; //
for (num j = zero; j < phrase.size(); j++) { (*qvars[phrase[j]]).mark = zero; } //
when(write) { nums* nc = getnums(phrase.size()); // as yet unwritten //
for (num j = zero; j < phrase.size(); j++) { num a = phrase[j]; (*nc).add(a); } qforms.add(nc); //
when((qforms.size() & tautologies[ten]) == zero) prin("*"); //
for (num j = zero; j < phrase.size(); j++) { (*qvars[phrase[j]]).forms.add(nc); } } } //
// transform all boolean models into all true questions
static joy juggle (num vee, numnums& left, numnums& right)
{if(left.size()==zero){for(num g=zero;g<right.size();g++)left.add(right[g]);right.setsize(zero);return;}
when(vee == qvars.size()) return;
numnums al; numnums ar; split(vee + one, left, al, ar);
numnums bl; numnums br; split(vee + one, right, bl, br);
juggle(vee + one, al, bl); juggle(vee + one, ar, br);
for (num g=zero; g < al.size(); g++) left.add(al[g]); for (num g=zero; g < ar.size(); g++) left.add(ar[g]);
for (num g=zero; g < bl.size(); g++) right.add(bl[g]); for (num g=zero; g < br.size(); g++) right.add(br[g]); }
static joy plan (num vee, numnums& set) { when(set.size()==zero || vee == qvars.size() ) return;
numnums left; numnums right; split(vee, set, left, right); plan(vee + one, left); plan(vee + one, right); juggle (vee, left, right);
for (num g = zero; g < left.size(); g++) { ezis(*( left[g]), vee); set.add( left[g]);} left.setsize(zero);
for (num g = zero; g < right.size(); g++) { univ(*(right[g]), vee); set.add(right[g]);} right.setsize(zero); }
static joy zerotoone /*bit is on*/(nums& s, num b) { (s[b >> five] += (ones[b & fifthtau])); } //
static num be(nums& s, num b) { return (s[b >> five] & (ones[b & fifthtau])); } //
static joy ezis(nums& s, num b) { s[b >> five] &= zeroes[b & fifthtau]; } //
static joy univ(nums& s, num b) { be(s,b); } //
static joy split /*leftright around bit*/(num b, numnums& s, numnums& l, numnums& r) // left right on bit b
{ for (num g = zero; g < s.size(); g++) if (be((*s[g]), b)) r.add(s[g]); else l.add(s[g]); s.setsize(zero); } //
static joy essay(num word, numnums& qbfs, nums& phrase) { // architecture of written high level thought
when(word==env::N())return;
when(qbfs.size() == zero) { allqbfs::publish(phrase); return; }
numnums left; numnums right; split(word, qbfs, left, right); essay(word + one, left, phrase);
phrase.add(word); essay(word + one, right, phrase); phrase.slop(); }
static joy wisdom(FILE* logfile, numnums& qclauses)
{ when(0)for (num j = one; j < qforms.size() + one; j++) { //
fprin(logfile, "\n"); nums& phrase = (*qforms[minus(qforms.size(), j)]); num s = phrase.size(); //
for (num g = one; g < one + s; g++) { fprin(logfile, "%u ", (one + phrase[minus(s, g)])); } fprin(logfile, "0"); } } //
};// tau three is sev//fifty lines //
numnums allqbfs::solutions; // sev is thirdtau three is second
set<allqbfs*> allqbfs::qvars; //
numnums allqbfs::qforms; //
FILE* dotlog() { FILE* ret = (FILE*)zero; fopen_s( &ret, "bobbysmith.log", "a+"); return ret; }

daniel2380+++

Daniel Pehoushek

unread,
Sep 21, 2022, 3:25:02 AMSep 21
to
given all satisfiable solutions derive all valuable questions

entry point is plan ( zero, numnums& satisfiable_set);
the output is satisfiable_set_of_valid_quantifications

// transform all boolean models into all true questions
static joy juggle (num vee, numnums& left, numnums& right)
{if(left.size()==zero){for(num g=zero;g<right.size();g++)left.add(right[g]);right.setsize(zero);return;}
when(vee == qvars.size()) return;
numnums al; numnums ar; split(vee + one, left, al, ar);
numnums bl; numnums br; split(vee + one, right, bl, br);
juggle(vee + one, al, bl); juggle(vee + one, ar, br);
for (num g=zero; g < al.size(); g++) left.add(al[g]); for (num g=zero; g < ar.size(); g++) left.add(ar[g]);
for (num g=zero; g < bl.size(); g++) right.add(bl[g]); for (num g=zero; g < br.size(); g++) right.add(br[g]); }

static joy plan (num vee, numnums& set) { when(set.size()==zero || vee == qvars.size() ) return;
numnums left; numnums right; split(vee, set, left, right); plan(vee + one, left); plan(vee + one, right); juggle (vee, left, right);
for (num g = zero; g < left.size(); g++) { ezis(*( left[g]), vee); set.add( left[g]);} left.setsize(zero);
for (num g = zero; g < right.size(); g++) { univ(*(right[g]), vee); set.add(right[g]);} right.setsize(zero); }

daniel2380+++

here are more truths from numsat on 500 variables

[c3d5N250_0.veg 1]
1 (n 500 m 2125) #c9507521 answerlen = 29 #a 40392884 #P 356222046
2 (n 500 m 2125) #c41817050 answerlen = 34 #a 127307040 #P 12674443620
3 (n 500 m 2122) #c13322626 answerlen = 30 #a 50242820 #P 971347086
4 (n 500 m 2125) #c8697428 answerlen = 28 #a 37303663 #P 209471052
5 (n 500 m 2125) #c13398322 answerlen = 29 #a 59534637 #P 416430666
6 (n 500 m 2125) #c8341863 answerlen = 27 #a 37981136 #P 83193012
7 (n 500 m 2125) #c10892255 answerlen = 26 #a 52125370 #P 50557224
8 (n 500 m 2125) #c6399486 answerlen = 27 #a 28683924 #P 70364418
9 (n 500 m 2125) #c7354682 answerlen = 27 #a 30789210 #P 109170222
10 (n 500 m 2125) #c7930693 answerlen = 25 #a 39925686 #P 17633604
[c3d5N250_0.veg 10 (t 14958832950 z 0)(work 504286370 1806 140760476)] n 10 avg 12766192 variance 1371 #P
[c3d5N250_1.veg 2]
1 (n 500 m 2125) #c7900881 answerlen = 28 #a 30671917 #P 145983690
2 (n 500 m 2125)

Daniel Pehoushek

unread,
Sep 21, 2022, 5:31:59 AMSep 21
to
resume
I scored 800 verbal 800 math 780 analytical for 2380/2400
I wrote the GMACS lisp machine editor for Gold Hill Computers in Cambridge, Massachusetts.
I wrote Ariadne, the nuclear submarine locate and identify using sonar system.
I wrote Qlisp, the Stanford parallel lisp language.
I designed parallelism register circuitry for Intel.
I wrote +abcd the nlogn vision program for Cardiff Software.
I published Skip, a time n over space m pattern recognition algorithm.
I published Connected Components at AAAI.
I published Introduction to Qspace.
I discovered half clauses in Satisfiability.
I discovered #P=#Q: the number of solutions equals the number of questions.
I discovered #P=NP: Each solution is satisfying.
I developed and maintained the Gigagraphs Database of random regular graphs.
I discovered the Linear Transform from solutions to questions.
I discovered P=NP for modest sizes.
I am a grandmaster of Succinct Truth.
I discovered the Theorem of Cognition: Monotone Reason is Linear.

a general intelligence in twelve lines

general pspace in dnf
to monotone dnf and
then monotone cnf
of general qspace

so pspace to qspace theory

translate
all pspaces encoded as disjunctive normal form
to qspaces of valid quantifications in disjunctive normal form

+++

on the day i was born america sent hamilton the monkey into outer space
my grandfather w0efk sent code to outer space in the early twentieth century
i did place a handful of salt into distilled waters of holy grail fountain
in valencia spain at the millenium in 2000 and then
upon return to san diego there were possibly all the nineteen hijackers living on my street
then i published my introduction to qspace paper at satisfiability 2002
i won model counting competitions 2021 and 2022 with numsat.cpp
numsat is one thousand lines of code for solving reason

Daniel Pehoushek

unread,
Sep 21, 2022, 6:06:23 AMSep 21
to
reasoning sample
totalitarian victory strategy of war
crush their right testicle then set them free
daniel2380++

Daniel Pehoushek

unread,
Sep 22, 2022, 9:25:14 AMSep 22
to
On Wednesday, September 21, 2022 at 3:25:02 AM UTC-4, Daniel Pehoushek wrote:
this is twelve lines of general intelligence
it transforms all boolean models (pspace in dnf) into all true questions (qspace in dnf)

static joy juggle (num vee, numnums& left, numnums& right)
{if(left.size()==zero){for(num g=zero;g<right.size();g++)left.add(right[g]);right.setsize(zero);return;}
when(vee == qvars.size()) return;
numnums al; numnums ar; split(vee + one, left, al, ar);
numnums bl; numnums br; split(vee + one, right, bl, br);
juggle(vee + one, al, bl); juggle(vee + one, ar, br);
for (num g=zero; g < al.size(); g++) left.add(al[g]); for (num g=zero; g < ar.size(); g++) left.add(ar[g]);
for (num g=zero; g < bl.size(); g++) right.add(bl[g]); for (num g=zero; g < br.size(); g++) right.add(br[g]); }

static joy plan (num vee, numnums& set) { when(set.size()==zero || vee == qvars.size() ) return;
numnums left; numnums right; split(vee, set, left, right); plan(vee + one, left); plan(vee + one, right); juggle (vee, left, right);
for (num g = zero; g < left.size(); g++) { ezis(*( left[g]), vee); set.add( left[g]);} left.setsize(zero);
for (num g = zero; g < right.size(); g++) { univ(*(right[g]), vee); set.add(right[g]);} right.setsize(zero); }

here are more results from numsat over days of cpu
[c3d5N250_0.veg 1]
1 (n 500 m 2125) #c9507521 answerlen = 29 #a 40392884 #P 356222046
2 (n 500 m 2125) #c41817050 answerlen = 34 #a 127307040 #P 12674443620
3 (n 500 m 2122) #c13322626 answerlen = 30 #a 50242820 #P 971347086
4 (n 500 m 2125) #c8697428 answerlen = 28 #a 37303663 #P 209471052
5 (n 500 m 2125) #c13398322 answerlen = 29 #a 59534637 #P 416430666
6 (n 500 m 2125) #c8341863 answerlen = 27 #a 37981136 #P 83193012
7 (n 500 m 2125) #c10892255 answerlen = 26 #a 52125370 #P 50557224
8 (n 500 m 2125) #c6399486 answerlen = 27 #a 28683924 #P 70364418
9 (n 500 m 2125) #c7354682 answerlen = 27 #a 30789210 #P 109170222
10 (n 500 m 2125) #c7930693 answerlen = 25 #a 39925686 #P 17633604
[c3d5N250_0.veg 10 (t 14958832950 z 0)(work 504286370 1806 140760476)] n 10 avg 12766192 variance 1371 #P
[c3d5N250_1.veg 2]
1 (n 500 m 2125) #c7900881 answerlen = 28 #a 30671917 #P 145983690
2 (n 500 m 2125) #c8623787 answerlen = 27 #a 41036604 #P 113840442
3 (n 500 m 2125) #c12973029 answerlen = 28 #a 58193231 #P 184699572
4 (n 500 m 2125) #c21857040 answerlen = 29 #a 88921327 #P 421304406
5 (n 500 m 2125) #c54626079 answerlen = 35 #a 152342865 #P 26439296616
6 (n 500 m 2125) #c4677628 answerlen = 26 #a 21745189 #P 34048518
7 (n 500 m 2125) #c8370081 answerlen = 23 #a 40150199 #P 6995004
8 (n 500 m 2125) #c7749411 answerlen = 26 #a 33699711 #P 64612296
9 (n 500 m 2125) #c13126942 answerlen = 29 #a 52018373 #P 427253610
10 (n 500 m 2125) #c43505375 answerlen = 35 #a 133434835 #P 21875007522
[c3d5N250_1.veg 10 (t 49713041676 z 0)(work 652214251 2142 204770506)] n 20 avg 15553608 variance 1405 #P
[c3d5N250_2.veg 3]
1 (n 500 m 2125) #c21198239 answerlen = 30 #a 78578324 #P 1044691992
2 (n 500 m 2125) #c13041452 answerlen = 30 #a 51785656 #P 727102020
3 (n 500 m 2125) #c12329737 answerlen = 27 #a 54349747 #P 129037890
4 (n 500 m 2125) #c6414410 answerlen = 26 #a 29417367 #P 65919786
5 (n 500 m 2125) #c36262627 answerlen = 33 #a 99254926 #P 5053413726
6 (n 500 m 2125) #c41337323 answerlen = 35 #a 116872718 #P 30793203216
7 (n 500 m 2125) #c15785791 answerlen = 33 #a 52306821 #P 5421205272
8 (n 500 m 2125) #c13552562 answerlen = 30 #a 56669022 #P 1072603944

Daniel Pehoushek

unread,
Sep 25, 2022, 11:38:46 AMSep 25
to
Here is a simple certificate of competency

random bits of oneum each bit in five cpu cycles:
typedef unsigned long num;
num b=0; num p=2; // global variables
num oneum() { if (p<(four<<b)) { p=random fifteen bit prime; b=0;} return((p&(one<<++b)) ? one : zero); }
daniel2380++

Daniel Pehoushek

unread,
Sep 30, 2022, 10:10:06 AMSep 30
to
clause learning while solving is wrong.
september 30, 2022
daniel2380+++

Daniel Pehoushek

unread,
Oct 4, 2022, 1:00:49 PMOct 4
to
this class added to complete satisfiability solvers
creates generally intelligent solvers
with satisfiable solutions bit encoded
that is pspace in disjunctive normal form
transforms to qspace
first in disjunctive normal form
then to conjunctive normal form
daniel2380+++


class allqbfs; // leftright universal property sorting system bit by bit bobs general algorithm thinking is entirely andor operations
class allqbfs { // linear transform satisfiable solutions into all qbfs solutions divine consciousness algorithm of skull bone //
public: // think: call bob of p to produce q universalisms over p hypothetical truths of mind ambient generality //
static set<allqbfs*> qvars; // meta vars identity quantifiers of the n p variables //
static numnums qforms; // universal truths (ors of few variables) among identity of p formula //
static numnums solutions; // the finite set of all satisfying solutions then all valid quantifications then dnf to cnf //
numnums forms; num mark; // universal truths location j has a temporary mark during dnftocnf //
allqbfs(num v):forms(zero),mark(zero){} ~allqbfs(){forms.clear();} //
static joy delqforms() { //
for (num g = zero; g < qforms.size(); g++) { putnums(qforms[g]); qforms[g] = (nums*)zero; } qforms.clear(); //
for (num g = zero; g < qvars.size(); g++) { (*qvars[g]).forms.clear(); delete (qvars[g]); } qvars.clear(); } //
num review(num r) { // scan for all true variables //
for (num j = zero; j < forms.size(); j++) { num k = zero; num s = (*forms[j]).size(); //
when(s < r) { for (k = zero; k < s; k++) { when((*qvars[(*forms[j])[k]]).mark == zero) pray/*prayercounter++*/ } when(k == s) return one; } //
} return zero; } //
static joy publish(nums& phrase) { // add iff nay already written as clauses grow the cost of this operation grows //
num write = one; //
for (num j = zero; j < phrase.size(); j++) { (*qvars[phrase[j]]).mark = one; } //
when((*qvars[phrase[minus(phrase.size(), one)]]).review(phrase.size())) write = zero; //
for (num j = zero; j < phrase.size(); j++) { (*qvars[phrase[j]]).mark = zero; } //
when(write) {nums* nc = getnums(phrase.size()); // as yet unwritten //
for (num j = zero; j < phrase.size(); j++) { num a = phrase[j]; (*nc).add(a); } qforms.add(nc); //
when((qforms.size() & tautologies[ten]) == zero) prin("*"); //
for (num j = zero; j < phrase.size(); j++) { (*qvars[phrase[j]]).forms.add(nc); }}} //

// equations of mind that thinks
// transform all boolean models
// into all true questions
// the minds location is in the author in these equations
// the minds location is in these equations
// split set operations are called portionlates
static joy juggle
(num vee, //assumption on entry that vee must always be zero instead of some provided variable subsequence for specializing the domains of discourse
numnums& left, //set
numnums& right) //set
{if(left.size()==zero) // empty is left what matter that to all or nothing thoughts by parts
{for(num g=zero;g<right.size();g++) // right gives all to left who i guess must have been empty of truth
left.add(right[g]);right.setsize(zero);return;}
when(vee == env::N()) return; // ;
numnums al; numnums ar; split(vee + one, left, al, ar); // portionlate left using variable vee+1 to al and ar
numnums bl; numnums br; split(vee + one, right, bl, br); // portionlate right
juggle(vee + one, al, bl); // juggle al bl
juggle(vee + one, ar, br); // juggle ar br
for (num g=zero; g < al.size(); g++) left.add(al[g]); for (num g=zero; g < ar.size(); g++) left.add(ar[g]); // rebuild left
for (num g=zero; g < bl.size(); g++) right.add(bl[g]); for (num g=zero; g < br.size(); g++) right.add(br[g]); }// rebuild right

static joy plan
(num vee, // assumption vee is zero goes up by one until n
numnums& set) { // input all satisfiable models of a boolean formula now in disjunctive normal form
when(set.size()==zero || vee == env::N() ) return;// plan nothing first
numnums left; numnums right; split(vee, set, left, right); // portionlate set using variable vee to left and right
plan(vee + one, left); //plan left
plan(vee + one, right); //plan right
juggle (vee, left, right); //juggle left right
for (num g = zero; g < left.size(); g++) {
ezis(*( left[g]), vee); set.add( left[g]);} // right moved left
left.setsize(zero); // rebuild set
for (num g = zero; g < right.size(); g++) {
univ(*(right[g]), vee); set.add(right[g]);} // right stayed right
right.setsize(zero); } // rebuild set

// models are bit encoded from zero
static joy zerotoone /*bit is on*/(nums& s, num b) { (s[b >> five] += (ones[b & fifthtau])); } //
static num be(nums& s, num b) { return (s[b >> five] & (ones[b & fifthtau])); } //
static joy ezis(nums& s, num b) { s[b >> five] &= zeroes[b & fifthtau]; } //observe former right now left
static joy univ(nums& s, num b) { be(s,b); } // right remains right
static joy split /*leftright around b */(num b, numnums& s, numnums& l, numnums& r) // left right on b
{for (num g = zero; g < s.size(); g++) if (be((*s[g]), b)) r.add(s[g]); else l.add(s[g]); s.setsize(zero); } //


static joy essay(num word, numnums& qbfs, nums& phrase) { // architecture of written high level thought
when(word==env::N())return;
when(qbfs.size() == zero) { allqbfs::publish(phrase); return; }
numnums left; numnums right; split(word, qbfs, left, right); essay(word + one, left, phrase);
phrase.add(word); essay(word + one, right, phrase); phrase.slop(); }
static joy wisdom(FILE* logfile, numnums& qclauses)
{for (num j = one; j < qforms.size() + one; j++) { //
fprin(logfile, "\n"); nums& phrase = (*qforms[minus(qforms.size(), j)]); num s = phrase.size(); //
for (num g = one; g < one + s; g++) { fprin(logfile, "%u ", (one + phrase[minus(s, g)])); } fprin(logfile, "0"); } } //
};// tau three is sev//fifty lines //
numnums allqbfs::solutions; // sev is thirdtau three is second
set<allqbfs*> allqbfs::qvars; //
numnums allqbfs::qforms; //
FILE* dotlog() { FILE* ret = (FILE*)zero; fopen_s( &ret, "numsat.log", "a+"); return ret; }//stringletteraplus

Daniel Pehoushek

unread,
Oct 7, 2022, 4:39:36 AMOct 7
to
notice that
the general intelligence algorithm
takes linear space and linear time
transforming models into questions
then the printed wisdom requires
quadratic time to produce
monotone conjunctive normal form
by emulating the publishing industry algorithm
daniel2380+++
Reply all
Reply to author
Forward
0 new messages