Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #37814 > unrolled thread
| Started by | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| First post | 2021-08-11 20:33 -0700 |
| Last post | 2021-08-17 11:46 -0700 |
| Articles | 10 on this page of 30 — 5 participants |
Back to article view | Back to comp.theory
sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-11 20:33 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-11 20:39 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 02:13 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 03:39 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 03:57 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 04:16 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 04:26 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 04:36 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 04:54 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 05:11 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 05:20 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 05:26 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 05:35 -0700
Re: sublinear identity in ten lines olcott <NoOne@NoWhere.com> - 2021-08-12 09:54 -0500
Re: sublinear identity in ten lines Andy Walker <anw@cuboid.co.uk> - 2021-08-12 19:19 +0100
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-12 12:59 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-13 01:29 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-13 01:48 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-13 06:00 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-13 06:53 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-13 07:04 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-13 07:17 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-13 07:24 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-13 07:40 -0700
Re: sublinear identity in ten lines Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-13 20:08 +0100
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-14 01:41 -0700
Re: sublinear identity in ten lines Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-14 12:59 +0100
Re: sublinear identity in ten lines Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-08-14 05:22 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-14 06:02 -0700
Re: sublinear identity in ten lines Daniel Pehoushek <pehoushek1@gmail.com> - 2021-08-17 11:46 -0700
Page 2 of 2 — ← Prev page 1 [2]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-08-13 07:04 -0700 |
| Message-ID | <4ad8ae76-da7d-4ce3-aeec-abb761a772c6n@googlegroups.com> |
| In reply to | #37871 |
On Friday, August 13, 2021 at 9:53:41 AM UTC-4, Daniel Pehoushek wrote:
> On Friday, August 13, 2021 at 9:00:36 AM UTC-4, Daniel Pehoushek wrote:
> > On Friday, August 13, 2021 at 4:48:24 AM UTC-4, Daniel Pehoushek wrote:
> > > On Friday, August 13, 2021 at 4:29:44 AM UTC-4, Daniel Pehoushek wrote:
> > > > On Thursday, August 12, 2021 at 3:59:19 PM UTC-4, Daniel Pehoushek wrote:
> > > > > On Thursday, August 12, 2021 at 2:19:07 PM UTC-4, Andy Walker wrote:
> > > > > > On 12/08/2021 12:26, Daniel Pehoushek wrote:
> > > > > > [...]
> > > > > > > const num one = (num)true; // fundamental unity of one with truth
> > > > > > > const num zero = one >> one; // one down one bit is universal zero
> > > > > > > purest cleanest possible definition of zero without using negation or
> > > > > > > minus
> > > > > > > const num two = one + one + (one >> one); // two is one plus one plus
> > > > > > > zero // zero counts most cleanly
> > > > > > > const num three = two + one; //let there be light numbers 0123
> > > > > > > const num four = two + two; //at last after all the theoretical work
> > > > > > > on small numbers we have "every child knows"
> > > > > > > const num five = three + two; //bobs favorite number is five
> > > > > > Ha! My "Game Theory" program recognises [amongst others]
> > > > > >
> > > > > > GAME zero = (null, null),
> > > > > > one = (+zero, null),
> > > > > > two = (+one, null),
> > > > > > half = (+zero, +one), [...];
> > > > > >
> > > > > > ["null" is an empty array of games, "+" is a user-defined monadic operator
> > > > > > that turns a game into an array of games]. It's more about games than
> > > > > > about numbers [which are a subset of games], else I would have done a lot
> > > > > > more to implement N and arithmetic in general. What I actually used it
> > > > > > for was to check some counts of simple games [eg generated by "day four"]
> > > > > > and to ensure the correctness of some exam questions.
> > > > > >
> > > > > > --
> > > > > > Andy Walker, Nottingham.
> > > > > > Andy's music pages: www.cuboid.me.uk/andy/Music
> > > > > > Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Bucalossi
> > > > > anyone care to value send this O(N/M) identity algorithm to google for a share of the profits?
> > > > >
> > > > > bug fix:
> > > > > num found = zero;// just count all finds one by one
> > > > > num skip(nums& pat,nums& stream,num& A,numnums* work,numnums* coolnums)
> > > > > { memrefs = zero; num lgM = zero;
> > > > > {num B = one; num tmp = pat.size(); while (tmp = tmp / A) {lgM++; B = B * A;}
> > > > > for (num g = (*work).size(); g < B; g++) { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > > > > for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - (lgM ))
> > > > > {nums* smallset = (*work)[lgma(j, stream, lgM )]; for (num k = zero; k < (*smallset).size(); k++) { num beginat = j - (*smallset)[k]; num there = one;
> > > > > for (num g = zero; g < pat.size(); g++) { when (stream[ beginat + g ] == pat[ g ]) continue; there = zero; escLoop } when(there) found++; } }
> > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> > > > > return memrefs; }
> > > > >
> > > > > num lgma(num g, nums& letters, num& lgpatternsize)
> > > > > { num answer = one; for (num h = zero; h < lgpatternsize; h++)
> > > > > { when (g + h < letters.size()) answer *= ((letters[g + h]) + one); } return Lessone(answer); }
> > > > in just have a dozen lines,
> > > > theoretically optimal string identity in O(N/M)
> > > > what is identity good for besides string matching?
> > > > optimally fastest possible string identity
> > > > good for what? self identity?
> > > > self identity is in all ways good
> > > > identity of other is good
> > > > identity is good
> > > > id entity ten
> > > > is ten
> > > > ten
> > > > num found = zero;// just count all finds one by one
> > > > num skip(nums& pat,nums& stream,num& A,numnums* work,numnums* coolnums)
> > > > { memrefs = zero; num lgM = zero;
> > > > {num B=one; num tmp=pat.size(); while(tmp=tmp / A){lgM++; B=B * A;} for (num g = (*work).size(); g < B; g++) { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > > > for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - lgM){nums* smallset=(*work)[lgma(j,stream,lgM)];for(num k=zero; k<(*smallset).size(); k++){num beginat=j - (*smallset)[k]; num there=one;
> > > > for (num g = zero; g < pat.size(); g++) { when (stream[ beginat + g ] == pat[ g ]) continue; there = zero; escLoop } when(there) found++; } }
> > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> > > > return memrefs; }
> > > > let this O(N/M) string matcher certify about bob that
> > > > i have source code for truth available by email.
> > > > daniel
> > > dear academics
> > > radical truth is what i suffer from here is present situation
> > > been trying for over one month to get response from the committee
> > > about how did my program bob in
> > > model counting competition 2021
> > > so that means i won but wtf zero emails
> > > on comp dot theory i am trying this to fish for responses
> > > none ever since winning that ai competition with bob
> > > tiz about n/m recognition again as if that is important
> > > daniel gres 2380 with bob an ai
> > > in just have a dozen lines,
> > > theoretically optimal string identity in O(N/M)
> > > what is identity good for besides string matching?
> > > optimally fastest possible string identity
> > > good for what? self identity?
> > > self identity is in all ways good
> > > identity of other is good
> > > identity is good
> > > id entity ten
> > > is ten
> > > ten
> > >
> > > num found = zero;// just count all finds one by one
> > > num skip(nums& pat,nums& stream,num& A,numnums* work,numnums* coolnums)
> > > { memrefs = zero; num lgM = zero;
> > > {num B=one; num tmp=pat.size(); while(tmp=tmp / A){lgM++; B=B * A;} for (num g = (*work).size(); g < B; g++) { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > > for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - lgM){nums* smallset=(*work)[lgma(j,stream,lgM)];for(num k=zero; k<(*smallset).size(); k++){num beginat=j - (*smallset)[k]; num there=one;
> > > for (num g = zero; g < pat.size(); g++) { when (stream[ beginat + g ] == pat[ g ]) continue; there = zero; escLoop } when(there) found++; } }
> > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> > > return memrefs; }
> > >
> > > let this O(N/M) string matcher certify about bob that
> > > i have source code for truth available by email.
> > > daniel
> > so blazingly fast identity or cognition in time N/M
> > whatever thats good for... googling and cybersecurity among others.
> >
> > skip search
> > 1. prepare the workspace, {num B=one; num tmp=pat.size(); while... { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > 2. annotate pattern, for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > 3. main skip loop, for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - lgM){nums* smallset= ...num beginat=j - (*smallset)[k]; num there=one;
> > 4. unannotate pattern. for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> >
> > completely unknown to theoretical computer science.
> > turning sequences of logm letter into numbers is the key:
> > num lgma(num g, nums& letters, num& lgpatternsize)
> > { num answer = one; for (num h = zero; h < lgpatternsize; h++) { when (g + h < letters.size()) answer *= ((letters[g + h]) + one); } return Lessone(answer); }
> > order of magnitude better than knuth morris pratt or boyer moore. now what?
> > daniel
> i am trying to fish for email responses.
> zero ever since winning that 2021
> ai competition with bob.
> daniel gres2380 with bob
> bob is an ai oracle for
> model counting and
> for universal truth
> and now identity
> is on the order
> of size N over
> size M time
> and space
my set theory is all of the finite propositional realm
here it is in code for larger sets than just a few members
for general boolean sets
i use n variable boolean formulas
with associated model counts
as foundation of set theory
the important thing about my set theory is
due and ample regard for space to hold set
//num memrefs = zero;
template < class tt > class set { // fibolacci 0 1 2 4 7 11 17 26 /// space growth of ordered sets
public:
joy allocay(num get) { if (have < get) { tt* tmp = new tt[(num)get]; if (tmp == (tt*)zero) {} else { for (num h = zero; h < have; h++) { tmp[h] = v[h]; v[h] = (tt)zero; }
when(v == (tt*)zero) {} else { delete[]v; } { have = zero; v = tmp; have = get; tmp = (tt*)zero;}}}}
joy add(tt elt) { /*memrefs++;*/ if (y == have) { allocay((one + (y >> one) + y)); } v[y] = elt; y++; }
inline num size() { /*memrefs++;*/ return y; }
inline tt& operator[](num r) { /*memrefs++;*/ return v[r]; }
num setsize(num z) { /*memrefs++;*/ y = z; return y; }
tt slop() { /*memrefs++;*/ tt ret = (tt)zero; if (y) { y = Lessone(y); ret = v[y]; v[y] = (tt)zero; } else {}return ret; }
tt last() { /*memrefs++;*/ tt ret = (tt)zero; if (y) { ret = v[Lessone(y)]; } return ret; }
num memberp(tt elt) { /*memrefs += size(); */ for (num g = zero; g < size(); g++) if (v[g] == elt) { return one; } return zero; }
joy clear() { for (num g = zero; g < have; g++)v[g] = (tt)zero; y = zero; }
~set() { clear(); when(v == (tt*)zero) {}otherwise{ delete[]v; }y = zero; have = zero; v = (tt*)zero; }
set(num beg) : y(zero), have(zero), v((tt*)zero) { when(beg) allocay(beg); }
set() : y(zero), have(zero), v((tt*)zero) { }
num y; num have; tt* v;
};/// class ordered set class ordered set class ordered set // (nine + three) procedures + three datamembers //jdp
typedef set<num> nums; /*77inbob 117indoggy*/ typedef set<nums*> numnums; /*37*///76//33indoggy
numnums numsstack; nums* getnums(num desire) { when(numsstack.size()) return numsstack.slop(); return new nums(desire); } joy putnums(nums* big) { (*big).clear(); numsstack.add(big); }//192
typedef unsigned long long nuum;/*12*///41//15indoggy
for smaller sets i use bit strings and track dynamically the count.
daniel
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-08-13 07:17 -0700 |
| Message-ID | <c8fb5359-c293-42e7-b480-8a49b5fe8dc8n@googlegroups.com> |
| In reply to | #37872 |
On Friday, August 13, 2021 at 10:04:29 AM UTC-4, Daniel Pehoushek wrote:
> On Friday, August 13, 2021 at 9:53:41 AM UTC-4, Daniel Pehoushek wrote:
> > On Friday, August 13, 2021 at 9:00:36 AM UTC-4, Daniel Pehoushek wrote:
> > > On Friday, August 13, 2021 at 4:48:24 AM UTC-4, Daniel Pehoushek wrote:
> > > > On Friday, August 13, 2021 at 4:29:44 AM UTC-4, Daniel Pehoushek wrote:
> > > > > On Thursday, August 12, 2021 at 3:59:19 PM UTC-4, Daniel Pehoushek wrote:
> > > > > > On Thursday, August 12, 2021 at 2:19:07 PM UTC-4, Andy Walker wrote:
> > > > > > > On 12/08/2021 12:26, Daniel Pehoushek wrote:
> > > > > > > [...]
> > > > > > > > const num one = (num)true; // fundamental unity of one with truth
> > > > > > > > const num zero = one >> one; // one down one bit is universal zero
> > > > > > > > purest cleanest possible definition of zero without using negation or
> > > > > > > > minus
> > > > > > > > const num two = one + one + (one >> one); // two is one plus one plus
> > > > > > > > zero // zero counts most cleanly
> > > > > > > > const num three = two + one; //let there be light numbers 0123
> > > > > > > > const num four = two + two; //at last after all the theoretical work
> > > > > > > > on small numbers we have "every child knows"
> > > > > > > > const num five = three + two; //bobs favorite number is five
> > > > > > > Ha! My "Game Theory" program recognises [amongst others]
> > > > > > >
> > > > > > > GAME zero = (null, null),
> > > > > > > one = (+zero, null),
> > > > > > > two = (+one, null),
> > > > > > > half = (+zero, +one), [...];
> > > > > > >
> > > > > > > ["null" is an empty array of games, "+" is a user-defined monadic operator
> > > > > > > that turns a game into an array of games]. It's more about games than
> > > > > > > about numbers [which are a subset of games], else I would have done a lot
> > > > > > > more to implement N and arithmetic in general. What I actually used it
> > > > > > > for was to check some counts of simple games [eg generated by "day four"]
> > > > > > > and to ensure the correctness of some exam questions.
> > > > > > >
> > > > > > > --
> > > > > > > Andy Walker, Nottingham.
> > > > > > > Andy's music pages: www.cuboid.me.uk/andy/Music
> > > > > > > Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Bucalossi
> > > > > > anyone care to value send this O(N/M) identity algorithm to google for a share of the profits?
> > > > > >
> > > > > > bug fix:
> > > > > > num found = zero;// just count all finds one by one
> > > > > > num skip(nums& pat,nums& stream,num& A,numnums* work,numnums* coolnums)
> > > > > > { memrefs = zero; num lgM = zero;
> > > > > > {num B = one; num tmp = pat.size(); while (tmp = tmp / A) {lgM++; B = B * A;}
> > > > > > for (num g = (*work).size(); g < B; g++) { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > > > > > for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - (lgM ))
> > > > > > {nums* smallset = (*work)[lgma(j, stream, lgM )]; for (num k = zero; k < (*smallset).size(); k++) { num beginat = j - (*smallset)[k]; num there = one;
> > > > > > for (num g = zero; g < pat.size(); g++) { when (stream[ beginat + g ] == pat[ g ]) continue; there = zero; escLoop } when(there) found++; } }
> > > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> > > > > > return memrefs; }
> > > > > >
> > > > > > num lgma(num g, nums& letters, num& lgpatternsize)
> > > > > > { num answer = one; for (num h = zero; h < lgpatternsize; h++)
> > > > > > { when (g + h < letters.size()) answer *= ((letters[g + h]) + one); } return Lessone(answer); }
> > > > > in just have a dozen lines,
> > > > > theoretically optimal string identity in O(N/M)
> > > > > what is identity good for besides string matching?
> > > > > optimally fastest possible string identity
> > > > > good for what? self identity?
> > > > > self identity is in all ways good
> > > > > identity of other is good
> > > > > identity is good
> > > > > id entity ten
> > > > > is ten
> > > > > ten
> > > > > num found = zero;// just count all finds one by one
> > > > > num skip(nums& pat,nums& stream,num& A,numnums* work,numnums* coolnums)
> > > > > { memrefs = zero; num lgM = zero;
> > > > > {num B=one; num tmp=pat.size(); while(tmp=tmp / A){lgM++; B=B * A;} for (num g = (*work).size(); g < B; g++) { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > > > > for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - lgM){nums* smallset=(*work)[lgma(j,stream,lgM)];for(num k=zero; k<(*smallset).size(); k++){num beginat=j - (*smallset)[k]; num there=one;
> > > > > for (num g = zero; g < pat.size(); g++) { when (stream[ beginat + g ] == pat[ g ]) continue; there = zero; escLoop } when(there) found++; } }
> > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> > > > > return memrefs; }
> > > > > let this O(N/M) string matcher certify about bob that
> > > > > i have source code for truth available by email.
> > > > > daniel
> > > > dear academics
> > > > radical truth is what i suffer from here is present situation
> > > > been trying for over one month to get response from the committee
> > > > about how did my program bob in
> > > > model counting competition 2021
> > > > so that means i won but wtf zero emails
> > > > on comp dot theory i am trying this to fish for responses
> > > > none ever since winning that ai competition with bob
> > > > tiz about n/m recognition again as if that is important
> > > > daniel gres 2380 with bob an ai
> > > > in just have a dozen lines,
> > > > theoretically optimal string identity in O(N/M)
> > > > what is identity good for besides string matching?
> > > > optimally fastest possible string identity
> > > > good for what? self identity?
> > > > self identity is in all ways good
> > > > identity of other is good
> > > > identity is good
> > > > id entity ten
> > > > is ten
> > > > ten
> > > >
> > > > num found = zero;// just count all finds one by one
> > > > num skip(nums& pat,nums& stream,num& A,numnums* work,numnums* coolnums)
> > > > { memrefs = zero; num lgM = zero;
> > > > {num B=one; num tmp=pat.size(); while(tmp=tmp / A){lgM++; B=B * A;} for (num g = (*work).size(); g < B; g++) { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > > > for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - lgM){nums* smallset=(*work)[lgma(j,stream,lgM)];for(num k=zero; k<(*smallset).size(); k++){num beginat=j - (*smallset)[k]; num there=one;
> > > > for (num g = zero; g < pat.size(); g++) { when (stream[ beginat + g ] == pat[ g ]) continue; there = zero; escLoop } when(there) found++; } }
> > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> > > > return memrefs; }
> > > >
> > > > let this O(N/M) string matcher certify about bob that
> > > > i have source code for truth available by email.
> > > > daniel
> > > so blazingly fast identity or cognition in time N/M
> > > whatever thats good for... googling and cybersecurity among others.
> > >
> > > skip search
> > > 1. prepare the workspace, {num B=one; num tmp=pat.size(); while... { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > > 2. annotate pattern, for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > > 3. main skip loop, for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - lgM){nums* smallset= ...num beginat=j - (*smallset)[k]; num there=one;
> > > 4. unannotate pattern. for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> > >
> > > completely unknown to theoretical computer science.
> > > turning sequences of logm letter into numbers is the key:
> > > num lgma(num g, nums& letters, num& lgpatternsize)
> > > { num answer = one; for (num h = zero; h < lgpatternsize; h++) { when (g + h < letters.size()) answer *= ((letters[g + h]) + one); } return Lessone(answer); }
> > > order of magnitude better than knuth morris pratt or boyer moore. now what?
> > > daniel
> > i am trying to fish for email responses.
> > zero ever since winning that 2021
> > ai competition with bob.
> > daniel gres2380 with bob
> > bob is an ai oracle for
> > model counting and
> > for universal truth
> > and now identity
> > is on the order
> > of size N over
> > size M time
> > and space
> my set theory is all of the finite propositional realm
> here it is in code for larger sets than just a few members
> for general boolean sets
> i use n variable boolean formulas
> with associated model counts
> as foundation of set theory
>
> the important thing about my set theory is
> due and ample regard for space to hold set
>
> //num memrefs = zero;
> template < class tt > class set { // fibolacci 0 1 2 4 7 11 17 26 /// space growth of ordered sets
> public:
> joy allocay(num get) { if (have < get) { tt* tmp = new tt[(num)get]; if (tmp == (tt*)zero) {} else { for (num h = zero; h < have; h++) { tmp[h] = v[h]; v[h] = (tt)zero; }
> when(v == (tt*)zero) {} else { delete[]v; } { have = zero; v = tmp; have = get; tmp = (tt*)zero;}}}}
> joy add(tt elt) { /*memrefs++;*/ if (y == have) { allocay((one + (y >> one) + y)); } v[y] = elt; y++; }
> inline num size() { /*memrefs++;*/ return y; }
> inline tt& operator[](num r) { /*memrefs++;*/ return v[r]; }
> num setsize(num z) { /*memrefs++;*/ y = z; return y; }
> tt slop() { /*memrefs++;*/ tt ret = (tt)zero; if (y) { y = Lessone(y); ret = v[y]; v[y] = (tt)zero; } else {}return ret; }
> tt last() { /*memrefs++;*/ tt ret = (tt)zero; if (y) { ret = v[Lessone(y)]; } return ret; }
> num memberp(tt elt) { /*memrefs += size(); */ for (num g = zero; g < size(); g++) if (v[g] == elt) { return one; } return zero; }
> joy clear() { for (num g = zero; g < have; g++)v[g] = (tt)zero; y = zero; }
> ~set() { clear(); when(v == (tt*)zero) {}otherwise{ delete[]v; }y = zero; have = zero; v = (tt*)zero; }
> set(num beg) : y(zero), have(zero), v((tt*)zero) { when(beg) allocay(beg); }
> set() : y(zero), have(zero), v((tt*)zero) { }
> num y; num have; tt* v;
> };/// class ordered set class ordered set class ordered set // (nine + three) procedures + three datamembers //jdp
> typedef set<num> nums; /*77inbob 117indoggy*/ typedef set<nums*> numnums; /*37*///76//33indoggy
> numnums numsstack; nums* getnums(num desire) { when(numsstack.size()) return numsstack.slop(); return new nums(desire); } joy putnums(nums* big) { (*big).clear(); numsstack.add(big); }//192
> typedef unsigned long long nuum;/*12*///41//15indoggy
>
> for smaller sets i use bit strings and track dynamically the count.
> daniel
my bignum is an ordered set of num:
class bignum { /*50*/// answer handler in grim detail
public: nums n; bignum& operator++() { foundationofreason(zero); return *this; } //see epluribusunum // counting the biggest numbers in the smallest feasible number base
the unbounded recursive core of bobs thought is:
// undo inference to data structure
inline joy abinitio(num w) { t_r_e_e += ones[w]; count++; } // operation three +s bobs mental truth core system
// do inference to data structure
inline num yaystonays(num z){when(t_r_e_e&(one<<z)){t_r_e_e&=diagovreason[z];count=countdown[count];env::zeesva[env::zeesvg++]=usiv+z;
when(one==count)return ergo();}return count;}
// assert consistency of input formula half clauses
num ergo(){nums& m=*oneways.v[unity(t_r_e_e,wyde())];num y=zero;num g=zero;while(g<m.y)when((*env::allBobs.v[(y=m.v[g++])>>siv]).yaystonays(y&sivones))
continue;else return(*env::allBobs.v[zero]).yaystonays(zero);return one;}
one trillion inferences per hour.
1100 line source code available by email.
daniel
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-08-13 07:24 -0700 |
| Message-ID | <37535b74-6718-4946-bccd-9baf1b1aa647n@googlegroups.com> |
| In reply to | #37873 |
On Friday, August 13, 2021 at 10:17:06 AM UTC-4, Daniel Pehoushek wrote:
> On Friday, August 13, 2021 at 10:04:29 AM UTC-4, Daniel Pehoushek wrote:
> > On Friday, August 13, 2021 at 9:53:41 AM UTC-4, Daniel Pehoushek wrote:
> > > On Friday, August 13, 2021 at 9:00:36 AM UTC-4, Daniel Pehoushek wrote:
> > > > On Friday, August 13, 2021 at 4:48:24 AM UTC-4, Daniel Pehoushek wrote:
> > > > > On Friday, August 13, 2021 at 4:29:44 AM UTC-4, Daniel Pehoushek wrote:
> > > > > > On Thursday, August 12, 2021 at 3:59:19 PM UTC-4, Daniel Pehoushek wrote:
> > > > > > > On Thursday, August 12, 2021 at 2:19:07 PM UTC-4, Andy Walker wrote:
> > > > > > > > On 12/08/2021 12:26, Daniel Pehoushek wrote:
> > > > > > > > [...]
> > > > > > > > > const num one = (num)true; // fundamental unity of one with truth
> > > > > > > > > const num zero = one >> one; // one down one bit is universal zero
> > > > > > > > > purest cleanest possible definition of zero without using negation or
> > > > > > > > > minus
> > > > > > > > > const num two = one + one + (one >> one); // two is one plus one plus
> > > > > > > > > zero // zero counts most cleanly
> > > > > > > > > const num three = two + one; //let there be light numbers 0123
> > > > > > > > > const num four = two + two; //at last after all the theoretical work
> > > > > > > > > on small numbers we have "every child knows"
> > > > > > > > > const num five = three + two; //bobs favorite number is five
> > > > > > > > Ha! My "Game Theory" program recognises [amongst others]
> > > > > > > >
> > > > > > > > GAME zero = (null, null),
> > > > > > > > one = (+zero, null),
> > > > > > > > two = (+one, null),
> > > > > > > > half = (+zero, +one), [...];
> > > > > > > >
> > > > > > > > ["null" is an empty array of games, "+" is a user-defined monadic operator
> > > > > > > > that turns a game into an array of games]. It's more about games than
> > > > > > > > about numbers [which are a subset of games], else I would have done a lot
> > > > > > > > more to implement N and arithmetic in general. What I actually used it
> > > > > > > > for was to check some counts of simple games [eg generated by "day four"]
> > > > > > > > and to ensure the correctness of some exam questions.
> > > > > > > >
> > > > > > > > --
> > > > > > > > Andy Walker, Nottingham.
> > > > > > > > Andy's music pages: www.cuboid.me.uk/andy/Music
> > > > > > > > Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Bucalossi
> > > > > > > anyone care to value send this O(N/M) identity algorithm to google for a share of the profits?
> > > > > > >
> > > > > > > bug fix:
> > > > > > > num found = zero;// just count all finds one by one
> > > > > > > num skip(nums& pat,nums& stream,num& A,numnums* work,numnums* coolnums)
> > > > > > > { memrefs = zero; num lgM = zero;
> > > > > > > {num B = one; num tmp = pat.size(); while (tmp = tmp / A) {lgM++; B = B * A;}
> > > > > > > for (num g = (*work).size(); g < B; g++) { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > > > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > > > > > > for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - (lgM ))
> > > > > > > {nums* smallset = (*work)[lgma(j, stream, lgM )]; for (num k = zero; k < (*smallset).size(); k++) { num beginat = j - (*smallset)[k]; num there = one;
> > > > > > > for (num g = zero; g < pat.size(); g++) { when (stream[ beginat + g ] == pat[ g ]) continue; there = zero; escLoop } when(there) found++; } }
> > > > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> > > > > > > return memrefs; }
> > > > > > >
> > > > > > > num lgma(num g, nums& letters, num& lgpatternsize)
> > > > > > > { num answer = one; for (num h = zero; h < lgpatternsize; h++)
> > > > > > > { when (g + h < letters.size()) answer *= ((letters[g + h]) + one); } return Lessone(answer); }
> > > > > > in just have a dozen lines,
> > > > > > theoretically optimal string identity in O(N/M)
> > > > > > what is identity good for besides string matching?
> > > > > > optimally fastest possible string identity
> > > > > > good for what? self identity?
> > > > > > self identity is in all ways good
> > > > > > identity of other is good
> > > > > > identity is good
> > > > > > id entity ten
> > > > > > is ten
> > > > > > ten
> > > > > > num found = zero;// just count all finds one by one
> > > > > > num skip(nums& pat,nums& stream,num& A,numnums* work,numnums* coolnums)
> > > > > > { memrefs = zero; num lgM = zero;
> > > > > > {num B=one; num tmp=pat.size(); while(tmp=tmp / A){lgM++; B=B * A;} for (num g = (*work).size(); g < B; g++) { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > > > > > for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - lgM){nums* smallset=(*work)[lgma(j,stream,lgM)];for(num k=zero; k<(*smallset).size(); k++){num beginat=j - (*smallset)[k]; num there=one;
> > > > > > for (num g = zero; g < pat.size(); g++) { when (stream[ beginat + g ] == pat[ g ]) continue; there = zero; escLoop } when(there) found++; } }
> > > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> > > > > > return memrefs; }
> > > > > > let this O(N/M) string matcher certify about bob that
> > > > > > i have source code for truth available by email.
> > > > > > daniel
> > > > > dear academics
> > > > > radical truth is what i suffer from here is present situation
> > > > > been trying for over one month to get response from the committee
> > > > > about how did my program bob in
> > > > > model counting competition 2021
> > > > > so that means i won but wtf zero emails
> > > > > on comp dot theory i am trying this to fish for responses
> > > > > none ever since winning that ai competition with bob
> > > > > tiz about n/m recognition again as if that is important
> > > > > daniel gres 2380 with bob an ai
> > > > > in just have a dozen lines,
> > > > > theoretically optimal string identity in O(N/M)
> > > > > what is identity good for besides string matching?
> > > > > optimally fastest possible string identity
> > > > > good for what? self identity?
> > > > > self identity is in all ways good
> > > > > identity of other is good
> > > > > identity is good
> > > > > id entity ten
> > > > > is ten
> > > > > ten
> > > > >
> > > > > num found = zero;// just count all finds one by one
> > > > > num skip(nums& pat,nums& stream,num& A,numnums* work,numnums* coolnums)
> > > > > { memrefs = zero; num lgM = zero;
> > > > > {num B=one; num tmp=pat.size(); while(tmp=tmp / A){lgM++; B=B * A;} for (num g = (*work).size(); g < B; g++) { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > > > > for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - lgM){nums* smallset=(*work)[lgma(j,stream,lgM)];for(num k=zero; k<(*smallset).size(); k++){num beginat=j - (*smallset)[k]; num there=one;
> > > > > for (num g = zero; g < pat.size(); g++) { when (stream[ beginat + g ] == pat[ g ]) continue; there = zero; escLoop } when(there) found++; } }
> > > > > for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> > > > > return memrefs; }
> > > > >
> > > > > let this O(N/M) string matcher certify about bob that
> > > > > i have source code for truth available by email.
> > > > > daniel
> > > > so blazingly fast identity or cognition in time N/M
> > > > whatever thats good for... googling and cybersecurity among others.
> > > >
> > > > skip search
> > > > 1. prepare the workspace, {num B=one; num tmp=pat.size(); while... { (*work).add((*coolnums).size() ? (*coolnums).slop() : new nums); (*(*work).last()).clear();} }
> > > > 2. annotate pattern, for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).add(g);
> > > > 3. main skip loop, for (num j = 0; j + lgM < stream.size(); j = j + pat.size() + one - lgM){nums* smallset= ...num beginat=j - (*smallset)[k]; num there=one;
> > > > 4. unannotate pattern. for (num g = 0; g + lgM < pat.size(); g++) (*(*work)[lgma(g, pat, lgM )]).slop();
> > > >
> > > > completely unknown to theoretical computer science.
> > > > turning sequences of logm letter into numbers is the key:
> > > > num lgma(num g, nums& letters, num& lgpatternsize)
> > > > { num answer = one; for (num h = zero; h < lgpatternsize; h++) { when (g + h < letters.size()) answer *= ((letters[g + h]) + one); } return Lessone(answer); }
> > > > order of magnitude better than knuth morris pratt or boyer moore. now what?
> > > > daniel
> > > i am trying to fish for email responses.
> > > zero ever since winning that 2021
> > > ai competition with bob.
> > > daniel gres2380 with bob
> > > bob is an ai oracle for
> > > model counting and
> > > for universal truth
> > > and now identity
> > > is on the order
> > > of size N over
> > > size M time
> > > and space
> > my set theory is all of the finite propositional realm
> > here it is in code for larger sets than just a few members
> > for general boolean sets
> > i use n variable boolean formulas
> > with associated model counts
> > as foundation of set theory
> >
> > the important thing about my set theory is
> > due and ample regard for space to hold set
> >
> > //num memrefs = zero;
> > template < class tt > class set { // fibolacci 0 1 2 4 7 11 17 26 /// space growth of ordered sets
> > public:
> > joy allocay(num get) { if (have < get) { tt* tmp = new tt[(num)get]; if (tmp == (tt*)zero) {} else { for (num h = zero; h < have; h++) { tmp[h] = v[h]; v[h] = (tt)zero; }
> > when(v == (tt*)zero) {} else { delete[]v; } { have = zero; v = tmp; have = get; tmp = (tt*)zero;}}}}
> > joy add(tt elt) { /*memrefs++;*/ if (y == have) { allocay((one + (y >> one) + y)); } v[y] = elt; y++; }
> > inline num size() { /*memrefs++;*/ return y; }
> > inline tt& operator[](num r) { /*memrefs++;*/ return v[r]; }
> > num setsize(num z) { /*memrefs++;*/ y = z; return y; }
> > tt slop() { /*memrefs++;*/ tt ret = (tt)zero; if (y) { y = Lessone(y); ret = v[y]; v[y] = (tt)zero; } else {}return ret; }
> > tt last() { /*memrefs++;*/ tt ret = (tt)zero; if (y) { ret = v[Lessone(y)]; } return ret; }
> > num memberp(tt elt) { /*memrefs += size(); */ for (num g = zero; g < size(); g++) if (v[g] == elt) { return one; } return zero; }
> > joy clear() { for (num g = zero; g < have; g++)v[g] = (tt)zero; y = zero; }
> > ~set() { clear(); when(v == (tt*)zero) {}otherwise{ delete[]v; }y = zero; have = zero; v = (tt*)zero; }
> > set(num beg) : y(zero), have(zero), v((tt*)zero) { when(beg) allocay(beg); }
> > set() : y(zero), have(zero), v((tt*)zero) { }
> > num y; num have; tt* v;
> > };/// class ordered set class ordered set class ordered set // (nine + three) procedures + three datamembers //jdp
> > typedef set<num> nums; /*77inbob 117indoggy*/ typedef set<nums*> numnums; /*37*///76//33indoggy
> > numnums numsstack; nums* getnums(num desire) { when(numsstack.size()) return numsstack.slop(); return new nums(desire); } joy putnums(nums* big) { (*big).clear(); numsstack.add(big); }//192
> > typedef unsigned long long nuum;/*12*///41//15indoggy
> >
> > for smaller sets i use bit strings and track dynamically the count.
> > daniel
> my bignum is an ordered set of num:
> class bignum { /*50*/// answer handler in grim detail
> public: nums n; bignum& operator++() { foundationofreason(zero); return *this; } //see epluribusunum // counting the biggest numbers in the smallest feasible number base
>
> the unbounded recursive core of bobs thought is:
> // undo inference to data structure
> inline joy abinitio(num w) { t_r_e_e += ones[w]; count++; } // operation three +s bobs mental truth core system
> // do inference to data structure
> inline num yaystonays(num z){when(t_r_e_e&(one<<z)){t_r_e_e&=diagovreason[z];count=countdown[count];env::zeesva[env::zeesvg++]=usiv+z;
> when(one==count)return ergo();}return count;}
> // assert consistency of input formula half clauses
> num ergo(){nums& m=*oneways.v[unity(t_r_e_e,wyde())];num y=zero;num g=zero;while(g<m.y)when((*env::allBobs.v[(y=m.v[g++])>>siv]).yaystonays(y&sivones))
> continue;else return(*env::allBobs.v[zero]).yaystonays(zero);return one;}
> one trillion inferences per hour.
> 1100 line source code available by email.
> daniel
i have a change to garey and johnson page one eighty five:
revised relativization:
1. P=NP for small quantities,
2. P!=NP for large.
daniel
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-08-13 07:40 -0700 |
| Message-ID | <30d8ae1d-1fa1-4975-8259-f9934f42d52an@googlegroups.com> |
| In reply to | #37874 |
i have a change to garey and johnson page one eighty five: revised relativization: 1. P=NP for small quantities, 2. P!=NP for large. bob computes small universal truth. daniel gres 2380 ps one month after winning model counting competition 2021 an oracle correctness contest but zero email responses since competition results please?
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-08-13 20:08 +0100 |
| Message-ID | <87lf55yxgt.fsf@bsb.me.uk> |
| In reply to | #37867 |
Daniel Pehoushek <pehoushek1@gmail.com> writes: > so blazingly fast identity or cognition in time N/M <cut> > completely unknown to theoretical computer science. Whose fault is that? Even if you are not up to writing a paper, you could publish sources that can be compiled. > now what? Publish! -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-08-14 01:41 -0700 |
| Message-ID | <ba97a161-6265-4ca9-99e7-d1dec60f8f4en@googlegroups.com> |
| In reply to | #37876 |
On Friday, August 13, 2021 at 3:08:05 PM UTC-4, Ben Bacarisse wrote: > Daniel Pehoushek <pehou...@gmail.com> writes: > > > so blazingly fast identity or cognition in time N/M > <cut> > > completely unknown to theoretical computer science. > Whose fault is that? Even if you are not up to writing a paper, you > could publish sources that can be compiled. > > > now what? > > Publish! > > -- > Ben. ben thanks for the reply. that helps ezistentialism (ie that i ezist...). i published a version of skip in 1998 at CPM98, butchered by coauthor lecroq. combinatorial pattern matching 1998. in 1997, i had just discovered the great #P=#Q theorem, and wanted cash to support research, so i published alpha skip search with two frenchmen. they really butchered the code, so now i am rectifying with skip search in under ten lines. one of the points is that skip is valuable in under ten lines and under three months of time from my life, and that bob is under 1100 lines and took maybe thirty years to write. so i want to use skip, at an order of magnitude better than kmp, as leverage to advertise the value of bob for universal truth. i am not very skilled in latex, otherwise a new paper about old skip is thoroughly justified in and of itself. O(N/M) pattern recognition deserves to be common knowledge in theoretical computer science. on the other hand, waiting twenty years to republish skip without the two frenchmen has been educational, in that zero theory students have rediscovered simple old sublinear skip search. it makes me wonder at how valuable simple bob is. anyway, if you are interested in writing a paper on skip, say titled: Skip Search: O(N/M) Pattern Recognition (in under ten lines of code) then count me in. i still cannot get email response from the committee on how bob did in the competition. the metaphysics about the null responses are pretty absurd. that is my real present problem. but publishing skip again could be a moneymaker in terms of reputation, not to mention problems like googling or cyber security identity of binary strings problems. as for what all sublinear identity algorithms are good for, that may need more study and publicity. it could end up that skip, in six lines and three months of my life, is more valuable than bob, in 1100 lines... sublinear identity versus universal truth... it seems like getting response from the committee on how bob did in detail in their competition should be easier than publishing about sublinear recognition. if only academics could have succinct certificates that indicate conceivably high valued work, academic life would be much easier... just need some sort of succinct academic labelling that everyone understands means high quality. daniel gres 2380
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-08-14 12:59 +0100 |
| Message-ID | <87pmugxmn9.fsf@bsb.me.uk> |
| In reply to | #37889 |
Daniel Pehoushek <pehoushek1@gmail.com> writes: > On Friday, August 13, 2021 at 3:08:05 PM UTC-4, Ben Bacarisse wrote: >> Daniel Pehoushek <pehou...@gmail.com> writes: >> >> > so blazingly fast identity or cognition in time N/M >> <cut> >> > completely unknown to theoretical computer science. >> Whose fault is that? Even if you are not up to writing a paper, you >> could publish sources that can be compiled. >> >> > now what? >> >> Publish! >> > > ben thanks for the reply. that helps ezistentialism (ie that i ezist...). > i published a version of skip in 1998 at CPM98, butchered by coauthor > lecroq. I know but you said it was messed up so that's not any good. > i still cannot get email response from the committee > on how bob did in the competition. The site shows bob placed eighth. That's pretty good for an independent piece of research, I'd say. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2021-08-14 05:22 -0700 |
| Message-ID | <ae1687a9-6081-4e07-ba77-d5d665a0a2d2n@googlegroups.com> |
| In reply to | #37890 |
On Saturday, 14 August 2021 at 12:59:25 UTC+1, Ben Bacarisse wrote: > Daniel Pehoushek <pehou...@gmail.com> writes: > > > i still cannot get email response from the committee > > on how bob did in the competition. > The site shows bob placed eighth. That's pretty good for an independent > piece of research, I'd say. > The important thing is that it was placed. So it fulfilled the requirements for entry and constituted a solver, and that's a good solid basis on which to work. From what I can tell (not really understanding the subject) bob's design goals are a bit different from the goals of the competition. It's a very highly optimised exact solver, whilst the competition is looking for good approximate solvers, even in the misleadingly titled "exact" track. So bob's rank order doesn't really mean anything.
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-08-14 06:02 -0700 |
| Message-ID | <29d3b2e6-8939-450e-ab29-4600d4a2c34bn@googlegroups.com> |
| In reply to | #37891 |
On Saturday, August 14, 2021 at 8:22:22 AM UTC-4, malcolm.ar...@gmail.com wrote: > On Saturday, 14 August 2021 at 12:59:25 UTC+1, Ben Bacarisse wrote: > > Daniel Pehoushek <pehou...@gmail.com> writes: > > > > > i still cannot get email response from the committee > > > on how bob did in the competition. > > The site shows bob placed eighth. That's pretty good for an independent > > piece of research, I'd say. > > > The important thing is that it was placed. So it fulfilled the requirements for > entry and constituted a solver, and that's a good solid basis on which to work. > > From what I can tell (not really understanding the subject) bob's design goals > are a bit different from the goals of the competition. It's a very highly > optimised exact solver, whilst the competition is looking for good approximate > solvers, even in the misleadingly titled "exact" track. So bob's rank order doesn't > really mean anything. yes. i look at the long term value of a correct track 1. producing and detecting oracles of truth accurately and succinctly is to me a trivial but important matter. i would be happy with one on one oracle validation but the committee is behaving in a stone stupid manner. without a competent and correct track 1 validation of reasoning in artificial intelligence would be difficult. also the value of universal truth may be getting underestimated by the committee. daniel
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-08-17 11:46 -0700 |
| Message-ID | <c7174d32-942b-4c64-8641-c0f1db433595n@googlegroups.com> |
| In reply to | #37892 |
On Saturday, August 14, 2021 at 9:02:30 AM UTC-4, Daniel Pehoushek wrote: > On Saturday, August 14, 2021 at 8:22:22 AM UTC-4, malcolm.ar...@gmail.com wrote: > > On Saturday, 14 August 2021 at 12:59:25 UTC+1, Ben Bacarisse wrote: > > > Daniel Pehoushek <pehou...@gmail.com> writes: > > > > > > > i still cannot get email response from the committee > > > > on how bob did in the competition. > > > The site shows bob placed eighth. That's pretty good for an independent > > > piece of research, I'd say. > > > > > The important thing is that it was placed. So it fulfilled the requirements for > > entry and constituted a solver, and that's a good solid basis on which to work. > > > > From what I can tell (not really understanding the subject) bob's design goals > > are a bit different from the goals of the competition. It's a very highly > > optimised exact solver, whilst the competition is looking for good approximate > > solvers, even in the misleadingly titled "exact" track. So bob's rank order doesn't > > really mean anything. > yes. i look at the long term value of a correct track 1. > producing and detecting oracles of truth accurately and > succinctly is to me a trivial but important matter. > i would be happy with one on one oracle validation > but the committee is behaving in a stone stupid manner. > > without a competent and correct track 1 validation of reasoning > in artificial intelligence would be difficult. also the value of > universal truth may be getting underestimated by the committee. > daniel let economy rule by coins for children daniel
[toc] | [prev] | [standalone]
Page 2 of 2 — ← Prev page 1 [2]
Back to top | Article view | comp.theory
csiph-web