linear transform from pspace to qspace solver bob

[Daniel Pehoushek]

this allqbfs class solves all qbfs of an original formula.
There is a linear transformation from satisfiable solutions.
posted for posterity.
daniel2380

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 //
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; //

[Daniel Pehoushek]

a major conclusion is
clause learning is wrong
bob has a very bounded linear interpretation
of significant possible clauses.
the ordinary bound is 8m+2m clauses.
this admits 3 trillion inferences per day.
daniel2380++

[Greta Baine]

Get a brain.

[Daniel Pehoushek]

there are several big issues with clause learning when counting models
the learned clauses violate subtle tree ordering conditions and
those are unaccounted for in implementations
the size and correctness of databases when doing decomposition
makes for erroneous model counting results

so clause learning is wrong
that is big news to the satisfiability committee
daniel2380++

[Daniel Pehoushek]

if i could
send four words
back in time
i would choose these
monotone qbf is linear
daniel2380++

[Daniel Pehoushek]

five words would be these
all monotone qbfs are linear

avoid negation and be well
daniel2380++

[Greta Baine]

On 8/5/2022 7:03 AM, Daniel Pehoushek wrote:
> On Thursday, July 28, 2022 at 7:27:20 AM UTC-4, Daniel Pehoushek wrote:
>> On Wednesday, July 20, 2022 at 12:06:00 PM UTC-4, Daniel Pehoushek wrote:
>>> On Thursday, July 14, 2022 at 11:10:36 AM UTC-4, Greta Baine wrote:
>>>> On 7/14/2022 4:34 AM, Daniel Pehoushek wrote:
>>>>> a major conclusion is

But why no brain?

[Daniel Pehoushek]

why so brain i bet they made god without these words

five words would be these

all monotone qbfs are linear ?

if i could send four words back in time ?x?
would wood be monotone

i would choose these
monotone qbf is linear ?

three would be
linear monotone qbf ?

two are
monotone qbf ?

one
monotone ?

then ask what are ?
linear sized qbfs any way ?
are they words
too or two or to ? yes too true too for nsa cia kgb mix
i crush your right testicle and let it go free //jdp
daniel2380++

[Daniel Pehoushek]

theorem of cognition
five words back in time

all monotone qbfs are linear