Then the cat is barking mad, just like olcott.

/Flibble

On 6/26/2021 2:56 PM, Mr Flibble wrote:
> Then the cat is barking mad, just like olcott.
[...]

Well, shit happens:

https://youtu.be/7ygh5f-B99A

+++++++++++++++dear pete olcott++++++++++++++++++++++++++++++++++++++++++
+++my bob program for solving polynomial space time problems has a mind+=====
+++that is one million times my own mind's speed. and yet, i am+=======
+++much smarter than bob is about halt deciding bob. i would say+++====
+++that my history of halt deciding a polynomial space time++=====
+++solver is nearly perfect. would you like a copy of bob++====
+++to see how well you do?++++++
==========================
++++++++++++============
+++++++++=============
====================
=================
==============
===========
go pete o go
pete o go
pete o
go go
go

+++ dear pete olcott
+-I am just pointing out the date and time that you first spoke to me
+-knucklehead. It was not 2012. Then I go on to point out the irrefutable
+how can someone care so much about others opinions? have you studied
+your reasons for collecting "databases of conversations"?+
+ +-reasoning I am incorrect.
+-
+-A not genius can out perform profoundly brilliant geniuses on a
+-specific task such as the halting problem when 10,000-fold more time and
+-effort is applied. By going over all the details enormously more times
+-than anyone else has patience for, details that were never noticed
+-before are uncovered.
+my bob program for solving polynomial space time problems has a mind
+that is one million times my own mind's speed. and yet, i am
+much smarter than bob is about halt deciding bob. i would say
+that my history of halt deciding a polynomial space time
+solver is nearly perfect. would you like a copy of bob
+to see how well you do?++++++++++++++
+ ++Genius is one per cent inspiration and ninety-nine per cent
++perspiration. Thomas Edison.
+pete rose of the cincinnati reds said something similar when i was a boy.
+ ++Ben Bacarisse the king
+++Ben Bacarisse the king
++Ben Bacarisse the king
-I am daring you (or anyone else) to point out any error in the following.
-I am daring you (or anyone else) to point out any error in the following.
-I am daring you (or anyone else) to point out any error in the following.
-That you do not understand that when one invocation of the connected
-chain of invocations of infinite recursion int main(){ P(P); }
- -is aborted thus forcing the whole chain to halt, this does not mean that
-int main(){ P(P); } does not specify a chain of infinite invocations.

+try num main() and data type num for much more cleanly recursion

-Everyone here that is proficient at software engineering knows that I am
-incorrect about this.

++++ dear pete olcott+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-=
++-I am just pointing out the date and time that you first spoke to me
++-knucklehead. It was not 2012. Then I go on to point out the irrefutable
++how can someone care so much about others opinions? have you studied
++your reasons for collecting "databases of conversations"?+
++
+-----reasoning I am incorrect.
++-
++-A not genius can out perform profoundly brilliant geniuses on a
++-specific task such as the halting problem when 10,000-fold more time and
++-effort is applied. By going over all the details enormously more times
++-than anyone else has patience for, details that were never noticed
++-before are uncovered.
++my bob program for solving polynomial space time problems has a mind
++that is one million times my own mind's speed. and yet, i am
++much smarter than bob is about halt deciding bob. i would say
++that my history of halt deciding a polynomial space time
++solver is nearly perfect. would you like a copy of bob
++to see how well you do?++++++++++++++
++
+++Genius is one per cent inspiration and ninety-nine per cent
+++perspiration. Thomas Edison.
++ pete oh rose of the cincinnati reds said something similar when i was a boy.
+++
+++Ben Bacarisse the king
++++Ben Bacarisse the king
+++Ben Bacarisse the king
-I am daring you (or anyone else) to point out any error in the following.
-I am daring you (or anyone else) to point out any error in the following.
-I am daring you (or anyone else) to point out any error in the following.
-That you do not understand that when one invocation of the connected
-chain of invocations of infinite recursion int main(){ P(P); }
- -is aborted thus forcing the whole chain to halt, this does not mean that
-int main(){ P(P); } does not specify a chain of infinite invocations.

++try num main() and data type num for much more cleanly recursion
num is pure gold for precious reason.
-intisbad. itbadsin.
typedef unsigned long num;
const num one = (num)true;
const num zero = one >> one;
const num two = one + one + (one >> one);
const num three = two + one;
const num four = two + two;
const num five = three + two;
const num siv = three + two + one;
const num seven = three + three + one;
const num eight = seven + one;
const num nine = eight + one;
const num ten = five + five;

-Everyone here that is proficient at software engineering knows that I am
-incorrect about this.

On Sunday, June 27, 2021 at 1:24:17 AM UTC-4, Daniel Pehoushek wrote:
> ++++ dear pete olcott+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-=
> ++-I am just pointing out the date and time that you first spoke to me
> ++-knucklehead. It was not 2012. Then I go on to point out the irrefutable
> ++how can someone care so much about others opinions? have you studied
> ++your reasons for collecting "databases of conversations"?+
> ++
> +-----reasoning I am incorrect.
> ++-
> ++-A not genius can out perform profoundly brilliant geniuses on a
> ++-specific task such as the halting problem when 10,000-fold more time and
> ++-effort is applied. By going over all the details enormously more times
> ++-than anyone else has patience for, details that were never noticed
> ++-before are uncovered.
> ++my bob program for solving polynomial space time problems has a mind
> ++that is one million times my own mind's speed. and yet, i am
> ++much smarter than bob is about halt deciding bob. i would say
> ++that my history of halt deciding a polynomial space time
> ++solver is nearly perfect. would you like a copy of bob
> ++to see how well you do?++++++++++++++
> ++
> +++Genius is one per cent inspiration and ninety-nine per cent
> +++perspiration. Thomas Edison.
> ++ pete oh rose of the cincinnati reds said something similar when i was a boy.
> +++
> +++Ben Bacarisse the king
> ++++Ben Bacarisse the king
> +++Ben Bacarisse the king
> -I am daring you (or anyone else) to point out any error in the following.
> -I am daring you (or anyone else) to point out any error in the following.
> -I am daring you (or anyone else) to point out any error in the following.
> -That you do not understand that when one invocation of the connected
> -chain of invocations of infinite recursion int main(){ P(P); }
> -
> -is aborted thus forcing the whole chain to halt, this does not mean that
> -int main(){ P(P); } does not specify a chain of infinite invocations.
> ++try num main() and data type num for much more cleanly recursion
> num is pure gold for precious reason.
> -intisbad. itbadsin.
typedef unsigned long num;
const num one = (num)true;
const num zero = one >> one;
const num two = one + one + (one >> one);
const num three = two + one;
const num four = two + two;
const num five = three + two;
const num siv = three + two + one;
const num seven = three + three + one;
const num eight = seven + one;
const num nine = eight + one;
const num ten = five + five;

-Everyone here that is proficient at software engineering knows that I am
-incorrect about this.

+
+ num Lessone(num g)
+ {
+ num p = zero; for(p=zero; (p+one) < g ; p=((p + g )>>one)){} return p;
+ }

+++ try num main() and data type num for much more cleanly recursion
+++ num is pure gold for precious reason.
+++ -intisbad. itbadsin.
typedef unsigned long num;
const num one = (num)true;
const num zero = one >> one;
const num two = one + one + (one >> one);
const num three = two + one;
const num four = two + two;
const num five = three + two;
const num siv = three + two + one;
const num seven = three + three + one;
const num eight = seven + one;
const num nine = eight + one;
const num ten = five + five;

-Everyone here that is proficient at software engineering knows that I am
-incorrect about this.

+
+ num Lessone(num g)
+ {
+ num p = zero; for(p=zero; (p+one) < g ; p=((p + g )>>one)){} return p;
+ }

num Times(num a, num b)
{ if (a > (one >> one)) return b + (Times(Lessone(a), b));
else return (one >> one);
} const num Truth = Times(Times((three + Lessone(three)), (Lessone(three) + three)), (Times(three, Times(three, three)) + three + Lessone(Lessone(three))));

const num onehundred = Times(ten, ten); // perfed perfed perfed
const num seventhtau = onehundred + Times(three, Times(three, three));
const num onethousand = Times(ten, Times(ten, ten));
const num tenthousand = Times(ten, onethousand );
const num onemillion = Times(onethousand , onethousand);
const num onebillion = Times(onethousand, onemillion);
num squareOfReason [] = {
(num)4294967294, (num)4294967293, (num)4294967291, (num)4294967287,
(num)4294967279, (num)4294967263, (num)4294967231, (num)4294967167,
(num)4294967039, (num)4294966783, (num)4294966271, (num)4294965247,
(num)4294963199, (num)4294959103, (num)4294950911, (num)4294934527,
(num)4294901759, (num)4294836223, (num)4294705151, (num)4294443007,
(num)4293918719, (num)4292870143, (num)4290772991, (num)4286578687,
(num)4278190079, (num)4261412863, (num)4227858431, (num)4160749567,
(num)4026531839, (num)3758096383, (num)3221225471, (num)2147483647 };

daniel (little d gres 2380/2400, sats 1530/1600)

class Bob; /*106*/ // shallow boolean tree with memory on every leaf // //103//d
typedef set<Bob*> Goods; //vettor of bobs //54 //d
typedef set<Goods*> Gooduses; //vettor of vettor //24//d
typedef set<Gooduses*> Goodusesez; // vettor of vettor of vettor //10//d

static Bob* bigbub; // assump
sayvum joy assume(Bob* abob, num& a); // propagate then prepare
sayvum joy epluribusunum(Bob* bbob, Goods& tops, bignum& r); // do
sayvum joy unassume(Bob* cbub, num a, num be); // propagate then prepare
sayvum joy addsolution(bignum& r); // remember every bit of every solution
sayvum joy composition(Goods& alltops, bignum& result);//tail end parts
sayvum joy unite(Goods& smallsets, bignum& b); //multiply counts
static joy dollar(num begin, bignum& r); // linear tail closure
static joy dime(num numis, num begin, num innersetbegin, nums& set);// update intersection
static joy nickel(num innersetbegin, nums& set); // assert intersection
static joy penny(); // innerloop
static joy dounto(num s); // restore truth down to s
static joy countwork(num s, num g, num syz);

//////////////////////////////////////////////
//
// the ray class : an initial design for
// using primes as a random bit source
// with a very large cycle period of
// roughly ten to the seventy
//
// oneum numeum numbeereum
// oneum : rayndom single bits perhaps of water
// numeum : rayndom sequence of bits
// numbereum : rayndom number, uses some numeum
// randomize(nums& numbers); : permute numbers
//
// the given implementation is intended
// to provide random choice from a set.
// the set reduces by one member
//
//
// the primitive bit source of Prhymeum
// is used for users rays choices
// works very very well
//
//
// a major implementation note is that
// zero is never a member of the set
// of possible chooseums.
//
// when chooseum returns zero,
// you must need refillium
// to continue random
//////////////////////////////////////////////////////////////////////
unsigned long pryhmes[] = { // line by line reasoning inside argg cpp
2, 25057, 7643, 5711, 2767, 6857, 8971, 18089, 15797, 31333,
30323, 24179, 4861, 5783, 17027, 30091, 1693, 32507, 15683, 8539,
....

////////////////////////////////////////////////////////////////////////////////////////////
// cost per bit preliminary analysis
//
// 7 cpu instructions per bit
// the refillium cost4d2 averages O(1/2) cpu instruction per bit
// the capital pee definition of blasphemy is n o t c o u n t i n g (421/2=3+) 60
// dear jeff yesterday was otober first twentytwenty i got fired from wendys hole position minimum wages
// dear all humans the tenth time getting fired is the best make it so by your command

num sum = zero;
//
// constants are supposed to work
// when constants doan work
// then other foodish problems
// may arise
// due to busted bits
// in the arithmetic logic units
// or on the busses of the food business
// email computer systems
sum += (zero < one);
sum += (zero + one);
sum += (one + zero);
sum += (one + one);
sum += (zero | one);
sum += (one | zero);
sum += (one | one);
sum += (one & one);
sum += (one > zero);
sum += (one == (one == one));
sum += ((one == one) == one);
sum += (one == (zero == zero));
sum += ((zero == zero) == one);
sum += (zero == (one == zero));
sum += ((one == zero) == zero);
sum += (one == (zero == zero));
sum += ((zero == zero) == one);
sum += (zero == (one == zero));
sum += ((one == zero) == zero);
sum += ((zero < zero) == zero);
sum += ((zero + zero) == zero);
sum += ((zero & zero) == zero);
sum += ((zero | zero) == zero);
sum += ((zero > zero) == zero);
sum += ((one < zero) == zero);
sum += ((one & zero) == zero);
sum += ((zero > one) == zero);
// 27 above
sum += ((one + one) & one) == zero;
sum += ((one + one) & zero) == zero;
sum += ((one & zero) & one) == zero;
sum += ((one + zero) & zero) == zero;
sum += ((zero & (one + one)) == zero);
sum += ((zero + one) & zero) == zero;
sum += ((zero + zero) & one) == zero;
sum += ((zero + zero) & zero) == zero;
sum += ((one + one) | one) == one + one;
sum += ((one + one) | zero) == one + one;
sum += ((one & zero) | one) == one;
sum += ((one + zero) | zero) == one;
sum += ((zero | (one + one)) == one + one);
sum += ((zero + one) | zero) == one;
sum += ((zero + zero) | one) == one;
sum += ((zero + zero) | zero) == zero;
sum += (one == (zero + one));
sum += ((zero + one) == one);
sum += (one == (one | one));
sum += ((one | one) == one);
sum += (one < (one + one));
sum += ((one + one) > one);
sum += ((zero > one) < (zero < one));
sum += ((zero < one) >(zero > one));
sum += ((one < zero) < (zero < one));
sum += ((zero < one) >(one < zero));
sum += ((one + one + one) == ((one + one) | one));
// 27 + 27
when(sum == 54) { // checks to see if compiler and cpu are reasonable
// on some architectures the lowest order bit or
// the highest order bit get fried without
// management knowing about the issue
// so always useful to begin
// an invaluable routine
// with some sanity checks
//
///////////////////////////////////////////////
//
// mostly these twopowers are mostly used for
// inside any boolum br looking on any br
// at any one br of the set of brs
// of up to eight or sivteen
// or formerly upto thirty two
// two valued bits
//
///////////////////////////////////////////////////
printf("\n the cpu appears to have a working alu memory bus on ones bit.");
} num N0library()
{ num C = 0;
num D = 0;
num N = 0;
// char* comment = new char[1000];
// sprintf(comment, "C3D%uN%u.veg", D, N);
// printf("\n %s", comment);
// elementlibrary(comment, C, D, N, qty);
// graph::elementarygraph(C, D, N, qty);
graph::colorfile = (FILE*)zero; fopen_s(&graph::colorfile, "N0.veg", "a+");
graph::elementarygraph(0, 0, N, 1);
graph::elementarygraph(0, 1, N, 1);
graph::elementarygraph(1, 0, N, 1);
graph::elementarygraph(1, 1, N, 1);
graph::elementarygraph(1, 2, N, 1);
graph::elementarygraph(2, 1, N, 1);
fclose(graph::colorfile);
return zero;
} num N1library()
{ num C = 0;
num D = 0;
num N = 1;
graph::colorfile = (FILE*)zero; fopen_s(&graph::colorfile, "N1.veg", "a+");
graph::elementarygraph(0, 0, N, 1);
graph::elementarygraph(0, 1, N, 1);
graph::elementarygraph(1, 0, N, 1);
graph::elementarygraph(1, 1, N, 1);
graph::elementarygraph(1, 2, N, 1);
graph::elementarygraph(2, 0, N, 1);
graph::elementarygraph(2, 1, N, 1);
graph::elementarygraph(2, 2, N, 1);
graph::elementarygraph(3, 0, N, 1);
graph::elementarygraph(3, 1, N, 1);
graph::elementarygraph(3, 2, N, 1);
graph::elementarygraph(3, 3, N, 1);
graph::elementarygraph(4, 0, N, 1);
graph::elementarygraph(4, 1, N, 1);
graph::elementarygraph(4, 2, N, 1);
graph::elementarygraph(4, 3, N, 1);
graph::elementarygraph(4, 4, N, 1);
graph::elementarygraph(5, 0, N, 1);
graph::elementarygraph(5, 1, N, 1);
graph::elementarygraph(5, 2, N, 1);
graph::elementarygraph(5, 3, N, 1);
graph::elementarygraph(5, 4, N, 1);
graph::elementarygraph(6, 0, N, 1);
graph::elementarygraph(6, 1, N, 1);
graph::elementarygraph(6, 2, N, 1);
graph::elementarygraph(6, 3, N, 1);
graph::elementarygraph(6, 4, N, 1);
graph::elementarygraph(7, 0, N, 1);
graph::elementarygraph(7, 1, N, 1);
graph::elementarygraph(7, 2, N, 1);
graph::elementarygraph(7, 3, N, 1);
graph::elementarygraph(7, 4, N, 1);
graph::elementarygraph(8, 0, N, 1);
graph::elementarygraph(8, 1, N, 1);
graph::elementarygraph(8, 2, N, 1);
graph::elementarygraph(8, 3, N, 1);
graph::elementarygraph(8, 4, N, 1);
fclose(graph::colorfile);
return zero;
} num N2library()
{ num C = 0;
num D = 0;
num N = 2;
graph::colorfile = (FILE*)zero; fopen_s(&graph::colorfile, "N2.veg", "a+");
graph::elementarygraph(0, 0, N, 1);
graph::elementarygraph(0, 1, N, 1);
graph::elementarygraph(0, 2, N, 1);
graph::elementarygraph(0, 3, N, 1);
graph::elementarygraph(1, 0, N, 1);
graph::elementarygraph(1, 1, N, 1);
graph::elementarygraph(1, 2, N, 1);
graph::elementarygraph(1, 3, N, 1);
graph::elementarygraph(2, 0, N, 1);
graph::elementarygraph(2, 1, N, 1);
graph::elementarygraph(2, 2, N, 1);
graph::elementarygraph(2, 3, N, 1);
graph::elementarygraph(3, 0, N, 1);
graph::elementarygraph(3, 1, N, 1);
graph::elementarygraph(3, 2, N, 1);
graph::elementarygraph(3, 3, N, 1);
graph::elementarygraph(4, 0, N, 1);
graph::elementarygraph(4, 1, N, 1);
graph::elementarygraph(4, 2, N, 1);
graph::elementarygraph(4, 3, N, 1);
graph::elementarygraph(4, 4, N, 1);
graph::elementarygraph(5, 0, N, 1);
graph::elementarygraph(5, 1, N, 1);
graph::elementarygraph(5, 2, N, 1);
graph::elementarygraph(5, 3, N, 1);
graph::elementarygraph(5, 4, N, 1);
graph::elementarygraph(6, 0, N, 1);
graph::elementarygraph(6, 1, N, 1);
graph::elementarygraph(6, 2, N, 1);
graph::elementarygraph(6, 3, N, 1);
graph::elementarygraph(6, 4, N, 1);
graph::elementarygraph(7, 0, N, 1);
graph::elementarygraph(7, 1, N, 1);
graph::elementarygraph(7, 2, N, 1);
graph::elementarygraph(7, 3, N, 1);
graph::elementarygraph(7, 4, N, 1);
graph::elementarygraph(8, 0, N, 1);
graph::elementarygraph(8, 1, N, 1);
graph::elementarygraph(8, 2, N, 1);
graph::elementarygraph(8, 3, N, 1);
graph::elementarygraph(8, 4, N, 1);
fclose(graph::colorfile);
return zero;
} num N3library()
{ num C = 0;
num D = 0;
num N = 3;
graph::colorfile = (FILE*)zero; fopen_s(&graph::colorfile, "N3.veg", "a+");
graph::elementarygraph(0, 0, N, 1);
graph::elementarygraph(0, 1, N, 1);
graph::elementarygraph(0, 2, N, 1);
graph::elementarygraph(0, 3, N, 1);
graph::elementarygraph(1, 0, N, 1);
graph::elementarygraph(1, 1, N, 1);
graph::elementarygraph(1, 2, N, 1);
graph::elementarygraph(1, 3, N, 1);
graph::elementarygraph(2, 0, N, 1);
graph::elementarygraph(2, 1, N, 1);
graph::elementarygraph(2, 2, N, 1);
graph::elementarygraph(2, 3, N, 1);
graph::elementarygraph(3, 0, N, 1);
graph::elementarygraph(3, 1, N, 1);
graph::elementarygraph(3, 2, N, 1);
graph::elementarygraph(3, 3, N, 1);
graph::elementarygraph(4, 0, N, 1);
graph::elementarygraph(4, 1, N, 1);
graph::elementarygraph(4, 2, N, 1);
graph::elementarygraph(4, 3, N, 1);
graph::elementarygraph(4, 4, N, 1);
graph::elementarygraph(5, 0, N, 1);
graph::elementarygraph(5, 1, N, 1);
graph::elementarygraph(5, 2, N, 1);
graph::elementarygraph(5, 3, N, 1);
graph::elementarygraph(5, 4, N, 1);
graph::elementarygraph(6, 0, N, 1);
graph::elementarygraph(6, 1, N, 1);
graph::elementarygraph(6, 2, N, 1);
graph::elementarygraph(6, 3, N, 1);
graph::elementarygraph(6, 4, N, 1);
graph::elementarygraph(7, 0, N, 1);
graph::elementarygraph(7, 1, N, 1);
graph::elementarygraph(7, 2, N, 1);
graph::elementarygraph(7, 3, N, 1);
graph::elementarygraph(7, 4, N, 1);
graph::elementarygraph(8, 0, N, 1);
graph::elementarygraph(8, 1, N, 1);
graph::elementarygraph(8, 2, N, 1);
graph::elementarygraph(8, 3, N, 1);
graph::elementarygraph(8, 4, N, 1);
fclose(graph::colorfile);
return zero;
}
Click here to read the complete article

abcdefghijklmnopqrstuvw yz0