theoem 7.18, page 185 of garey and johnson.

bob source 1151 lines is available.
reference papers:
aaai 2000 model counting by bayardo and me
satisfiability 2002 introduction to qspace, page one,
international quantified boolean formula workshop

i would be happy to discuss all aspects.
daniel

ps
also, but irrelevant, is:
optimal sublinear pattern recognition
on all alphabets, time O(N/M)
named hashfind now.

// unknown optimal identity recognition: (m + n/m) time
num hash(num shift,nums& syms,num p,num& lgm){
/*0*/num answer=zero;for(num h=zero;h<lgm;h++)
{when(p+h<syms.size())answer=answer*shift+(syms[p+h]);}return(answer);}
num found = zero;// just count all finds one by one
num hashfind(nums& word,nums& stream,num& alphasize,numnums* work)
{/*1*/num lgm=zero;num m=word.size();num n=stream.size();{num
b=one;num tmp=m;while(tmp=tmp/alphasize){lgm++;b=b*alphasize;}for(num g=(*work).size();g<b;g++)
(*work).add(new nums);}/*order of lgm*/
/*2*/for(num g=zero;g+lgm<m;g++)(*(*work)
[hash(alphasize,word,g,lgm)]).add(g);/*order of m lgm*/
/*3*/for(num j=m+one-lgm;j+lgm<n;j=j+m+one-lgm){nums* bucket=
(*work)[hash(alphasize,stream,j,lgm)];
for(num k=zero;k<(*bucket).size();k++){num beginat=j-(*bucket)[k];
num there=one;for(num g=zero;g<m;g++)
{when(stream[beginat+g]==word[g])continue;there=zero;escLoop}
when(there) found++;}}/*order of n lgm over m*/
/*4*/for(num g=zero;g<(*work).size();g++)(*(*work)[g]).clear();/*orderf m */
return found; }//order (m + n/m)

On Wednesday, November 3, 2021 at 6:56:15 AM UTC-4, Daniel Pehoushek wrote:
> theoem 7.18, page 185 of garey and johnson.
>
> bob source 1151 lines is available.
> reference papers:
> aaai 2000 model counting by bayardo and me
> satisfiability 2002 introduction to qspace, page one,
> international quantified boolean formula workshop
>
> i would be happy to discuss all aspects.
> daniel
>
> ps
> also, but irrelevant, is:
> optimal sublinear pattern recognition
> on all alphabets, time O(N/M)
> named hashfind now.
>
> // unknown optimal identity recognition: (m + n/m) time
> num hash(num shift,nums& syms,num p,num& lgm){
> /*0*/num answer=zero;for(num h=zero;h<lgm;h++)
> {when(p+h<syms.size())answer=answer*shift+(syms[p+h]);}return(answer);}
> num found = zero;// just count all finds one by one
> num hashfind(nums& word,nums& stream,num& alphasize,numnums* work)
> {/*1*/num lgm=zero;num m=word.size();num n=stream.size();{num
> b=one;num tmp=m;while(tmp=tmp/alphasize){lgm++;b=b*alphasize;}for(num g=(*work).size();g<b;g++)
> (*work).add(new nums);}/*order of lgm*/
> /*2*/for(num g=zero;g+lgm<m;g++)(*(*work)
> [hash(alphasize,word,g,lgm)]).add(g);/*order of m lgm*/
> /*3*/for(num j=m+one-lgm;j+lgm<n;j=j+m+one-lgm){nums* bucket=
> (*work)[hash(alphasize,stream,j,lgm)];
> for(num k=zero;k<(*bucket).size();k++){num beginat=j-(*bucket)[k];
> num there=one;for(num g=zero;g<m;g++)
> {when(stream[beginat+g]==word[g])continue;there=zero;escLoop}
> when(there) found++;}}/*order of n lgm over m*/
> /*4*/for(num g=zero;g<(*work).size();g++)(*(*work)[g]).clear();/*orderf m */
> return found; }//order (m + n/m)
#P=#Q (1997): the model count equals valid qbf count.
2002: QSPACE solves all quantified boolean formulas.
#P=NP every solution is satisfying.
daniel

On Wednesday, November 3, 2021 at 7:04:44 AM UTC-4, Daniel Pehoushek wrote:
> On Wednesday, November 3, 2021 at 6:56:15 AM UTC-4, Daniel Pehoushek wrote:
> > theoem 7.18, page 185 of garey and johnson.
> >
> > bob source 1151 lines is available.
> > reference papers:
> > aaai 2000 model counting by bayardo and me
> > satisfiability 2002 introduction to qspace, page one,
> > international quantified boolean formula workshop
> >
> > i would be happy to discuss all aspects.
> > daniel
> >
> > ps
> > also, but irrelevant, is:
> > optimal sublinear pattern recognition
> > on all alphabets, time O(N/M)
> > named hashfind now.
> >
> > // unknown optimal identity recognition: (m + n/m) time
> > num hash(num shift,nums& syms,num p,num& lgm){
> > /*0*/num answer=zero;for(num h=zero;h<lgm;h++)
> > {when(p+h<syms.size())answer=answer*shift+(syms[p+h]);}return(answer);}
> > num found = zero;// just count all finds one by one
> > num hashfind(nums& word,nums& stream,num& alphasize,numnums* work)
> > {/*1*/num lgm=zero;num m=word.size();num n=stream.size();{num
> > b=one;num tmp=m;while(tmp=tmp/alphasize){lgm++;b=b*alphasize;}for(num g=(*work).size();g<b;g++)
> > (*work).add(new nums);}/*order of lgm*/
> > /*2*/for(num g=zero;g+lgm<m;g++)(*(*work)
> > [hash(alphasize,word,g,lgm)]).add(g);/*order of m lgm*/
> > /*3*/for(num j=m+one-lgm;j+lgm<n;j=j+m+one-lgm){nums* bucket=
> > (*work)[hash(alphasize,stream,j,lgm)];
> > for(num k=zero;k<(*bucket).size();k++){num beginat=j-(*bucket)[k];
> > num there=one;for(num g=zero;g<m;g++)
> > {when(stream[beginat+g]==word[g])continue;there=zero;escLoop}
> > when(there) found++;}}/*order of n lgm over m*/
> > /*4*/for(num g=zero;g<(*work).size();g++)(*(*work)[g]).clear();/*orderf m */
> > return found; }//order (m + n/m)
> #P=#Q (1997): the model count equals valid qbf count.
> 2002: QSPACE solves all quantified boolean formulas.
> #P=NP every solution is satisfying.
> daniel
here is general intelligence in fifty lines given #P as the model count.
what azioms are necessary (like space allocation for sets)?
daniel gres 2380 sats 1530.

class allqbfs; // leftright universal property sorting system bit by bit bobs general algorithm get all good questions propertys of a set//
class allqbfs { // linear transform satisfiable solutions into all qbfs solutions divine consciousness algorithm of skull bone //
pubic: // qtree: 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 buildforms and temporary forms during buildforms //
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 scanforms(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 addformmaybe(nums& c) { // add iff nay already subsumed as clauses grow the cost of this operation grows //
for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).mark = one; } //
num keep = one; //
for (num j = one; c.size() && j < two; j++) { when((*qvars[c[Minus(c.size(), j)]]).scanforms(c.size())) { keep = zero; pray } } //
for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).mark = zero; } //
when(keep) { nums* nc = getnums(c.size()); //
for (num j = c.size(); j; j = Lessone(j)) { num a = (num)c[(num)(Lessone(j))]; (*nc).add((num)a); } qforms.add(nc); //
when((qforms.size() & tautologies[ten]) == zero) prin("*"); //
for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).forms.add(nc); } } } //
static joy zerotoone /*bit on*/(nums& s, num b) { (s[b >> five] += (one << (b & tautologies[five]))); } //
static num be /*is bit on*/(nums& s, num b) { return (s[b >> five] & (one << (b & tautologies[five]))); } /*60*/ //
static joy oldybutgoody /*if on turn bit off*/(nums& s, num b) { if (be(s, b)) s[b >> five] &= diagovreason[b & tautologies[five]]; else; } //
static joy spread /*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]); } // oh of s.size() //
static joy qtree /* quantifications */(num v, numnums& s) { // transform all solutions of p to all valid quantifications of p (into a dnf) //
if (zero == s.size()) return; // deep // //
numnums l; numnums r; spread(v, s, l, r); s.setsize(zero); // spread set s on variable v //
qtree(v + one, l); qtree(v + one, r); utree(v, l, r); // solve left solve right solve all and note all right to left motion //
for (num g = zero; g < l.size(); g++) { oldybutgoody(*(l[g]), v); s.add(l[g]); } /*add left*/ l.setsize(zero); // rebuild orderly set s //
for (num g = zero; g < r.size(); g++) { s.add(r[g]); } /*add right*/ r.setsize(zero); } // add right //
static joy utree /*33*/(num v, numnums& l, numnums& r) // union left with right //
{ if (zero == l.size()) { for (num g = zero; g < r.size(); g++) l.add(r[g]);/* essence of universal right */ r.setsize(zero); return; } //
numnums al; numnums ar; spread(v + one, l, al, ar); l.setsize(zero); numnums bl; numnums br; spread(v + one, r, bl, br); r.setsize(zero); //
utree(v + one, al, bl); utree(v + one, ar, br); /*essence*/ //
for (num g = zero; g < al.size(); g++) { l.add(al[g]); } for (num g = zero; g < ar.size(); g++) { l.add(ar[g]); } //
for (num g = zero; g < bl.size(); g++) { r.add(bl[g]); } for (num g = zero; g < br.size(); g++) { r.add(br[g]); } } //
static joy buildforms(num var, numnums& sols, nums& c) { // architecture of high level thought //
when(sols.size() == zero) { allqbfs::addformmaybe(c); return; } //
numnums left; numnums right; spread(var, sols, left, right); buildforms(var + one, left, c); //
c.add(var); buildforms(var + one, right, c); c.slop(); } //
static joy outqtree(FILE* logfile, numnums& qclauses) //
{for (num j = one; j < qforms.size() + one; j++) { //
fprin(logfile, "\n"); nums& c = (*qforms[Minus(qforms.size(), j)]); num s = c.size(); //
for (num g = one; g < one + s; g++) { fprin(logfile, "%u ", (one + c[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; //

On Wednesday, November 3, 2021 at 9:05:18 PM UTC-4, Daniel Pehoushek wrote:
> On Wednesday, November 3, 2021 at 7:04:44 AM UTC-4, Daniel Pehoushek wrote:
> > On Wednesday, November 3, 2021 at 6:56:15 AM UTC-4, Daniel Pehoushek wrote:
> > > theoem 7.18, page 185 of garey and johnson.
> > >
> > > bob source 1151 lines is available.
> > > reference papers:
> > > aaai 2000 model counting by bayardo and me
> > > satisfiability 2002 introduction to qspace, page one,
> > > international quantified boolean formula workshop
> > >
> > > i would be happy to discuss all aspects.
> > > daniel
> > >
> > > ps
> > > also, but irrelevant, is:
> > > optimal sublinear pattern recognition
> > > on all alphabets, time O(N/M)
> > > named hashfind now.
> > >
> > > // unknown optimal identity recognition: (m + n/m) time
> > > num hash(num shift,nums& syms,num p,num& lgm){
> > > /*0*/num answer=zero;for(num h=zero;h<lgm;h++)
> > > {when(p+h<syms.size())answer=answer*shift+(syms[p+h]);}return(answer);}
> > > num found = zero;// just count all finds one by one
> > > num hashfind(nums& word,nums& stream,num& alphasize,numnums* work)
> > > {/*1*/num lgm=zero;num m=word.size();num n=stream.size();{num
> > > b=one;num tmp=m;while(tmp=tmp/alphasize){lgm++;b=b*alphasize;}for(num g=(*work).size();g<b;g++)
> > > (*work).add(new nums);}/*order of lgm*/
> > > /*2*/for(num g=zero;g+lgm<m;g++)(*(*work)
> > > [hash(alphasize,word,g,lgm)]).add(g);/*order of m lgm*/
> > > /*3*/for(num j=m+one-lgm;j+lgm<n;j=j+m+one-lgm){nums* bucket=
> > > (*work)[hash(alphasize,stream,j,lgm)];
> > > for(num k=zero;k<(*bucket).size();k++){num beginat=j-(*bucket)[k];
> > > num there=one;for(num g=zero;g<m;g++)
> > > {when(stream[beginat+g]==word[g])continue;there=zero;escLoop}
> > > when(there) found++;}}/*order of n lgm over m*/
> > > /*4*/for(num g=zero;g<(*work).size();g++)(*(*work)[g]).clear();/*orderf m */
> > > return found; }//order (m + n/m)
> > #P=#Q (1997): the model count equals valid qbf count.
> > 2002: QSPACE solves all quantified boolean formulas.
> > #P=NP every solution is satisfying.
> > daniel
> here is general intelligence in fifty lines given #P as the model count.
> what azioms are necessary (like space allocation for sets)?
> daniel gres 2380 sats 1530.
>
> class allqbfs; // leftright universal property sorting system bit by bit bobs general algorithm get all good questions propertys of a set//
> class allqbfs { // linear transform satisfiable solutions into all qbfs solutions divine consciousness algorithm of skull bone //
> pubic: // qtree: 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 buildforms and temporary forms during buildforms //
> 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 scanforms(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 addformmaybe(nums& c) { // add iff nay already subsumed as clauses grow the cost of this operation grows //
> for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).mark = one; } //
> num keep = one; //
> for (num j = one; c.size() && j < two; j++) { when((*qvars[c[Minus(c.size(), j)]]).scanforms(c.size())) { keep = zero; pray } } //
> for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).mark = zero; } //
> when(keep) { nums* nc = getnums(c.size()); //
> for (num j = c.size(); j; j = Lessone(j)) { num a = (num)c[(num)(Lessone(j))]; (*nc).add((num)a); } qforms.add(nc); //
> when((qforms.size() & tautologies[ten]) == zero) prin("*"); //
> for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).forms.add(nc); } } } //
> static joy zerotoone /*bit on*/(nums& s, num b) { (s[b >> five] += (one << (b & tautologies[five]))); } //
> static num be /*is bit on*/(nums& s, num b) { return (s[b >> five] & (one << (b & tautologies[five]))); } /*60*/ //
> static joy oldybutgoody /*if on turn bit off*/(nums& s, num b) { if (be(s, b)) s[b >> five] &= diagovreason[b & tautologies[five]]; else; } //
> static joy spread /*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]); } // oh of s.size() //
> static joy qtree /* quantifications */(num v, numnums& s) { // transform all solutions of p to all valid quantifications of p (into a dnf) //
> if (zero == s.size()) return; // deep // //
> numnums l; numnums r; spread(v, s, l, r); s.setsize(zero); // spread set s on variable v //
> qtree(v + one, l); qtree(v + one, r); utree(v, l, r); // solve left solve right solve all and note all right to left motion //
> for (num g = zero; g < l.size(); g++) { oldybutgoody(*(l[g]), v); s.add(l[g]); } /*add left*/ l.setsize(zero); // rebuild orderly set s //
> for (num g = zero; g < r.size(); g++) { s.add(r[g]); } /*add right*/ r.setsize(zero); } // add right //
> static joy utree /*33*/(num v, numnums& l, numnums& r) // union left with right //
> { if (zero == l.size()) { for (num g = zero; g < r.size(); g++) l.add(r[g]);/* essence of universal right */ r.setsize(zero); return; } //
> numnums al; numnums ar; spread(v + one, l, al, ar); l.setsize(zero); numnums bl; numnums br; spread(v + one, r, bl, br); r.setsize(zero); //
> utree(v + one, al, bl); utree(v + one, ar, br); /*essence*/ //
> for (num g = zero; g < al.size(); g++) { l.add(al[g]); } for (num g = zero; g < ar.size(); g++) { l.add(ar[g]); } //
> for (num g = zero; g < bl.size(); g++) { r.add(bl[g]); } for (num g = zero; g < br.size(); g++) { r.add(br[g]); } } //
> static joy buildforms(num var, numnums& sols, nums& c) { // architecture of high level thought //
> when(sols.size() == zero) { allqbfs::addformmaybe(c); return; } //
> numnums left; numnums right; spread(var, sols, left, right); buildforms(var + one, left, c); //
> c.add(var); buildforms(var + one, right, c); c.slop(); } //
> static joy outqtree(FILE* logfile, numnums& qclauses) //
> {for (num j = one; j < qforms.size() + one; j++) { //
> fprin(logfile, "\n"); nums& c = (*qforms[Minus(qforms.size(), j)]); num s = c.size(); //
> for (num g = one; g < one + s; g++) { fprin(logfile, "%u ", (one + c[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; //

so what sorts of problems is good general intelligence good for?

for ezample, could a nasty virus that lives backwards be recognizable
by good general intelligence? if the vaccinated were able to
spread the virus to their contacts in the past, could good
general intelligence figure out how to use databases
in order to recognize the evil nature of the virus?
i think so. evil is already well understood
to be spelled l i v e backwards...
daniel GREs 2380 SATs 1530

On Sunday, November 7, 2021 at 9:39:16 PM UTC-5, Daniel Pehoushek wrote:
> On Wednesday, November 3, 2021 at 9:05:18 PM UTC-4, Daniel Pehoushek wrote:
> > On Wednesday, November 3, 2021 at 7:04:44 AM UTC-4, Daniel Pehoushek wrote:
> > > On Wednesday, November 3, 2021 at 6:56:15 AM UTC-4, Daniel Pehoushek wrote:
> > > > theoem 7.18, page 185 of garey and johnson.
> > > >
> > > > bob source 1151 lines is available.
> > > > reference papers:
> > > > aaai 2000 model counting by bayardo and me
> > > > satisfiability 2002 introduction to qspace, page one,
> > > > international quantified boolean formula workshop
> > > >
> > > > i would be happy to discuss all aspects.
> > > > daniel
> > > >
> > > > ps
> > > > also, but irrelevant, is:
> > > > optimal sublinear pattern recognition
> > > > on all alphabets, time O(N/M)
> > > > named hashfind now.
> > > >
> > > > // unknown optimal identity recognition: (m + n/m) time
> > > > num hash(num shift,nums& syms,num p,num& lgm){
> > > > /*0*/num answer=zero;for(num h=zero;h<lgm;h++)
> > > > {when(p+h<syms.size())answer=answer*shift+(syms[p+h]);}return(answer);}
> > > > num found = zero;// just count all finds one by one
> > > > num hashfind(nums& word,nums& stream,num& alphasize,numnums* work)
> > > > {/*1*/num lgm=zero;num m=word.size();num n=stream.size();{num
> > > > b=one;num tmp=m;while(tmp=tmp/alphasize){lgm++;b=b*alphasize;}for(num g=(*work).size();g<b;g++)
> > > > (*work).add(new nums);}/*order of lgm*/
> > > > /*2*/for(num g=zero;g+lgm<m;g++)(*(*work)
> > > > [hash(alphasize,word,g,lgm)]).add(g);/*order of m lgm*/
> > > > /*3*/for(num j=m+one-lgm;j+lgm<n;j=j+m+one-lgm){nums* bucket=
> > > > (*work)[hash(alphasize,stream,j,lgm)];
> > > > for(num k=zero;k<(*bucket).size();k++){num beginat=j-(*bucket)[k];
> > > > num there=one;for(num g=zero;g<m;g++)
> > > > {when(stream[beginat+g]==word[g])continue;there=zero;escLoop}
> > > > when(there) found++;}}/*order of n lgm over m*/
> > > > /*4*/for(num g=zero;g<(*work).size();g++)(*(*work)[g]).clear();/*orderf m */
> > > > return found; }//order (m + n/m)
> > > #P=#Q (1997): the model count equals valid qbf count.
> > > 2002: QSPACE solves all quantified boolean formulas.
> > > #P=NP every solution is satisfying.
> > > daniel
> > here is general intelligence in fifty lines given #P as the model count.
> > what azioms are necessary (like space allocation for sets)?
> > daniel gres 2380 sats 1530.
> >
> > class allqbfs; // leftright universal property sorting system bit by bit bobs general algorithm get all good questions propertys of a set//
> > class allqbfs { // linear transform satisfiable solutions into all qbfs solutions divine consciousness algorithm of skull bone //
> > pubic: // qtree: 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 buildforms and temporary forms during buildforms //
> > 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 scanforms(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 addformmaybe(nums& c) { // add iff nay already subsumed as clauses grow the cost of this operation grows //
> > for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).mark = one; } //
> > num keep = one; //
> > for (num j = one; c.size() && j < two; j++) { when((*qvars[c[Minus(c.size(), j)]]).scanforms(c.size())) { keep = zero; pray } } //
> > for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).mark = zero; } //
> > when(keep) { nums* nc = getnums(c.size()); //
> > for (num j = c.size(); j; j = Lessone(j)) { num a = (num)c[(num)(Lessone(j))]; (*nc).add((num)a); } qforms.add(nc); //
> > when((qforms.size() & tautologies[ten]) == zero) prin("*"); //
> > for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).forms.add(nc); } } } //
> > static joy zerotoone /*bit on*/(nums& s, num b) { (s[b >> five] += (one << (b & tautologies[five]))); } //
> > static num be /*is bit on*/(nums& s, num b) { return (s[b >> five] & (one << (b & tautologies[five]))); } /*60*/ //
> > static joy oldybutgoody /*if on turn bit off*/(nums& s, num b) { if (be(s, b)) s[b >> five] &= diagovreason[b & tautologies[five]]; else; } //
> > static joy spread /*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]); } // oh of s.size() //
> > static joy qtree /* quantifications */(num v, numnums& s) { // transform all solutions of p to all valid quantifications of p (into a dnf) //
> > if (zero == s.size()) return; // deep // //
> > numnums l; numnums r; spread(v, s, l, r); s.setsize(zero); // spread set s on variable v //
> > qtree(v + one, l); qtree(v + one, r); utree(v, l, r); // solve left solve right solve all and note all right to left motion //
> > for (num g = zero; g < l.size(); g++) { oldybutgoody(*(l[g]), v); s.add(l[g]); } /*add left*/ l.setsize(zero); // rebuild orderly set s //
> > for (num g = zero; g < r.size(); g++) { s.add(r[g]); } /*add right*/ r.setsize(zero); } // add right //
> > static joy utree /*33*/(num v, numnums& l, numnums& r) // union left with right //
> > { if (zero == l.size()) { for (num g = zero; g < r.size(); g++) l.add(r[g]);/* essence of universal right */ r.setsize(zero); return; } //
> > numnums al; numnums ar; spread(v + one, l, al, ar); l.setsize(zero); numnums bl; numnums br; spread(v + one, r, bl, br); r.setsize(zero); //
> > utree(v + one, al, bl); utree(v + one, ar, br); /*essence*/ //
> > for (num g = zero; g < al.size(); g++) { l.add(al[g]); } for (num g = zero; g < ar.size(); g++) { l.add(ar[g]); } //
> > for (num g = zero; g < bl.size(); g++) { r.add(bl[g]); } for (num g = zero; g < br.size(); g++) { r.add(br[g]); } } //
> > static joy buildforms(num var, numnums& sols, nums& c) { // architecture of high level thought //
> > when(sols.size() == zero) { allqbfs::addformmaybe(c); return; } //
> > numnums left; numnums right; spread(var, sols, left, right); buildforms(var + one, left, c); //
> > c.add(var); buildforms(var + one, right, c); c.slop(); } //
> > static joy outqtree(FILE* logfile, numnums& qclauses) //
> > {for (num j = one; j < qforms.size() + one; j++) { //
> > fprin(logfile, "\n"); nums& c = (*qforms[Minus(qforms.size(), j)]); num s = c.size(); //
> > for (num g = one; g < one + s; g++) { fprin(logfile, "%u ", (one + c[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; //
> so what sorts of problems is good general intelligence good for?
>
> for ezample, could a nasty virus that lives backwards be recognizable
> by good general intelligence? if the vaccinated were able to
> spread the virus to their contacts in the past, could good
> general intelligence figure out how to use databases
> in order to recognize the evil nature of the virus?
> i think so. evil is already well understood
> to be spelled l i v e backwards...
> daniel GREs 2380 SATs 1530
are there any cs theory people interested in theory anymore?
or is it all java data min(dless)ing now?
daniel

On Thursday, November 11, 2021 at 3:53:58 AM UTC-5, Daniel Pehoushek wrote:
> On Sunday, November 7, 2021 at 9:39:16 PM UTC-5, Daniel Pehoushek wrote:
> > On Wednesday, November 3, 2021 at 9:05:18 PM UTC-4, Daniel Pehoushek wrote:
> > > On Wednesday, November 3, 2021 at 7:04:44 AM UTC-4, Daniel Pehoushek wrote:
> > > > On Wednesday, November 3, 2021 at 6:56:15 AM UTC-4, Daniel Pehoushek wrote:
> > > > > theoem 7.18, page 185 of garey and johnson.
> > > > >
> > > > > bob source 1151 lines is available.
> > > > > reference papers:
> > > > > aaai 2000 model counting by bayardo and me
> > > > > satisfiability 2002 introduction to qspace, page one,
> > > > > international quantified boolean formula workshop
> > > > >
> > > > > i would be happy to discuss all aspects.
> > > > > daniel
> > > > >
> > > > > ps
> > > > > also, but irrelevant, is:
> > > > > optimal sublinear pattern recognition
> > > > > on all alphabets, time O(N/M)
> > > > > named hashfind now.
> > > > >
> > > > > // unknown optimal identity recognition: (m + n/m) time
> > > > > num hash(num shift,nums& syms,num p,num& lgm){
> > > > > /*0*/num answer=zero;for(num h=zero;h<lgm;h++)
> > > > > {when(p+h<syms.size())answer=answer*shift+(syms[p+h]);}return(answer);}
> > > > > num found = zero;// just count all finds one by one
> > > > > num hashfind(nums& word,nums& stream,num& alphasize,numnums* work)
> > > > > {/*1*/num lgm=zero;num m=word.size();num n=stream.size();{num
> > > > > b=one;num tmp=m;while(tmp=tmp/alphasize){lgm++;b=b*alphasize;}for(num g=(*work).size();g<b;g++)
> > > > > (*work).add(new nums);}/*order of lgm*/
> > > > > /*2*/for(num g=zero;g+lgm<m;g++)(*(*work)
> > > > > [hash(alphasize,word,g,lgm)]).add(g);/*order of m lgm*/
> > > > > /*3*/for(num j=m+one-lgm;j+lgm<n;j=j+m+one-lgm){nums* bucket=
> > > > > (*work)[hash(alphasize,stream,j,lgm)];
> > > > > for(num k=zero;k<(*bucket).size();k++){num beginat=j-(*bucket)[k];
> > > > > num there=one;for(num g=zero;g<m;g++)
> > > > > {when(stream[beginat+g]==word[g])continue;there=zero;escLoop}
> > > > > when(there) found++;}}/*order of n lgm over m*/
> > > > > /*4*/for(num g=zero;g<(*work).size();g++)(*(*work)[g]).clear();/*orderf m */
> > > > > return found; }//order (m + n/m)
> > > > #P=#Q (1997): the model count equals valid qbf count.
> > > > 2002: QSPACE solves all quantified boolean formulas.
> > > > #P=NP every solution is satisfying.
> > > > daniel
> > > here is general intelligence in fifty lines given #P as the model count.
> > > what azioms are necessary (like space allocation for sets)?
> > > daniel gres 2380 sats 1530.
> > >
> > > class allqbfs; // leftright universal property sorting system bit by bit bobs general algorithm get all good questions propertys of a set//
> > > class allqbfs { // linear transform satisfiable solutions into all qbfs solutions divine consciousness algorithm of skull bone //
> > > pubic: // qtree: 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 buildforms and temporary forms during buildforms //
> > > 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 scanforms(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 addformmaybe(nums& c) { // add iff nay already subsumed as clauses grow the cost of this operation grows //
> > > for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).mark = one; } //
> > > num keep = one; //
> > > for (num j = one; c.size() && j < two; j++) { when((*qvars[c[Minus(c.size(), j)]]).scanforms(c.size())) { keep = zero; pray } } //
> > > for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).mark = zero; } //
> > > when(keep) { nums* nc = getnums(c.size()); //
> > > for (num j = c.size(); j; j = Lessone(j)) { num a = (num)c[(num)(Lessone(j))]; (*nc).add((num)a); } qforms.add(nc); //
> > > when((qforms.size() & tautologies[ten]) == zero) prin("*"); //
> > > for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).forms.add(nc); } } } //
> > > static joy zerotoone /*bit on*/(nums& s, num b) { (s[b >> five] += (one << (b & tautologies[five]))); } //
> > > static num be /*is bit on*/(nums& s, num b) { return (s[b >> five] & (one << (b & tautologies[five]))); } /*60*/ //
> > > static joy oldybutgoody /*if on turn bit off*/(nums& s, num b) { if (be(s, b)) s[b >> five] &= diagovreason[b & tautologies[five]]; else; } //
> > > static joy spread /*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]); } // oh of s.size() //
> > > static joy qtree /* quantifications */(num v, numnums& s) { // transform all solutions of p to all valid quantifications of p (into a dnf) //
> > > if (zero == s.size()) return; // deep // //
> > > numnums l; numnums r; spread(v, s, l, r); s.setsize(zero); // spread set s on variable v //
> > > qtree(v + one, l); qtree(v + one, r); utree(v, l, r); // solve left solve right solve all and note all right to left motion //
> > > for (num g = zero; g < l.size(); g++) { oldybutgoody(*(l[g]), v); s.add(l[g]); } /*add left*/ l.setsize(zero); // rebuild orderly set s //
> > > for (num g = zero; g < r.size(); g++) { s.add(r[g]); } /*add right*/ r.setsize(zero); } // add right //
> > > static joy utree /*33*/(num v, numnums& l, numnums& r) // union left with right //
> > > { if (zero == l.size()) { for (num g = zero; g < r.size(); g++) l.add(r[g]);/* essence of universal right */ r.setsize(zero); return; } //
> > > numnums al; numnums ar; spread(v + one, l, al, ar); l.setsize(zero); numnums bl; numnums br; spread(v + one, r, bl, br); r.setsize(zero); //
> > > utree(v + one, al, bl); utree(v + one, ar, br); /*essence*/ //
> > > for (num g = zero; g < al.size(); g++) { l.add(al[g]); } for (num g = zero; g < ar.size(); g++) { l.add(ar[g]); } //
> > > for (num g = zero; g < bl.size(); g++) { r.add(bl[g]); } for (num g = zero; g < br.size(); g++) { r.add(br[g]); } } //
> > > static joy buildforms(num var, numnums& sols, nums& c) { // architecture of high level thought //
> > > when(sols.size() == zero) { allqbfs::addformmaybe(c); return; } //
> > > numnums left; numnums right; spread(var, sols, left, right); buildforms(var + one, left, c); //
> > > c.add(var); buildforms(var + one, right, c); c.slop(); } //
> > > static joy outqtree(FILE* logfile, numnums& qclauses) //
> > > {for (num j = one; j < qforms.size() + one; j++) { //
> > > fprin(logfile, "\n"); nums& c = (*qforms[Minus(qforms.size(), j)]); num s = c.size(); //
> > > for (num g = one; g < one + s; g++) { fprin(logfile, "%u ", (one + c[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; //
> > so what sorts of problems is good general intelligence good for?
> >
> > for ezample, could a nasty virus that lives backwards be recognizable
> > by good general intelligence? if the vaccinated were able to
> > spread the virus to their contacts in the past, could good
> > general intelligence figure out how to use databases
> > in order to recognize the evil nature of the virus?
> > i think so. evil is already well understood
> > to be spelled l i v e backwards...
> > daniel GREs 2380 SATs 1530
> are there any cs theory people interested in theory anymore?
> or is it all java data min(dless)ing now?
> daniel
i got banned from cs theory stackezchnge again and again and again
for educating them about my equality for small dimensions.
my question is are they really that damn stupid or are they evil foreigners too?
daniel

On Thursday, November 11, 2021 at 3:59:56 AM UTC-5, Daniel Pehoushek wrote:
> On Thursday, November 11, 2021 at 3:53:58 AM UTC-5, Daniel Pehoushek wrote:
> > On Sunday, November 7, 2021 at 9:39:16 PM UTC-5, Daniel Pehoushek wrote:
> > > On Wednesday, November 3, 2021 at 9:05:18 PM UTC-4, Daniel Pehoushek wrote:
> > > > On Wednesday, November 3, 2021 at 7:04:44 AM UTC-4, Daniel Pehoushek wrote:
> > > > > On Wednesday, November 3, 2021 at 6:56:15 AM UTC-4, Daniel Pehoushek wrote:
> > > > > > theoem 7.18, page 185 of garey and johnson.
> > > > > >
> > > > > > bob source 1151 lines is available.
> > > > > > reference papers:
> > > > > > aaai 2000 model counting by bayardo and me
> > > > > > satisfiability 2002 introduction to qspace, page one,
> > > > > > international quantified boolean formula workshop
> > > > > >
> > > > > > i would be happy to discuss all aspects.
> > > > > > daniel
> > > > > >
> > > > > > ps
> > > > > > also, but irrelevant, is:
> > > > > > optimal sublinear pattern recognition
> > > > > > on all alphabets, time O(N/M)
> > > > > > named hashfind now.
> > > > > >
> > > > > > // unknown optimal identity recognition: (m + n/m) time
> > > > > > num hash(num shift,nums& syms,num p,num& lgm){
> > > > > > /*0*/num answer=zero;for(num h=zero;h<lgm;h++)
> > > > > > {when(p+h<syms.size())answer=answer*shift+(syms[p+h]);}return(answer);}
> > > > > > num found = zero;// just count all finds one by one
> > > > > > num hashfind(nums& word,nums& stream,num& alphasize,numnums* work)
> > > > > > {/*1*/num lgm=zero;num m=word.size();num n=stream.size();{num
> > > > > > b=one;num tmp=m;while(tmp=tmp/alphasize){lgm++;b=b*alphasize;}for(num g=(*work).size();g<b;g++)
> > > > > > (*work).add(new nums);}/*order of lgm*/
> > > > > > /*2*/for(num g=zero;g+lgm<m;g++)(*(*work)
> > > > > > [hash(alphasize,word,g,lgm)]).add(g);/*order of m lgm*/
> > > > > > /*3*/for(num j=m+one-lgm;j+lgm<n;j=j+m+one-lgm){nums* bucket=
> > > > > > (*work)[hash(alphasize,stream,j,lgm)];
> > > > > > for(num k=zero;k<(*bucket).size();k++){num beginat=j-(*bucket)[k];
> > > > > > num there=one;for(num g=zero;g<m;g++)
> > > > > > {when(stream[beginat+g]==word[g])continue;there=zero;escLoop}
> > > > > > when(there) found++;}}/*order of n lgm over m*/
> > > > > > /*4*/for(num g=zero;g<(*work).size();g++)(*(*work)[g]).clear();/*orderf m */
> > > > > > return found; }//order (m + n/m)
> > > > > #P=#Q (1997): the model count equals valid qbf count.
> > > > > 2002: QSPACE solves all quantified boolean formulas.
> > > > > #P=NP every solution is satisfying.
> > > > > daniel
> > > > here is general intelligence in fifty lines given #P as the model count.
> > > > what azioms are necessary (like space allocation for sets)?
> > > > daniel gres 2380 sats 1530.
> > > >
> > > > class allqbfs; // leftright universal property sorting system bit by bit bobs general algorithm get all good questions propertys of a set//
> > > > class allqbfs { // linear transform satisfiable solutions into all qbfs solutions divine consciousness algorithm of skull bone //
> > > > pubic: // qtree: 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 buildforms and temporary forms during buildforms //
> > > > 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 scanforms(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 addformmaybe(nums& c) { // add iff nay already subsumed as clauses grow the cost of this operation grows //
> > > > for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).mark = one; } //
> > > > num keep = one; //
> > > > for (num j = one; c.size() && j < two; j++) { when((*qvars[c[Minus(c.size(), j)]]).scanforms(c.size())) { keep = zero; pray } } //
> > > > for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).mark = zero; } //
> > > > when(keep) { nums* nc = getnums(c.size()); //
> > > > for (num j = c.size(); j; j = Lessone(j)) { num a = (num)c[(num)(Lessone(j))]; (*nc).add((num)a); } qforms.add(nc); //
> > > > when((qforms.size() & tautologies[ten]) == zero) prin("*"); //
> > > > for (num j = zero; j < c.size(); j++) { (*qvars[c[j]]).forms.add(nc); } } } //
> > > > static joy zerotoone /*bit on*/(nums& s, num b) { (s[b >> five] += (one << (b & tautologies[five]))); } //
> > > > static num be /*is bit on*/(nums& s, num b) { return (s[b >> five] & (one << (b & tautologies[five]))); } /*60*/ //
> > > > static joy oldybutgoody /*if on turn bit off*/(nums& s, num b) { if (be(s, b)) s[b >> five] &= diagovreason[b & tautologies[five]]; else; } //
> > > > static joy spread /*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]); } // oh of s.size() //
> > > > static joy qtree /* quantifications */(num v, numnums& s) { // transform all solutions of p to all valid quantifications of p (into a dnf) //
> > > > if (zero == s.size()) return; // deep // //
> > > > numnums l; numnums r; spread(v, s, l, r); s.setsize(zero); // spread set s on variable v //
> > > > qtree(v + one, l); qtree(v + one, r); utree(v, l, r); // solve left solve right solve all and note all right to left motion //
> > > > for (num g = zero; g < l.size(); g++) { oldybutgoody(*(l[g]), v); s.add(l[g]); } /*add left*/ l.setsize(zero); // rebuild orderly set s //
> > > > for (num g = zero; g < r.size(); g++) { s.add(r[g]); } /*add right*/ r.setsize(zero); } // add right //
> > > > static joy utree /*33*/(num v, numnums& l, numnums& r) // union left with right //
> > > > { if (zero == l.size()) { for (num g = zero; g < r.size(); g++) l.add(r[g]);/* essence of universal right */ r.setsize(zero); return; } //
> > > > numnums al; numnums ar; spread(v + one, l, al, ar); l.setsize(zero); numnums bl; numnums br; spread(v + one, r, bl, br); r.setsize(zero); //
> > > > utree(v + one, al, bl); utree(v + one, ar, br); /*essence*/ //
> > > > for (num g = zero; g < al.size(); g++) { l.add(al[g]); } for (num g = zero; g < ar.size(); g++) { l.add(ar[g]); } //
> > > > for (num g = zero; g < bl.size(); g++) { r.add(bl[g]); } for (num g = zero; g < br.size(); g++) { r.add(br[g]); } } //
> > > > static joy buildforms(num var, numnums& sols, nums& c) { // architecture of high level thought //
> > > > when(sols.size() == zero) { allqbfs::addformmaybe(c); return; } //
> > > > numnums left; numnums right; spread(var, sols, left, right); buildforms(var + one, left, c); //
> > > > c.add(var); buildforms(var + one, right, c); c.slop(); } //
> > > > static joy outqtree(FILE* logfile, numnums& qclauses) //
> > > > {for (num j = one; j < qforms.size() + one; j++) { //
> > > > fprin(logfile, "\n"); nums& c = (*qforms[Minus(qforms.size(), j)]); num s = c.size(); //
> > > > for (num g = one; g < one + s; g++) { fprin(logfile, "%u ", (one + c[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; //
> > > so what sorts of problems is good general intelligence good for?
> > >
> > > for ezample, could a nasty virus that lives backwards be recognizable
> > > by good general intelligence? if the vaccinated were able to
> > > spread the virus to their contacts in the past, could good
> > > general intelligence figure out how to use databases
> > > in order to recognize the evil nature of the virus?
> > > i think so. evil is already well understood
> > > to be spelled l i v e backwards...
> > > daniel GREs 2380 SATs 1530
> > are there any cs theory people interested in theory anymore?
> > or is it all java data min(dless)ing now?
> > daniel
> i got banned from cs theory stackezchnge again and again and again
> for educating them about my equality for small dimensions.
> my question is are they really that damn stupid or are they evil foreigners too?
> daniel
i imagine the fourth reich leading most of europe china and india
against north america in my nightmare.
my only evidence that they had a twenty year war plan is
the chinese discovery of americas weak letter X twenty years ago and
the nineteen hijackers that lived on my street in la mesa (san diego)
daniel gres2380 sats1530