// bob produces quality questions given good boolean models
// a set of honest boolean models goes in
// a set of honest questions comes out
// ten lines generally linear genius intelligence
joy qtree (num v, numnums& booleanmodels)
{ when (zero == booleanmodels.size()) return; numnums l; numnums r; spread(v, booleanmodels, l, r); booleanmodels.setsize(zero);
qtree(v + one, l); qtree(v + one, r); utree(v, l, r);
for (num g = zero; g < l.size(); g++) { onetozero(*(l[g]), v); booleanmodels.add(l[g]); } l.setsize(zero);
for (num g = zero; g < r.size(); g++) { booleanmodels.add(r[g]); } r.setsize(zero); }

joy utree (num v, numnums& l, numnums& r)
{ when (zero == l.size()) { for (num g = zero; g < r.size(); g++) l.add(r[g]); 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);
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]); } }

On 6/12/2022 2:23 PM, Daniel Pehoushek wrote:
> // bob produces quality questions given good boolean models
> // a set of honest boolean models goes in my bottom
> // a set of honest questions comes out my bottom
> // ten lines generally linear genius intelligence;
> joy qtree (num v, numnums& booleanmodels)

A_Brain() { // maybe false
get_one(soon);
}

On Sunday, June 12, 2022 at 11:35:40 PM UTC-4, Dave wrote:
> On 6/12/2022 2:23 PM, Daniel Pehoushek wrote:
> > // bob produces quality questions given good boolean models
> > // a set of honest boolean models goes in
> > // a set of honest questions comes out
> > // ten lines generally linear genius intelligence;
> > joy qtree (num v, numnums& booleanmodels)
> A_Brain() { // maybe false
> get_one(soon);
> }
dear dave
in 1983 i scored 800 verbal 800 math780 analytical for 2380/2400 on the GREs
with good reason fo skipping two questions (the ++)
i have worked on satisfiability for decades
solved it five years ago as good as it gets
daniel2380++

joy qtree (num v, numnums& booleanmodels)
{ when (zero == booleanmodels.size()) return; numnums l; numnums r; spread(v, booleanmodels, l, r); booleanmodels.setsize(zero);

qtree(v + one, l); qtree(v + one, r); utree(v, l, r);
// solve left right then patch up level v

for (num g = zero; g < l.size(); g++) { onetozero(*(l[g]), v); booleanmodels.add(l[g]); } l.setsize(zero);
for (num g = zero; g < r.size(); g++) { booleanmodels.add(r[g]); } r.setsize(zero); }

joy utree (num v, numnums& l, numnums& r)
{ when (zero == l.size()) { for (num g = zero; g < r.size(); g++) l.add(r[g]); 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);
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]); } }

On Monday, June 13, 2022 at 12:17:56 AM UTC-4, Daniel Pehoushek wrote:
> On Sunday, June 12, 2022 at 11:35:40 PM UTC-4, Dave wrote:
> > On 6/12/2022 2:23 PM, Daniel Pehoushek wrote:
> > > // bob produces quality questions given good boolean models
> > > // a set of honest boolean models goes in
> > > // a set of honest questions comes out
> > > // ten lines generally linear genius intelligence;
> > > joy qtree (num v, numnums& booleanmodels)
> > A_Brain() { // maybe false
> > get_one(soon);
> > }
> dear dave
> in 1983 i scored 800 verbal 800 math780 analytical for 2380/2400 on the GREs
> with good reason fo skipping two questions (the ++)
> i have worked on satisfiability for decades
> solved it five years ago as good as it gets
> daniel2380++
> joy qtree (num v, numnums& booleanmodels)
> { when (zero == booleanmodels.size()) return; numnums l; numnums r; spread(v, booleanmodels, l, r); booleanmodels.setsize(zero);
>
> qtree(v + one, l); qtree(v + one, r); utree(v, l, r);
> // solve left right then patch up level v
> for (num g = zero; g < l.size(); g++) { onetozero(*(l[g]), v); booleanmodels.add(l[g]); } l.setsize(zero);
> for (num g = zero; g < r.size(); g++) { booleanmodels.add(r[g]); } r.setsize(zero); }
>
> joy utree (num v, numnums& l, numnums& r)
> { when (zero == l.size()) { for (num g = zero; g < r.size(); g++) l.add(r[g]); 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);
> 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]); } }

ten lines general intelligence
information into questions

joy solveboth (num v, numnums& booleanmodels)
{ when (zero == booleanmodels.size()) return; numnums l; numnums r; spread(v, booleanmodels, l, r); booleanmodels.setsize(zero);
solveboth(v + one, l); solveboth(v + one, r); integrate(v, l, r);
for (num g = zero; g < l.size(); g++) { onetozero(*(l[g]), v); booleanmodels.add(l[g]); } l.setsize(zero);
for (num g = zero; g < r.size(); g++) { booleanmodels.add(r[g]); } r.setsize(zero); }

joy integrate (num v, numnums& l, numnums& r)
{ when (zero == l.size()) { for (num g = zero; g < r.size(); g++) l.add(r[g]); 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);
integrate (v + one, al, bl); integrate (v + one, ar, br);
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]); } }

daniel2380++

prepare the inquisition
a system f o r t h a t where
every answer must be truth

recursive but linear formulas
for (how to) (think well)
from right well to left well

from (n) models of information
into (n) models of true questions

linear transform
of bits of information
to bits of truthfully stated
questions

additionally there also ezists
the quadratic transform
to universal truths as
conjunctive monotone clausal forms of
deep wisdom presented as commonsense

monotone reason is linearly decided
every solution is satisfying (#p=np)
common sense is monotone

daniel2380++

joy zerotoone /*bit is on*/(nums& p, num b) { (p[b >> five] += (ones[b & fifthtau]));} //
num be /*is bit on*/(nums& p, num b) { return (p[b >> five] & (ones[b & fifthtau]));} //

joy ezis(nums& p, num b) { p[b >> five] &= zeroes[b & fifthtau]; } //a model ezists

joy spread /*leftright around bit*/(num b, numnums& p, numnums& l, numnums& r) // left right on bit b //
{for (num g = zero; g < p.size(); g++) if (be((*p[g]), b)) r.add(p[g]); else l.add(p[g]); } // oh of p.size() //

//takes in models p beginning at variable v zero
joy think (num v, numnums& p) { // transform all solutions of p to all valid quantifications of p (into a dnf) //
if (zero == p.size()) return; // deep // //
numnums l; numnums r; spread(v, p, l, r); p.setsize(zero); // spread set p on variable v //
think(v + one, l); think(v + one, r); weave(v, l, r); // solve left solve right solve all and note all right to left motion //
for (num g = zero; g < l.size(); g++) { ezis(*(l[g]), v); p.add(l[g]); } /*solved left*/ l.setsize(zero); // rebuild orderly set p //
for (num g = zero; g < r.size(); g++) { p.add(r[g]); } /*add right*/ r.setsize(zero); } // add right //
joy weave (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); //
weave (v + one, al, bl); weave (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]); } } //

On 6/19/2022 12:05 PM, Daniel Pehoushek wrote:
> prepare the inquisition
> a system f o r t h a t where
> every answer must be truth

Get a brain.

On Tuesday, June 21, 2022 at 8:27:53 PM UTC-4, Greta Baine wrote:
> On 6/19/2022 12:05 PM, Daniel Pehoushek wrote:
> > prepare the inquisition
> > a system f o r t h a t where
> > every answer must be truth
> Get a brain.
gre at brain

1983 GREs 2380++
800 math 800 verbal 780 analytical

bob transforms models of information into models of questions
the questions all have truthful answers

daniel2380++

On 6/22/2022 1:12 PM, Daniel Pehoushek wrote:

Get a brain soon.

On Wednesday, June 22, 2022 at 4:15:56 PM UTC-4, Greta Baine wrote:
> On 6/22/2022 1:12 PM, Daniel Pehoushek wrote:
>
> Get a brain soon.
does denigrating me boost your adrenaline or testosterone?
i have done good work on monotone reason.
what have you done on reason?
daniel2380++

// every bit is read just twice and written at most once
// linear transform all boolean models into all true questions
// one bit at a time
daniel2391++
static joy sort (num v, numnums& s) {
if (zero == s.size()) return; numnums l; numnums r; spread(v, s, l, r); s.setsize(zero);
sort (v+one, l); sort (v+one, r); think (v, l, r);
for(num g=zero;g<l.size();g++){ ezis (*(l[g]),v);s.add(l[g]);}l.setsize(zero);
for(num g=zero;g<r.size();g++){ univ (*(r[g]),v);s.add(r[g]);}r.setsize(zero); }
static joy think (num v, numnums& l, numnums& r) {
if (zero == l.size()) { for (num g = zero; g < r.size(); g++) l.add(r[g]); 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);
think (v+one,al,bl); think (v+one,ar,br);
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 zerotoone /*bit is on*/(nums& s, num b) { (s[b >> five] += (ones[b & fifthtau]));} //
static num be /*is bit on*/(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) { s[b >> five] & ones[b & fifthtau]; } //
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() //

On 6/24/2022 6:43 AM, Daniel Pehoushek wrote:
> // every bit is read just twice and written at most once
> // linear transform all boolean models into all true questions
> // one bit at a time; this makes no sense at all.
> daniel2391++
> static joy sort (num v, numnums& s) {
> if (zero == s.size()) return; numnums l; numnums r; spread(v, s, l, r); s.setsize(zero);
> sort (v+one, l); sort (v+one, r); think (v, l, r);
> for(num g=zero;g<l.size();g++){ ezis (*(l[g]),v);s.add(l[g]);}l.setsize(zero);
> for(num g=zero;g<r.size();g++){ univ (*(r[g]),v);s.add(r[g]);}r.setsize(zero); }

Get a brain.

the linear transform transforms models into questions
the quadratic transform produces universal truth

transforming questions to universal truth is quadratic
daniel 2391++

On Sunday, June 26, 2022 at 5:03:20 AM UTC-4, Daniel Pehoushek wrote:
> the linear transform transforms models into questions
> the quadratic transform produces universal truth
>
> transforming questions to universal truth is quadratic
> daniel 2391++
monotone n variable formulas decide
two to the n qbfs and so are
powerful high order formulas
daniel 2391++

On 6/26/2022 3:30 PM, Daniel Pehoushek wrote:
> On Sunday, June 26, 2022 at 5:03:20 AM UTC-4, Daniel Pehoushek wrote:
>> the linear transform transforms models into questions
>> the quadratic transform produces universal truth
>>
>> transforming questions to universal truth is quadratic
>> daniel 2391++
> monotone n variable formulas decide
> two to the n qbfs and so are
> powerful high order formulas
> daniel 2391++

Get. A. Brain.

solving all qbfs correctly simultaneously
is easier than
solving one qbf with errors

in the code below every bit of every model is rewritten to be a valid quantification
to transform the sat models into qbf models
daniel 2391++

// solve all quantified boolean formulas in twenty lines of code
// boolean information transforms bit by bit into quantified boolean formulas
// sort(0, all_models_of_information) => all_valid_quantifications

joy justify (num vee, numnums& left, numnums& right) {
// justify empty left with the right
if (zero == left.size()) { // when empty left fill up with right
for (num g=zero;g<right.size();g++)
left.add(right[g]);
// universal forms become ezistential at the level vee
right.setsize(zero);
return; }
numnums al; numnums ar; spread(vee+one, left, al, ar); left.setsize(zero);
numnums bl; numnums br; spread(vee+one, right, bl, br); right.setsize(zero);
justify (vee+one,al,bl);// leftleft with rightleft
justify (vee+one,ar,br);// rightleft with rightright
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]); }

joy sort (num v, numnums& s) {
numnums l; numnums r;
// read every bit
spread(v, s, l, r); s.setsize(zero);
when (l.size()) sort (v+one, l); // spread left
when (r.size()) sort (v+one, r); // spread right
justify (v, l, r); // update valid quantifications
// write every quantifier
// declare ezistential quantification
for(num g=zero;g<l.size();g++) { ezis (*(l[g]),v);s.add(l[g]);} l.setsize(zero);
// declare universal quantification
for(num g=zero;g<r.size();g++) { univ (*(r[g]),v);s.add(r[g]);} r.setsize(zero); }
joy zerotoone /*bit is on*/(nums& s, num b) { (s[b >> five] += (ones[b & fifthtau]));} //
num be /*is bit on*/(nums& s, num b) { return (s[b >> five] & (ones[b & fifthtau]));} //
joy ezis(nums& s, num b) { s[b >> five] &= zeroes[b & fifthtau]; } //
joy univ(nums& s, num b) { s[b >> five] & ones[b & fifthtau]; } //
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()

On Monday, June 27, 2022 at 1:44:48 AM UTC-4, Daniel Pehoushek wrote:
> solving all qbfs correctly simultaneously
> is easier than
> solving one qbf with errors
>
> in the code below every bit of every model is rewritten to be a valid quantification
> to transform the sat models into qbf models
> daniel 2391++
>
> // solve all quantified boolean formulas in twenty lines of code
> // boolean information transforms bit by bit into quantified boolean formulas
> // sort(0, all_models_of_information) => all_valid_quantifications
>
> joy justify (num vee, numnums& left, numnums& right) {
> // justify empty left with the right
> if (zero == left.size()) { // when empty left fill up with right
> for (num g=zero;g<right.size();g++)
> left.add(right[g]);
> // universal forms become ezistential at the level vee
> right.setsize(zero);
> return; }
> numnums al; numnums ar; spread(vee+one, left, al, ar); left.setsize(zero);
> numnums bl; numnums br; spread(vee+one, right, bl, br); right.setsize(zero);
> justify (vee+one,al,bl);// leftleft with rightleft
> justify (vee+one,ar,br);// rightleft with rightright
> 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]); }
> joy sort (num v, numnums& s) {
> numnums l; numnums r;
> // read every bit
> spread(v, s, l, r); s.setsize(zero);
> when (l.size()) sort (v+one, l); // spread left
> when (r.size()) sort (v+one, r); // spread right
> justify (v, l, r); // update valid quantifications
> // write every quantifier
> // declare ezistential quantification
> for(num g=zero;g<l.size();g++) { ezis (*(l[g]),v);s.add(l[g]);} l.setsize(zero);
> // declare universal quantification
> for(num g=zero;g<r.size();g++) { univ (*(r[g]),v);s.add(r[g]);} r.setsize(zero); }
> joy zerotoone /*bit is on*/(nums& s, num b) { (s[b >> five] += (ones[b & fifthtau]));} //
> num be /*is bit on*/(nums& s, num b) { return (s[b >> five] & (ones[b & fifthtau]));} //
> joy ezis(nums& s, num b) { s[b >> five] &= zeroes[b & fifthtau]; } //
> joy univ(nums& s, num b) { s[b >> five] & ones[b & fifthtau]; } //
> 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()
sort simplifyd to five lines for generally ezistential intelligence
joy sort (num v, numnums& s) {
numnums l; numnums r; spread(v, s, l, r); // read every bit
when (l.size()) sort (v+one, l); // spread deeper left
when (r.size()) sort (v+one, r); // spread deeper right
justify (v, l, r); // update valid quantifications
for(num g=zero;g<l.size();g++) when (be (*(l[g]),v)) ezis (*(l[g]),v); }
the universality of the remainder is here under stated
jdp 2391++

On Monday, June 27, 2022 at 3:04:59 AM UTC-4, Daniel Pehoushek wrote:
> On Monday, June 27, 2022 at 1:44:48 AM UTC-4, Daniel Pehoushek wrote:
> > solving all qbfs correctly simultaneously
> > is easier than
> > solving one qbf with errors
> >
> > in the code below every bit of every model is rewritten to be a valid quantification
> > to transform the sat models into qbf models
> > daniel 2391++
> >
> > // solve all quantified boolean formulas in twenty lines of code
> > // boolean information transforms bit by bit into quantified boolean formulas
> > // sort(0, all_models_of_information) => all_valid_quantifications
> >
> > joy justify (num vee, numnums& left, numnums& right) {
> > // justify empty left with the right
> > if (zero == left.size()) { // when empty left fill up with right
> > for (num g=zero;g<right.size();g++)
> > left.add(right[g]);
> > // universal forms become ezistential at the level vee
> > right.setsize(zero);
> > return; }
> > numnums al; numnums ar; spread(vee+one, left, al, ar); left.setsize(zero);
> > numnums bl; numnums br; spread(vee+one, right, bl, br); right.setsize(zero);
> > justify (vee+one,al,bl);// leftleft with rightleft
> > justify (vee+one,ar,br);// rightleft with rightright
> > 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]); }
> > joy sort (num v, numnums& s) {
> > numnums l; numnums r;
> > // read every bit
> > spread(v, s, l, r); s.setsize(zero);
> > when (l.size()) sort (v+one, l); // spread left
> > when (r.size()) sort (v+one, r); // spread right
> > justify (v, l, r); // update valid quantifications
> > // write every quantifier
> > // declare ezistential quantification
> > for(num g=zero;g<l.size();g++) { ezis (*(l[g]),v);s.add(l[g]);} l.setsize(zero);
> > // declare universal quantification
> > for(num g=zero;g<r.size();g++) { univ (*(r[g]),v);s.add(r[g]);} r.setsize(zero); }
> > joy zerotoone /*bit is on*/(nums& s, num b) { (s[b >> five] += (ones[b & fifthtau]));} //
> > num be /*is bit on*/(nums& s, num b) { return (s[b >> five] & (ones[b & fifthtau]));} //
> > joy ezis(nums& s, num b) { s[b >> five] &= zeroes[b & fifthtau]; } //
> > joy univ(nums& s, num b) { s[b >> five] & ones[b & fifthtau]; } //
> > 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()
> sort simplifyd to five lines for generally ezistential intelligence
> joy sort (num v, numnums& s) {
> numnums l; numnums r; spread(v, s, l, r); // read every bit
> when (l.size()) sort (v+one, l); // spread deeper left
> when (r.size()) sort (v+one, r); // spread deeper right
> justify (v, l, r); // update valid quantifications
> for(num g=zero;g<l.size();g++) when (be (*(l[g]),v)) ezis (*(l[g]),v); }
> the universality of the remainder is here under stated
> jdp 2391++
0 three planes make a point
1 one half dozen lines
2 define an idea
3 two halfspaces make a space
4 two halfplanes make a plane
5 two halflines make a line
6 three planes make a point
7 four lines make a square
8 numbers are two colorable
9 theory is two colorable
10 all is black information on white background

bob solves all qbfs of all models in twenty lines
the input models transform into qbfs in linear time
daniel 2391++

joy plan (num vee, numnums& set) {
numnums left; numnums right; split(vee, set, left, right);
when (left.size()) plan (vee+one, left); // spread deeper left
when (right.size()) plan (vee+one, right); // spread deeper right
justify (vee, left, right); // then set vee quantifications
for(num g=zero;g<left.size();g++) when(be(*(left[g]),vee))ezis(*(left[g]),vee); }

joy justify (num vee, numnums& left, numnums& right) {
// justify empty left with the formerly universal right
if (left.size()==zero) { // when empty left fill up with right
for (num g=zero;g<right.size();g++) left.add(right[g]);
right.setsize(zero);
return; }
numnums al; numnums ar; split(vee+one, left, al, ar); left.setsize(zero);
numnums bl; numnums br; split(vee+one, right, bl, br); right.setsize(zero);
justify (vee+one,al,bl);// leftleft with rightleft
justify (vee+one,ar,br);// rightleft with rightright
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]); }

joy zerotoone /*bit is on*/(nums& s, num b) { (s[b >> five] += (ones[b & fifthtau]));} //
num be /*is bit on*/(nums& s, num b) { return (s[b >> five] & (ones[b & fifthtau]));} //
joy ezis(nums& s, num b) { s[b >> five] &= zeroes[b & fifthtau]; } //
joy univ(nums& s, num b) { s[b >> five] & ones[b & fifthtau]; } //
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]); } // oh of s.siz

On 6/27/2022 1:42 PM, Daniel Pehoushek wrote:
> bob solves all qbfs of all models in twenty lines
> the input models transform into qbfs in linear time

Roses are red
Brains are for posting
Your Llama's ballsack
Smells like it's roasting

bit models of quantification are monotone

valid questions are derived from models

monotone reason is linearly entirely decidable

monotone reason is linear

each solution is satisfying

the number of boolean models equals the number of valid questions

valid questions
are derived
in linear
time
from valid models

solving all qbfs is easier than just one qbf
daniel 2391++

On Tuesday, June 28, 2022 at 3:43:22 PM UTC-4, Pete wrote:
> On 6/27/2022 1:42 PM, Daniel Pehoushek wrote:
> > bob solves all qbfs of all models in twenty lines
> > the input models transform into qbfs in linear time
> Roses are red
> Brains are for posting
> Your Llama's ballsack
> Smells like it's roasting

// Solve all qbfs in twenty lines of code
// bit by bit linear transformation
// P=PSPACE=QSPACE for modest sizes
// the models transform into questions
// high level reason in five lines
daniel 2391++

joy plan (num vee, numnums& set) {
numnums left; numnums right; split(vee, set, left, right); set.setsize(zero);
when ( left.size()) plan (vee+one, left); // spread deeper left
when (right.size()) plan (vee+one, right); // spread deeper right
juggle (vee, left, right); // then set vee quantifications
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); }

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;}
numnums al; numnums ar; split(vee+one, left, al, ar); left.setsize(zero);
numnums bl; numnums br; split(vee+one, right, bl, br); right.setsize(zero);
juggle (vee+one,al,bl);// leftleft with leftright
juggle (vee+one,ar,br);// rightleft with rightright
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]); }

joy zerotoone /*bit is on*/(nums& s, num b) { (s[b >> five] += (ones[b & fifthtau]));} //
num be /*is bit on*/(nums& s, num b) { return (s[b >> five] & (ones[b & fifthtau]));} //
joy ezis(nums& s, num b) { s[b >> five] &= zeroes[b & fifthtau]; } //
joy univ(nums& s, num b) { s[b >> five] & ones[b & fifthtau]; } //
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]); } // oh of s.size()