Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Disc space -- the final frontier!


devel / comp.theory / Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

SubjectAuthor
* Validating that the implementation meets the spec for TM transitionolcott
+* Validating that the implementation meets the spec for TMMr Flibble
|`* Validating that the implementation meets the spec for TMolcott
| +* Validating that the implementation meets the spec for TM transition functionMr Flibble
| |`* Validating that the implementation meets the spec for TMolcott
| | `- Validating that the implementation meets the spec for TMMr Flibble
| `* Validating that the implementation meets the spec for TMMalcolm McLean
|  +* Validating that the implementation meets the spec for TMolcott
|  |+* Validating that the implementation meets the spec for TMMalcolm McLean
|  ||`- Validating that the implementation meets the spec for TMolcott
|  |+* Validating that the implementation meets the spec for TMMike Terry
|  ||`- Validating that the implementation meets the spec for TMolcott
|  |`* Validating that the implementation meets the spec for TM transition functionBen
|  | `* Validating that the implementation meets the spec for TMolcott
|  |  `* Validating that the implementation meets the spec for TM transition functionBen
|  |   +* Validating that the implementation meets the spec for TMJeff Barnett
|  |   |+* Validating that the implementation meets the spec for TM transition functionRichard Damon
|  |   ||`* Validating that the implementation meets the spec for TMMalcolm McLean
|  |   || +- Validating that the implementation meets the spec for TMRichard Damon
|  |   || `* Validating that the implementation meets the spec for TM transition functionBen
|  |   ||  `* Validating that the implementation meets the spec for TM transition functionBen
|  |   ||   `* Validating that the implementation meets the spec for TMolcott
|  |   ||    `- Validating that the implementation meets the spec for TM transition functionBen
|  |   |`* Validating that the implementation meets the spec for TM transition functionBen
|  |   | `* Validating that the implementation meets the spec for TMJeff Barnett
|  |   |  `* Validating that the implementation meets the spec for TM transition functionBen
|  |   |   +* Validating that the implementation meets the spec for TM transition functionRichard Damon
|  |   |   |+* Validating that the implementation meets the spec for TM transition functionMr Flibble
|  |   |   ||`* Validating that the implementation meets the spec for TMolcott
|  |   |   || `* Validating that the implementation meets the spec for TM transition functionBen
|  |   |   ||  `* Validating that the implementation meets the spec for TMolcott
|  |   |   ||   +- Validating that the implementation meets the spec for TMRichard Damon
|  |   |   ||   `* Validating that the implementation meets the spec for TM transition functionBen
|  |   |   ||    +* Validating that the implementation meets the spec for TMolcott
|  |   |   ||    |`- Validating that the implementation meets the spec for TM transition functionBen
|  |   |   ||    `- Validating that the implementation meets the spec for TMolcott
|  |   |   |`- Validating that the implementation meets the spec for TMJeff Barnett
|  |   |   `* Validating that the implementation meets the spec for TMolcott
|  |   |    `* Validating that the implementation meets the spec for TM transition functionBen
|  |   |     `* Validating that the implementation meets the spec for TMolcott
|  |   |      `* Validating that the implementation meets the spec for TM transition functionBen
|  |   |       `* Validating that the implementation meets the spec for TMolcott
|  |   |        +* Validating that the implementation meets the spec for TM transition functionRichard Damon
|  |   |        |`- Validating that the implementation meets the spec for TMMalcolm McLean
|  |   |        `* Validating that the implementation meets the spec for TM transition functionBen
|  |   |         `* Validating that the implementation meets the spec for TMMalcolm McLean
|  |   |          +* Validating that the implementation meets the spec for TM transition functionBen
|  |   |          |`* Validating that the implementation meets the spec for TMolcott
|  |   |          | +- Validating that the implementation meets the spec for TMRichard Damon
|  |   |          | `* Validating that the implementation meets the spec for TM transition functionBen
|  |   |          |  +* Validating that the implementation meets the spec for TMJeff Barnett
|  |   |          |  |`* Validating that the implementation meets the spec for TMolcott
|  |   |          |  | `- Validating that the implementation meets the spec for TMJeff Barnett
|  |   |          |  `* Validating that the implementation meets the spec for TM transition functionMr Flibble
|  |   |          |   +* Validating that the implementation meets the spec for TMdklei...@gmail.com
|  |   |          |   |+* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||`* Validating that the implementation meets the spec for TM transition functionBen
|  |   |          |   || `* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||  +* Validating that the implementation meets the spec for TMMike Terry
|  |   |          |   ||  |+- Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||  |`* Validating that the implementation meets the spec for TMMalcolm McLean
|  |   |          |   ||  | +- Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||  | `* Validating that the implementation meets the spec for TMMike Terry
|  |   |          |   ||  |  +* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||  |  |`- Validating that the implementation meets the spec for TMMike Terry
|  |   |          |   ||  |  `* Validating that the implementation meets the spec for TMMalcolm McLean
|  |   |          |   ||  |   +- Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||  |   +* Validating that the implementation meets the spec for TMMike Terry
|  |   |          |   ||  |   |`* Validating that the implementation meets the spec for TM transition function [ bolcott
|  |   |          |   ||  |   | `* Validating that the implementation meets the spec for TMMike Terry
|  |   |          |   ||  |   |  +- Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||  |   |  +- Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||  |   |  `* Validating that the implementation meets the spec for TM transition function [ bBen
|  |   |          |   ||  |   |   `* Validating that the implementation meets the spec for TMMike Terry
|  |   |          |   ||  |   |    `* Validating that the implementation meets the spec for TM transition function [ bBen
|  |   |          |   ||  |   |     +- Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||  |   |     +- Validating that the implementation meets the spec for TMRichard Damon
|  |   |          |   ||  |   |     `- Validating that the implementation meets the spec for TMMike Terry
|  |   |          |   ||  |   `* Validating that the implementation meets the spec for TMJeff Barnett
|  |   |          |   ||  |    `- Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||  `* Validating that the implementation meets the spec for TM transition function [ bBen
|  |   |          |   ||   +* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||   |`- Validating that the implementation meets the spec for TM transition function [ bBen
|  |   |          |   ||   `* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||    +* Validating that the implementation meets the spec for TMMike Terry
|  |   |          |   ||    |`- Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||    `* Validating that the implementation meets the spec for TM transition function [ bBen
|  |   |          |   ||     `* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||      `* Validating that the implementation meets the spec for TM transition function [ bBen
|  |   |          |   ||       `* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||        `* Validating that the implementation meets the spec for TM transition function [ bBen
|  |   |          |   ||         `* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||          +* Validating that the implementation meets the spec for TM transition function [ bBen
|  |   |          |   ||          |`* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||          | `* Validating that the implementation meets the spec for TM transition function [ bBen
|  |   |          |   ||          |  `* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||          |   `* Validating that the implementation meets the spec for TM transition function [ bBen
|  |   |          |   ||          |    `* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||          |     +* Validating that the implementation meets the spec for TMMr Flibble
|  |   |          |   ||          |     |`* Validating that the implementation meets the spec for TMolcott
|  |   |          |   ||          |     | `- Validating that the implementation meets the spec for TMMr Flibble
|  |   |          |   ||          |     `* Validating that the implementation meets the spec for TM transition function [ bBen
|  |   |          |   ||          `- Validating that the implementation meets the spec for TMRichard Damon
|  |   |          |   |`- Validating that the implementation meets the spec for TMolcott
|  |   |          |   +- Validating that the implementation meets the spec for TM transition functionBen
|  |   |          |   `- Validating that the implementation meets the spec for TMolcott
|  |   |          `- Validating that the implementation meets the spec for TMolcott
|  |   `* Validating that the implementation meets the spec for TMolcott
|  `* Validating that the implementation meets the spec for TM transition functionBen
`* Validating that the implementation meets the spec for TM transition functionMikko

Pages:12345678
Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<87h75tugo8.fsf@bsb.me.uk>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32423&group=comp.theory#32423

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Validating that the implementation meets the spec for TM transition function [ best tape ]
Date: Sat, 14 May 2022 01:00:23 +0100
Organization: A noiseless patient Spider
Lines: 67
Message-ID: <87h75tugo8.fsf@bsb.me.uk>
References: <t541t8$upu$1@dont-email.me> <87tu9u31nv.fsf@bsb.me.uk>
<X9mdnVTySoUr5eD_nZ2dnUU7_8zNnZ2d@giganews.com>
<874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com>
<87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com>
<87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com>
<87y1z5zoqu.fsf@bsb.me.uk> <20220513133840.0000732f@reddwarf.jmc>
<875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com>
<87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com>
<871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com>
<87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com>
<874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="e15a6e7790c7684a121ff07a3ede6665";
logging-data="15397"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/TVCtZV9kbT0w0M7MbLA3h94kTwt4lStY="
Cancel-Lock: sha1:PV9K7Ri2K7YuWZiDd+Iwq79E7og=
sha1:C0WSIX4VedlH1QL/F4W31LhHb34=
X-BSB-Auth: 1.b942bd439d847ca9667f.20220514010023BST.87h75tugo8.fsf@bsb.me.uk
 by: Ben - Sat, 14 May 2022 00:00 UTC

olcott <NoOne@NoWhere.com> writes:

> On 5/13/2022 5:57 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/13/2022 3:58 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/13/2022 2:12 PM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/13/2022 1:45 PM, Ben wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> Flibble found a case where my member functions would need to be
>>>>>>>>> extended and this extension may have a worse Big-O than std::deque in
>>>>>>>>> some cases.
>>>>>>>>
>>>>>>>> As did everyone who glanced at the code for more than a few seconds. Or
>>>>>>>> at least I sincerely hope they did. It's not hard to see that your code
>>>>>>>> was wrong.
>>>>>>>
>>>>>>> The details of std::deque is almost brand new to me.
>>>>>>
>>>>>> I guessed as much. Yet you claimed to have done better than the teams
>>>>>> of experienced programmers who've worked on various C++ standard
>>>>>> libraries after writing only a few lines of code? That level of
>>>>>> delusion might lead someone to think they can solve the halting problem.
>>>>>
>>>>> None-the-less my version does perform better and is much simpler on
>>>>> the operations that I need.
>>>> What new delusion is this? Your "version" is not a deque. What is it a
>>>> version of? What does it perform better than?
>>>>
>>>>>>> None-the-less my Tape_Type does seem optimal for a TM tape as long as
>>>>>>> the speed with Tape_Type::reserve() beats some and matches the rest of
>>>>>>> the speed of every operation of your std::string, otherwise I would go
>>>>>>> for the simpler std::string version.
>>>>>>
>>>>>> Using reserve has no effect on the one test case I have for timing.
>>>>>
>>>>> What is the speed difference?
>>>>
>>>> Not reliably measurable. I could do more robust tests but that's not
>>>> what I want to do today.
>>>
>>> This always works well for me.
>>> https://www.tutorialspoint.com/c_standard_library/c_function_clock.htm
>> It's not a method I like. When yours program is working, you can
>> do timings any way you like. (And since the code is C++ you might want
>> to look at std::chrono::high_resolution_clock.)
>>
>>> I want to know if your version is better than mine.
>>> When I am all done I want to have the best version.
>> Well, it's better because it's finished. It may be worse in other ways,
>> but you don't say what "best" means to you.
>
> Mine is certainly designed to scale so on this basis I will keep mine.

You don't have a TM interpreter yet! So presumably you mean you'll keep
your design even though you don't know if mine scales. You have always
stated strong opinions based on little knowledge.

--
Ben.
"le génie humain a des limites, quand la bêtise humaine n’en a pas"
Alexandre Dumas (fils)

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<f8ednbx2fY4Cb-P_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32427&group=comp.theory#32427

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 13 May 2022 19:06:55 -0500
Date: Fri, 13 May 2022 19:06:56 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
Content-Language: en-US
Newsgroups: comp.theory
References: <t541t8$upu$1@dont-email.me> <874k1v5xll.fsf@bsb.me.uk>
<2eOdnW7GpMwx6OH_nZ2dnUU7_81g4p2d@giganews.com> <87y1z650gu.fsf@bsb.me.uk>
<XdadnZj8avjLteD_nZ2dnUU7_8zNnZ2d@giganews.com> <875yma4i6b.fsf@bsb.me.uk>
<oZadnf2QMLKV8uD_nZ2dnUU7_8zNnZ2d@giganews.com> <87tu9u31nv.fsf@bsb.me.uk>
<X9mdnVTySoUr5eD_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<t5mh9a$l6h$1@dont-email.me> <69mdnUv8GvgFV-P_nZ2dnUU7_83NnZ2d@giganews.com>
<t5mqo1$h5o$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t5mqo1$h5o$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <f8ednbx2fY4Cb-P_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 73
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-NCHOrRDFsFCovLjZ1oRVTOUBwt+DQJIOXNNXqOopcaxGudqBW53MWg4O9IF6ptWSe9dv8qn+7y2Cga1!XqDGnfBqMckKhgFiiJ4xJnQTBxnDSSj8d94Pb2QXTJpCVe//E9wSEa89qiEOikaPQaadvk1k2xM=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5462
 by: olcott - Sat, 14 May 2022 00:06 UTC

On 5/13/2022 6:48 PM, Jeff Barnett wrote:
> On 5/13/2022 3:16 PM, olcott wrote:
>> On 5/13/2022 4:06 PM, Jeff Barnett wrote:
>>> On 5/13/2022 1:12 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/13/2022 1:45 PM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> Flibble found a case where my member functions would need to be
>>>>>>> extended and this extension may have a worse Big-O than
>>>>>>> std::deque in
>>>>>>> some cases.
>>>>>>
>>>>>> As did everyone who glanced at the code for more than a few
>>>>>> seconds.  Or
>>>>>> at least I sincerely hope they did.  It's not hard to see that
>>>>>> your code
>>>>>> was wrong.
>>>>>
>>>>> The details of std::deque is almost brand new to me.
>>>>
>>>> I guessed as much.  Yet you claimed to have done better than the teams
>>>> of experienced programmers who've worked on various C++ standard
>>>> libraries after writing only a few lines of code?  That level of
>>>> delusion might lead someone to think they can solve the halting
>>>> problem.
>>>>
>>>>> None-the-less my Tape_Type does seem optimal for a TM tape as long as
>>>>> the speed with Tape_Type::reserve() beats some and matches the rest of
>>>>> the speed of every operation of your std::string, otherwise I would go
>>>>> for the simpler std::string version.
>>>>
>>>> Using reserve has no effect on the one test case I have for timing.
>>> Everyone as noted and/or commented on the fact that PO does not read
>>> all that he cites or all that he criticizes. My conjecture is that he
>>> has a learning disability that is manifest in his inability to stay
>>> focused on or retain what he reads.
>>>
>>> Take this TM implementation nonsense: a few years ago many of us
>>> (including me) suggested TM testers and interpreters. He refused to
>>> use them at that time and now is trying to implement one himself. I
>>> don't think that it's for fun or curiosity. I think its because he
>>> cannot keep several ideas in his head at the same time. And what is
>>> this nonsense about rewriting part of the C library? I think that
>>> retaining enough of the documentation to use the existing package is
>>> beyond his reading and retaining abilities. So there is a desperate
>>> hope that he might be able to learn it by doing. The problem is that
>>> he must fog the landscape with obscurities to hide the display of his
>>> inabilities behind.
>>>
>>> If you have a moment to reflect, see if this viewpoint explains some
>>> or all of the exhibitions of the last few years to you. I'd be
>>> interested in what you think.
>>
>> My original intent was to rewrite this to give it a three minute
>> learning curve. http://www.lns.mit.edu/~dsw/turing/turing.html
>>
>> It is also useful for me to understand TM's better by writing one from
>> scratch.
> And what did you learn by badly miscoding part of the C library? <-
> that's a sarcastic question mark.

Tape_Type does seem to be an optimal way to define a TM tape in C++,
thus providing the other aspect of my design that has unlimited
scalability. Scalable state change is the other aspect.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32428&group=comp.theory#32428

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 13 May 2022 19:09:13 -0500
Date: Fri, 13 May 2022 19:09:14 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
Content-Language: en-US
Newsgroups: comp.theory
References: <t541t8$upu$1@dont-email.me> <87tu9u31nv.fsf@bsb.me.uk>
<X9mdnVTySoUr5eD_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com> <87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com> <874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com> <87h75tugo8.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87h75tugo8.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 74
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-vtitzib7M+nTnWvAUZQ/bgHqYMI0SgWJyyWvvtrImdHs/QDmTfZJUNcJ/gdUqD7Kx+0lCXvyyDwGyEs!e7ODJhs5w15+nOxZ0jYItz7gT36D/3OfMGa4SzyHL89nIzEsOlABAJrXPmDSxM/x9Br0HEzep3c=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5139
 by: olcott - Sat, 14 May 2022 00:09 UTC

On 5/13/2022 7:00 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 5/13/2022 5:57 PM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/13/2022 3:58 PM, Ben wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/13/2022 2:12 PM, Ben wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/13/2022 1:45 PM, Ben wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> Flibble found a case where my member functions would need to be
>>>>>>>>>> extended and this extension may have a worse Big-O than std::deque in
>>>>>>>>>> some cases.
>>>>>>>>>
>>>>>>>>> As did everyone who glanced at the code for more than a few seconds. Or
>>>>>>>>> at least I sincerely hope they did. It's not hard to see that your code
>>>>>>>>> was wrong.
>>>>>>>>
>>>>>>>> The details of std::deque is almost brand new to me.
>>>>>>>
>>>>>>> I guessed as much. Yet you claimed to have done better than the teams
>>>>>>> of experienced programmers who've worked on various C++ standard
>>>>>>> libraries after writing only a few lines of code? That level of
>>>>>>> delusion might lead someone to think they can solve the halting problem.
>>>>>>
>>>>>> None-the-less my version does perform better and is much simpler on
>>>>>> the operations that I need.
>>>>> What new delusion is this? Your "version" is not a deque. What is it a
>>>>> version of? What does it perform better than?
>>>>>
>>>>>>>> None-the-less my Tape_Type does seem optimal for a TM tape as long as
>>>>>>>> the speed with Tape_Type::reserve() beats some and matches the rest of
>>>>>>>> the speed of every operation of your std::string, otherwise I would go
>>>>>>>> for the simpler std::string version.
>>>>>>>
>>>>>>> Using reserve has no effect on the one test case I have for timing.
>>>>>>
>>>>>> What is the speed difference?
>>>>>
>>>>> Not reliably measurable. I could do more robust tests but that's not
>>>>> what I want to do today.
>>>>
>>>> This always works well for me.
>>>> https://www.tutorialspoint.com/c_standard_library/c_function_clock.htm
>>> It's not a method I like. When yours program is working, you can
>>> do timings any way you like. (And since the code is C++ you might want
>>> to look at std::chrono::high_resolution_clock.)
>>>
>>>> I want to know if your version is better than mine.
>>>> When I am all done I want to have the best version.
>>> Well, it's better because it's finished. It may be worse in other ways,
>>> but you don't say what "best" means to you.
>>
>> Mine is certainly designed to scale so on this basis I will keep mine.
>
> You don't have a TM interpreter yet! So presumably you mean you'll keep
> your design even though you don't know if mine scales. You have always
> stated strong opinions based on little knowledge.
>

Because of the simplicity that you claimed it probably could not quite
have the scalability that mine has.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<87zgjlt14r.fsf@bsb.me.uk>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32434&group=comp.theory#32434

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Validating that the implementation meets the spec for TM transition function [ best tape ]
Date: Sat, 14 May 2022 01:21:24 +0100
Organization: A noiseless patient Spider
Lines: 21
Message-ID: <87zgjlt14r.fsf@bsb.me.uk>
References: <t541t8$upu$1@dont-email.me> <874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com>
<87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com>
<87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com>
<87y1z5zoqu.fsf@bsb.me.uk> <20220513133840.0000732f@reddwarf.jmc>
<875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com>
<87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com>
<871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com>
<87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com>
<874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com>
<87h75tugo8.fsf@bsb.me.uk>
<f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="e15a6e7790c7684a121ff07a3ede6665";
logging-data="15397"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/pSD6aSJC++N6jY4oo5r0ylVPAyc3mghU="
Cancel-Lock: sha1:zbIp+kGzbukw9b4oYHaguY0iqlo=
sha1:vaRffNHrzau9pg4y5xszchAJ/Ns=
X-BSB-Auth: 1.3ee04f08ccd0f318cfbf.20220514012124BST.87zgjlt14r.fsf@bsb.me.uk
 by: Ben - Sat, 14 May 2022 00:21 UTC

olcott <NoOne@NoWhere.com> writes:

> On 5/13/2022 7:00 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:

>>> Mine is certainly designed to scale so on this basis I will keep mine.
>>
>> You don't have a TM interpreter yet! So presumably you mean you'll keep
>> your design even though you don't know if mine scales. You have always
>> stated strong opinions based on little knowledge.
>
> Because of the simplicity that you claimed it probably could not quite
> have the scalability that mine has.

Yours does not "scale" to even the simplest TM because it does not yet
exist.

--
Ben.
"le génie humain a des limites, quand la bêtise humaine n’en a pas"
Alexandre Dumas (fils)

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<t5n1pu$oga$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32445&group=comp.theory#32445

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: jbb...@notatt.com (Jeff Barnett)
Newsgroups: comp.theory
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
Date: Fri, 13 May 2022 19:48:40 -0600
Organization: A noiseless patient Spider
Lines: 67
Message-ID: <t5n1pu$oga$1@dont-email.me>
References: <t541t8$upu$1@dont-email.me> <874k1v5xll.fsf@bsb.me.uk>
<2eOdnW7GpMwx6OH_nZ2dnUU7_81g4p2d@giganews.com> <87y1z650gu.fsf@bsb.me.uk>
<XdadnZj8avjLteD_nZ2dnUU7_8zNnZ2d@giganews.com> <875yma4i6b.fsf@bsb.me.uk>
<oZadnf2QMLKV8uD_nZ2dnUU7_8zNnZ2d@giganews.com> <87tu9u31nv.fsf@bsb.me.uk>
<X9mdnVTySoUr5eD_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<t5mh9a$l6h$1@dont-email.me> <69mdnUv8GvgFV-P_nZ2dnUU7_83NnZ2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: base64
Injection-Date: Sat, 14 May 2022 01:48:46 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="0008a1c4b2ad15a2770c393bfa3f9d71";
logging-data="25098"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+WjPb4tXOdQBuBaeg5ghKYUR0xuz3VaO0="
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Cancel-Lock: sha1:1YfEN9Q7jQ8NSjnJ5eiF0k8wahs=
In-Reply-To: <69mdnUv8GvgFV-P_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Language: en-US
 by: Jeff Barnett - Sat, 14 May 2022 01:48 UTC

On 5/13/2022 3:16 PM, olcott wrote:
> On 5/13/2022 4:06 PM, Jeff Barnett wrote:
>> On 5/13/2022 1:12 PM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/13/2022 1:45 PM, Ben wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> Flibble found a case where my member functions would need to be
>>>>>> extended and this extension may have a worse Big-O than std::deque in
>>>>>> some cases.
>>>>>
>>>>> As did everyone who glanced at the code for more than a few
>>>>> seconds.  Or
>>>>> at least I sincerely hope they did.  It's not hard to see that your
>>>>> code
>>>>> was wrong.
>>>>
>>>> The details of std::deque is almost brand new to me.
>>>
>>> I guessed as much.  Yet you claimed to have done better than the teams
>>> of experienced programmers who've worked on various C++ standard
>>> libraries after writing only a few lines of code?  That level of
>>> delusion might lead someone to think they can solve the halting problem.
>>>
>>>> None-the-less my Tape_Type does seem optimal for a TM tape as long as
>>>> the speed with Tape_Type::reserve() beats some and matches the rest of
>>>> the speed of every operation of your std::string, otherwise I would go
>>>> for the simpler std::string version.
>>>
>>> Using reserve has no effect on the one test case I have for timing.
>> Everyone as noted and/or commented on the fact that PO does not read
>> all that he cites or all that he criticizes. My conjecture is that he
>> has a learning disability that is manifest in his inability to stay
>> focused on or retain what he reads.
>>
>> Take this TM implementation nonsense: a few years ago many of us
>> (including me) suggested TM testers and interpreters. He refused to
>> use them at that time and now is trying to implement one himself. I
>> don't think that it's for fun or curiosity. I think its because he
>> cannot keep several ideas in his head at the same time. And what is
>> this nonsense about rewriting part of the C library? I think that
>> retaining enough of the documentation to use the existing package is
>> beyond his reading and retaining abilities. So there is a desperate
>> hope that he might be able to learn it by doing. The problem is that
>> he must fog the landscape with obscurities to hide the display of his
>> inabilities behind.
>>
>> If you have a moment to reflect, see if this viewpoint explains some
>> or all of the exhibitions of the last few years to you. I'd be
>> interested in what you think.
>
> My original intent was to rewrite this to give it a three minute
> learning curve. http://www.lns.mit.edu/~dsw/turing/turing.html
>
> It is also useful for me to understand TM's better by writing one from
> scratch.
So you think the best way to learn a language is to write an interpreter
for it? That's just silly nonsense. You were unable to complete Ben's
first lesson - write a TM to accept even numbers with the numbers
represented base one. I honestly believe many kids in the last year or
two of grade school* could do that assignment. Crawl before you try to
walk. Tm interpreters are a dime a dozen. Use one of them and convince
yourself that you can do lesson one.
* I just sat in on a seminar discussing and describing efforts to add
computer engineering - development of computer artifacts such as
software - to the curriculum of all grades levels.Based on that and some
pilot studies, I believe the most kids could write that TM (EVEN) with
an interested teacher helping them learn about the basics.
--
Jeff Barnett

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<t5n2cd$r23$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32446&group=comp.theory#32446

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: jbb...@notatt.com (Jeff Barnett)
Newsgroups: comp.theory
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
Date: Fri, 13 May 2022 19:58:32 -0600
Organization: A noiseless patient Spider
Lines: 74
Message-ID: <t5n2cd$r23$1@dont-email.me>
References: <t541t8$upu$1@dont-email.me> <874k1v5xll.fsf@bsb.me.uk>
<2eOdnW7GpMwx6OH_nZ2dnUU7_81g4p2d@giganews.com> <87y1z650gu.fsf@bsb.me.uk>
<XdadnZj8avjLteD_nZ2dnUU7_8zNnZ2d@giganews.com> <875yma4i6b.fsf@bsb.me.uk>
<oZadnf2QMLKV8uD_nZ2dnUU7_8zNnZ2d@giganews.com> <87tu9u31nv.fsf@bsb.me.uk>
<X9mdnVTySoUr5eD_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<t5mh9a$l6h$1@dont-email.me> <69mdnUv8GvgFV-P_nZ2dnUU7_83NnZ2d@giganews.com>
<t5mqo1$h5o$1@dont-email.me> <f8ednbx2fY4Cb-P_nZ2dnUU7_81g4p2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: base64
Injection-Date: Sat, 14 May 2022 01:58:37 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="0008a1c4b2ad15a2770c393bfa3f9d71";
logging-data="27715"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/EcnD31BY8oTg30/wL6eqFAQ9egDxyRRc="
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Cancel-Lock: sha1:K1JMvhENuKPv8cNg31oDd8mcZeU=
In-Reply-To: <f8ednbx2fY4Cb-P_nZ2dnUU7_81g4p2d@giganews.com>
Content-Language: en-US
 by: Jeff Barnett - Sat, 14 May 2022 01:58 UTC

On 5/13/2022 6:06 PM, olcott wrote:
> On 5/13/2022 6:48 PM, Jeff Barnett wrote:
>> On 5/13/2022 3:16 PM, olcott wrote:
>>> On 5/13/2022 4:06 PM, Jeff Barnett wrote:
>>>> On 5/13/2022 1:12 PM, Ben wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/13/2022 1:45 PM, Ben wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> Flibble found a case where my member functions would need to be
>>>>>>>> extended and this extension may have a worse Big-O than
>>>>>>>> std::deque in
>>>>>>>> some cases.
>>>>>>>
>>>>>>> As did everyone who glanced at the code for more than a few
>>>>>>> seconds.  Or
>>>>>>> at least I sincerely hope they did.  It's not hard to see that
>>>>>>> your code
>>>>>>> was wrong.
>>>>>>
>>>>>> The details of std::deque is almost brand new to me.
>>>>>
>>>>> I guessed as much.  Yet you claimed to have done better than the teams
>>>>> of experienced programmers who've worked on various C++ standard
>>>>> libraries after writing only a few lines of code?  That level of
>>>>> delusion might lead someone to think they can solve the halting
>>>>> problem.
>>>>>
>>>>>> None-the-less my Tape_Type does seem optimal for a TM tape as long as
>>>>>> the speed with Tape_Type::reserve() beats some and matches the
>>>>>> rest of
>>>>>> the speed of every operation of your std::string, otherwise I
>>>>>> would go
>>>>>> for the simpler std::string version.
>>>>>
>>>>> Using reserve has no effect on the one test case I have for timing.
>>>> Everyone as noted and/or commented on the fact that PO does not read
>>>> all that he cites or all that he criticizes. My conjecture is that
>>>> he has a learning disability that is manifest in his inability to
>>>> stay focused on or retain what he reads.
>>>>
>>>> Take this TM implementation nonsense: a few years ago many of us
>>>> (including me) suggested TM testers and interpreters. He refused to
>>>> use them at that time and now is trying to implement one himself. I
>>>> don't think that it's for fun or curiosity. I think its because he
>>>> cannot keep several ideas in his head at the same time. And what is
>>>> this nonsense about rewriting part of the C library? I think that
>>>> retaining enough of the documentation to use the existing package is
>>>> beyond his reading and retaining abilities. So there is a desperate
>>>> hope that he might be able to learn it by doing. The problem is that
>>>> he must fog the landscape with obscurities to hide the display of
>>>> his inabilities behind.
>>>>
>>>> If you have a moment to reflect, see if this viewpoint explains some
>>>> or all of the exhibitions of the last few years to you. I'd be
>>>> interested in what you think.
>>>
>>> My original intent was to rewrite this to give it a three minute
>>> learning curve. http://www.lns.mit.edu/~dsw/turing/turing.html
>>>
>>> It is also useful for me to understand TM's better by writing one
>>> from scratch.
>> And what did you learn by badly miscoding part of the C library? <-
>> that's a sarcastic question mark.
>
> Tape_Type does seem to be an optimal way to define a TM tape in C++,
> thus providing the other aspect of my design that has unlimited
> scalability. Scalable state change is the other aspect.
Are you doing indefinite precision address pointers, etc? Or are you
smoking dope again? This is absurd! You have memory sizes of dozens (or
hundreds) of gigabytes and disk arrays of dozens or hundreds of
terabytes. So how far are you going to scale up? Are you going to add
offline disk arrays that swap with the ones online? So are you going to
to set a world record?
Or the real question: How much smoke are you going to blow to cover up
the fact that you can't do lesson one? You know the one. Write a TM that
accepts even numbers where numbers are encode base one, i.e., the length
of the string is the number?
--
Jeff Barnett

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<7bednRyhFMzqueL_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32451&group=comp.theory#32451

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 13 May 2022 22:39:35 -0500
Date: Fri, 13 May 2022 22:39:36 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
Content-Language: en-US
Newsgroups: comp.theory
References: <t541t8$upu$1@dont-email.me> <874k1v5xll.fsf@bsb.me.uk>
<2eOdnW7GpMwx6OH_nZ2dnUU7_81g4p2d@giganews.com> <87y1z650gu.fsf@bsb.me.uk>
<XdadnZj8avjLteD_nZ2dnUU7_8zNnZ2d@giganews.com> <875yma4i6b.fsf@bsb.me.uk>
<oZadnf2QMLKV8uD_nZ2dnUU7_8zNnZ2d@giganews.com> <87tu9u31nv.fsf@bsb.me.uk>
<X9mdnVTySoUr5eD_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<t5mh9a$l6h$1@dont-email.me> <69mdnUv8GvgFV-P_nZ2dnUU7_83NnZ2d@giganews.com>
<t5mqo1$h5o$1@dont-email.me> <f8ednbx2fY4Cb-P_nZ2dnUU7_81g4p2d@giganews.com>
<t5n2cd$r23$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t5n2cd$r23$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <7bednRyhFMzqueL_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 96
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-gLtgk+9uCs3/FUoMma74id6IxLLoHfGwjpvO6QNTusCEBRCPAlSUnP20ftPT+e6omkQ1BM9+abfFQKW!Go008hsXhjuOPiO4BMSooFcLX3HQAKJ+o1tZV4zLbdekSda71WiALtFuoWNeYG//XDakoil5Kyc=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6484
 by: olcott - Sat, 14 May 2022 03:39 UTC

On 5/13/2022 8:58 PM, Jeff Barnett wrote:
> On 5/13/2022 6:06 PM, olcott wrote:
>> On 5/13/2022 6:48 PM, Jeff Barnett wrote:
>>> On 5/13/2022 3:16 PM, olcott wrote:
>>>> On 5/13/2022 4:06 PM, Jeff Barnett wrote:
>>>>> On 5/13/2022 1:12 PM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/13/2022 1:45 PM, Ben wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> Flibble found a case where my member functions would need to be
>>>>>>>>> extended and this extension may have a worse Big-O than
>>>>>>>>> std::deque in
>>>>>>>>> some cases.
>>>>>>>>
>>>>>>>> As did everyone who glanced at the code for more than a few
>>>>>>>> seconds.  Or
>>>>>>>> at least I sincerely hope they did.  It's not hard to see that
>>>>>>>> your code
>>>>>>>> was wrong.
>>>>>>>
>>>>>>> The details of std::deque is almost brand new to me.
>>>>>>
>>>>>> I guessed as much.  Yet you claimed to have done better than the
>>>>>> teams
>>>>>> of experienced programmers who've worked on various C++ standard
>>>>>> libraries after writing only a few lines of code?  That level of
>>>>>> delusion might lead someone to think they can solve the halting
>>>>>> problem.
>>>>>>
>>>>>>> None-the-less my Tape_Type does seem optimal for a TM tape as
>>>>>>> long as
>>>>>>> the speed with Tape_Type::reserve() beats some and matches the
>>>>>>> rest of
>>>>>>> the speed of every operation of your std::string, otherwise I
>>>>>>> would go
>>>>>>> for the simpler std::string version.
>>>>>>
>>>>>> Using reserve has no effect on the one test case I have for timing.
>>>>> Everyone as noted and/or commented on the fact that PO does not
>>>>> read all that he cites or all that he criticizes. My conjecture is
>>>>> that he has a learning disability that is manifest in his inability
>>>>> to stay focused on or retain what he reads.
>>>>>
>>>>> Take this TM implementation nonsense: a few years ago many of us
>>>>> (including me) suggested TM testers and interpreters. He refused to
>>>>> use them at that time and now is trying to implement one himself. I
>>>>> don't think that it's for fun or curiosity. I think its because he
>>>>> cannot keep several ideas in his head at the same time. And what is
>>>>> this nonsense about rewriting part of the C library? I think that
>>>>> retaining enough of the documentation to use the existing package
>>>>> is beyond his reading and retaining abilities. So there is a
>>>>> desperate hope that he might be able to learn it by doing. The
>>>>> problem is that he must fog the landscape with obscurities to hide
>>>>> the display of his inabilities behind.
>>>>>
>>>>> If you have a moment to reflect, see if this viewpoint explains
>>>>> some or all of the exhibitions of the last few years to you. I'd be
>>>>> interested in what you think.
>>>>
>>>> My original intent was to rewrite this to give it a three minute
>>>> learning curve. http://www.lns.mit.edu/~dsw/turing/turing.html
>>>>
>>>> It is also useful for me to understand TM's better by writing one
>>>> from scratch.
>>> And what did you learn by badly miscoding part of the C library? <-
>>> that's a sarcastic question mark.
>>
>> Tape_Type does seem to be an optimal way to define a TM tape in C++,
>> thus providing the other aspect of my design that has unlimited
>> scalability. Scalable state change is the other aspect.
>
> Are you doing indefinite precision address pointers, etc? Or are you
> smoking dope again? This is absurd! You have memory sizes of dozens (or
> hundreds) of gigabytes and disk arrays of dozens or hundreds of
> terabytes. So how far are you going to scale up?

At least 4GB

> Are you going to add
> offline disk arrays that swap with the ones online? So are you going to
> to set a world record?
>
> Or the real question: How much smoke are you going to blow to cover up
> the fact that you can't do lesson one? You know the one. Write a TM that
> accepts even numbers where numbers are encode base one, i.e., the length
> of the string is the number?

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32458&group=comp.theory#32458

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:622a:3cf:b0:2f3:ec70:4e72 with SMTP id k15-20020a05622a03cf00b002f3ec704e72mr7964032qtx.61.1652518480485;
Sat, 14 May 2022 01:54:40 -0700 (PDT)
X-Received: by 2002:a81:6d15:0:b0:2f8:272e:f34e with SMTP id
i21-20020a816d15000000b002f8272ef34emr9687986ywc.112.1652518480195; Sat, 14
May 2022 01:54:40 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 14 May 2022 01:54:39 -0700 (PDT)
In-Reply-To: <f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:d1d4:fd2f:31d3:8f45;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:d1d4:fd2f:31d3:8f45
References: <t541t8$upu$1@dont-email.me> <87tu9u31nv.fsf@bsb.me.uk>
<X9mdnVTySoUr5eD_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com> <87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com> <874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com> <87h75tugo8.fsf@bsb.me.uk> <f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com>
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Sat, 14 May 2022 08:54:40 +0000
Content-Type: text/plain; charset="UTF-8"
 by: Malcolm McLean - Sat, 14 May 2022 08:54 UTC

On Saturday, 14 May 2022 at 01:09:20 UTC+1, olcott wrote:
> On 5/13/2022 7:00 PM, Ben wrote:
> > olcott <No...@NoWhere.com> writes:
> >
> >> On 5/13/2022 5:57 PM, Ben wrote:
> >>> olcott <No...@NoWhere.com> writes:
> >>>
> >>>> On 5/13/2022 3:58 PM, Ben wrote:
> >>>>> olcott <No...@NoWhere.com> writes:
> >>>>>
> >>>>>> On 5/13/2022 2:12 PM, Ben wrote:
> >>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>
> >>>>>>>> On 5/13/2022 1:45 PM, Ben wrote:
> >>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>
> >>>>>>>>>> Flibble found a case where my member functions would need to be
> >>>>>>>>>> extended and this extension may have a worse Big-O than std::deque in
> >>>>>>>>>> some cases.
> >>>>>>>>>
> >>>>>>>>> As did everyone who glanced at the code for more than a few seconds. Or
> >>>>>>>>> at least I sincerely hope they did. It's not hard to see that your code
> >>>>>>>>> was wrong.
> >>>>>>>>
> >>>>>>>> The details of std::deque is almost brand new to me.
> >>>>>>>
> >>>>>>> I guessed as much. Yet you claimed to have done better than the teams
> >>>>>>> of experienced programmers who've worked on various C++ standard
> >>>>>>> libraries after writing only a few lines of code? That level of
> >>>>>>> delusion might lead someone to think they can solve the halting problem.
> >>>>>>
> >>>>>> None-the-less my version does perform better and is much simpler on
> >>>>>> the operations that I need.
> >>>>> What new delusion is this? Your "version" is not a deque. What is it a
> >>>>> version of? What does it perform better than?
> >>>>>
> >>>>>>>> None-the-less my Tape_Type does seem optimal for a TM tape as long as
> >>>>>>>> the speed with Tape_Type::reserve() beats some and matches the rest of
> >>>>>>>> the speed of every operation of your std::string, otherwise I would go
> >>>>>>>> for the simpler std::string version.
> >>>>>>>
> >>>>>>> Using reserve has no effect on the one test case I have for timing.
> >>>>>>
> >>>>>> What is the speed difference?
> >>>>>
> >>>>> Not reliably measurable. I could do more robust tests but that's not
> >>>>> what I want to do today.
> >>>>
> >>>> This always works well for me.
> >>>> https://www.tutorialspoint.com/c_standard_library/c_function_clock.htm
> >>> It's not a method I like. When yours program is working, you can
> >>> do timings any way you like. (And since the code is C++ you might want
> >>> to look at std::chrono::high_resolution_clock.)
> >>>
> >>>> I want to know if your version is better than mine.
> >>>> When I am all done I want to have the best version.
> >>> Well, it's better because it's finished. It may be worse in other ways,
> >>> but you don't say what "best" means to you.
> >>
> >> Mine is certainly designed to scale so on this basis I will keep mine.
> >
> > You don't have a TM interpreter yet! So presumably you mean you'll keep
> > your design even though you don't know if mine scales. You have always
> > stated strong opinions based on little knowledge.
> >
> Because of the simplicity that you claimed it probably could not quite
> have the scalability that mine has.
>
You're using C++, so you need a class with the function to read the tape
at the current head position, a function to write a symbol to the tape at
the current head position, a function to move the head one place left,
and a function to move the head one place right.

Also you are going to need a function to read a "window" round the tape
head, for visualisation purposes. That will be the hardest part, because the
"window" can extend beyond the tape's physical bounds.

You might also need copy and "move" constructors, and maybe a constructor
to create a tape with initial contents (you could do this on top of the move
and write functions). You'll need a default constructor to create an
initially blank tape. Depending on your model, you might also have to write
an explicit destructor.

Good software engineering practice is to write the interface first, then write
a simple implementation that doesn't have to be efficient or to scale up
to long tapes. You then write a more efficient implementation later, if it is
required.

For an even odd decider, you won't need a very efficient tape at all. A human
can count values up to maybe 20 in unary notation, reliably. So you can really
only test for tapes with less than 20 symbols on them. That's tiny, even for a
ZX81.

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<P8WdnRjqkK8g7-L_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32459&group=comp.theory#32459

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 14 May 2022 04:13:32 -0500
Date: Sat, 14 May 2022 04:13:33 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
Content-Language: en-US
Newsgroups: comp.theory
References: <t541t8$upu$1@dont-email.me> <87tu9u31nv.fsf@bsb.me.uk>
<X9mdnVTySoUr5eD_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com> <87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com> <874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com> <87h75tugo8.fsf@bsb.me.uk>
<f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
<45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <P8WdnRjqkK8g7-L_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 181
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-IDy6iP6KUeens2bO+Ht9bscOYUUERlqXoBU1F9Szme+S5/npQaYXoZSfdiQxmIa/JALUOBRQQv+AFU8!8cTvcB6Dlm1jVjeVliJXoN96ZjqdouypJx+Ggvrnjr7A4/2GOKFbPgV8zksxz5e18Jq9VHZy8Fk=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 9040
 by: olcott - Sat, 14 May 2022 09:13 UTC

On 5/14/2022 3:54 AM, Malcolm McLean wrote:
> On Saturday, 14 May 2022 at 01:09:20 UTC+1, olcott wrote:
>> On 5/13/2022 7:00 PM, Ben wrote:
>>> olcott <No...@NoWhere.com> writes:
>>>
>>>> On 5/13/2022 5:57 PM, Ben wrote:
>>>>> olcott <No...@NoWhere.com> writes:
>>>>>
>>>>>> On 5/13/2022 3:58 PM, Ben wrote:
>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/13/2022 2:12 PM, Ben wrote:
>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 5/13/2022 1:45 PM, Ben wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> Flibble found a case where my member functions would need to be
>>>>>>>>>>>> extended and this extension may have a worse Big-O than std::deque in
>>>>>>>>>>>> some cases.
>>>>>>>>>>>
>>>>>>>>>>> As did everyone who glanced at the code for more than a few seconds. Or
>>>>>>>>>>> at least I sincerely hope they did. It's not hard to see that your code
>>>>>>>>>>> was wrong.
>>>>>>>>>>
>>>>>>>>>> The details of std::deque is almost brand new to me.
>>>>>>>>>
>>>>>>>>> I guessed as much. Yet you claimed to have done better than the teams
>>>>>>>>> of experienced programmers who've worked on various C++ standard
>>>>>>>>> libraries after writing only a few lines of code? That level of
>>>>>>>>> delusion might lead someone to think they can solve the halting problem.
>>>>>>>>
>>>>>>>> None-the-less my version does perform better and is much simpler on
>>>>>>>> the operations that I need.
>>>>>>> What new delusion is this? Your "version" is not a deque. What is it a
>>>>>>> version of? What does it perform better than?
>>>>>>>
>>>>>>>>>> None-the-less my Tape_Type does seem optimal for a TM tape as long as
>>>>>>>>>> the speed with Tape_Type::reserve() beats some and matches the rest of
>>>>>>>>>> the speed of every operation of your std::string, otherwise I would go
>>>>>>>>>> for the simpler std::string version.
>>>>>>>>>
>>>>>>>>> Using reserve has no effect on the one test case I have for timing.
>>>>>>>>
>>>>>>>> What is the speed difference?
>>>>>>>
>>>>>>> Not reliably measurable. I could do more robust tests but that's not
>>>>>>> what I want to do today.
>>>>>>
>>>>>> This always works well for me.
>>>>>> https://www.tutorialspoint.com/c_standard_library/c_function_clock.htm
>>>>> It's not a method I like. When yours program is working, you can
>>>>> do timings any way you like. (And since the code is C++ you might want
>>>>> to look at std::chrono::high_resolution_clock.)
>>>>>
>>>>>> I want to know if your version is better than mine.
>>>>>> When I am all done I want to have the best version.
>>>>> Well, it's better because it's finished. It may be worse in other ways,
>>>>> but you don't say what "best" means to you.
>>>>
>>>> Mine is certainly designed to scale so on this basis I will keep mine.
>>>
>>> You don't have a TM interpreter yet! So presumably you mean you'll keep
>>> your design even though you don't know if mine scales. You have always
>>> stated strong opinions based on little knowledge.
>>>
>> Because of the simplicity that you claimed it probably could not quite
>> have the scalability that mine has.
>>
> You're using C++, so you need a class with the function to read the tape
> at the current head position, a function to write a symbol to the tape at
> the current head position, a function to move the head one place left,
> and a function to move the head one place right.
>
> Also you are going to need a function to read a "window" round the tape
> head, for visualisation purposes. That will be the hardest part, because the
> "window" can extend beyond the tape's physical bounds.
>
> You might also need copy and "move" constructors, and maybe a constructor
> to create a tape with initial contents (you could do this on top of the move
> and write functions). You'll need a default constructor to create an
> initially blank tape. Depending on your model, you might also have to write
> an explicit destructor.
>
> Good software engineering practice is to write the interface first, then write
> a simple implementation that doesn't have to be efficient or to scale up
> to long tapes. You then write a more efficient implementation later, if it is
> required.
>
> For an even odd decider, you won't need a very efficient tape at all. A human
> can count values up to maybe 20 in unary notation, reliably. So you can really
> only test for tapes with less than 20 symbols on them. That's tiny, even for a
> ZX81.

typedef unsigned char tape_element;
// Tape_Type implements a two-way Turing machine tape.
// Right contains Tape_Head >= 0 values (right expansion)
// Left contains Tape_Head < 0 values (left expansion)
//
// Grows with Right.push_back() as Tape_Head increases above 0.
// Grows with Left.push_back() as Tape_Head decreases below 0.
//
// Tape_Type has functionality very similar to std::deque
// yet implements this functionality much more simply.
// This saves time and space.
//
class Tape_Type
{

private:
int Tape_Head = 0; // Can be negative
std::vector<tape_element> Left; // Stores left expansion
std::vector<tape_element> Right; // Stores right expansion

tape_element& operator[](int index)
{
return index >= 0 ? Right[index] : Left[-index - 1];
}

public:
tape_element& front( ) { return Left.back(); }
tape_element& back() { return Right.back(); }
void push_front(tape_element E) { Left.push_back(E); }
void push_back(tape_element E) { Right.push_back(E); }
void reserve(unsigned int N)
{ Left.reserve(N); Right.reserve(N); }

void Write(tape_element Y){ (*this)[Tape_Head] = Y; };
tape_element Read() { return (*this)[Tape_Head]; };

void move_head(char E)
{
if (E == 'L')
move_left();
else
move_right();
}

void move_left()
{
Tape_Head--;
int Left_Index = ((Tape_Head * -1) -1);
if (Left_Index == Left.size())
Left.push_back('_');
}

void move_right()
{
Tape_Head++;
if (Tape_Head == Right.size())
Right.push_back('_');
}

void Output()
{
printf("Tape_Type::Output()\n");
if (Left.size())
{
int Last_One = Left.size() - 1;
for (int N = Last_One; N >= 0; N--)
{
int TH = (N + 1) * -1; // determine Tape_Head from N
printf("[%04d]:%c Left[%02d]\n", TH, Left[N], N);
}
}
if (Right.size())
for (int N = 0; N < Right.size(); N++)
printf("[%04d]:%c Right[%02d]\n", N, Right[N], N);
}
};

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<6490efea-5b5c-4695-85c6-5cfb9a36709en@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32461&group=comp.theory#32461

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:4710:b0:6a0:110d:467b with SMTP id bs16-20020a05620a471000b006a0110d467bmr6578978qkb.179.1652524247867;
Sat, 14 May 2022 03:30:47 -0700 (PDT)
X-Received: by 2002:a0d:d88c:0:b0:2f7:bb41:1bd0 with SMTP id
a134-20020a0dd88c000000b002f7bb411bd0mr9892060ywe.199.1652524247661; Sat, 14
May 2022 03:30:47 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 14 May 2022 03:30:47 -0700 (PDT)
In-Reply-To: <P8WdnRjqkK8g7-L_nZ2dnUU7_83NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:d1d4:fd2f:31d3:8f45;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:d1d4:fd2f:31d3:8f45
References: <t541t8$upu$1@dont-email.me> <87tu9u31nv.fsf@bsb.me.uk>
<X9mdnVTySoUr5eD_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com> <87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com> <874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com> <87h75tugo8.fsf@bsb.me.uk>
<f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com> <45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com>
<P8WdnRjqkK8g7-L_nZ2dnUU7_83NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <6490efea-5b5c-4695-85c6-5cfb9a36709en@googlegroups.com>
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Sat, 14 May 2022 10:30:47 +0000
Content-Type: text/plain; charset="UTF-8"
 by: Malcolm McLean - Sat, 14 May 2022 10:30 UTC

On Saturday, 14 May 2022 at 10:13:40 UTC+1, olcott wrote:
> On 5/14/2022 3:54 AM, Malcolm McLean wrote:
> > On Saturday, 14 May 2022 at 01:09:20 UTC+1, olcott wrote:
> >> On 5/13/2022 7:00 PM, Ben wrote:
> >>> olcott <No...@NoWhere.com> writes:
> >>>
> >>>> On 5/13/2022 5:57 PM, Ben wrote:
> >>>>> olcott <No...@NoWhere.com> writes:
> >>>>>
> >>>>>> On 5/13/2022 3:58 PM, Ben wrote:
> >>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>
> >>>>>>>> On 5/13/2022 2:12 PM, Ben wrote:
> >>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>
> >>>>>>>>>> On 5/13/2022 1:45 PM, Ben wrote:
> >>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>
> >>>>>>>>>>>> Flibble found a case where my member functions would need to be
> >>>>>>>>>>>> extended and this extension may have a worse Big-O than std::deque in
> >>>>>>>>>>>> some cases.
> >>>>>>>>>>>
> >>>>>>>>>>> As did everyone who glanced at the code for more than a few seconds. Or
> >>>>>>>>>>> at least I sincerely hope they did. It's not hard to see that your code
> >>>>>>>>>>> was wrong.
> >>>>>>>>>>
> >>>>>>>>>> The details of std::deque is almost brand new to me.
> >>>>>>>>>
> >>>>>>>>> I guessed as much. Yet you claimed to have done better than the teams
> >>>>>>>>> of experienced programmers who've worked on various C++ standard
> >>>>>>>>> libraries after writing only a few lines of code? That level of
> >>>>>>>>> delusion might lead someone to think they can solve the halting problem.
> >>>>>>>>
> >>>>>>>> None-the-less my version does perform better and is much simpler on
> >>>>>>>> the operations that I need.
> >>>>>>> What new delusion is this? Your "version" is not a deque. What is it a
> >>>>>>> version of? What does it perform better than?
> >>>>>>>
> >>>>>>>>>> None-the-less my Tape_Type does seem optimal for a TM tape as long as
> >>>>>>>>>> the speed with Tape_Type::reserve() beats some and matches the rest of
> >>>>>>>>>> the speed of every operation of your std::string, otherwise I would go
> >>>>>>>>>> for the simpler std::string version.
> >>>>>>>>>
> >>>>>>>>> Using reserve has no effect on the one test case I have for timing.
> >>>>>>>>
> >>>>>>>> What is the speed difference?
> >>>>>>>
> >>>>>>> Not reliably measurable. I could do more robust tests but that's not
> >>>>>>> what I want to do today.
> >>>>>>
> >>>>>> This always works well for me.
> >>>>>> https://www.tutorialspoint.com/c_standard_library/c_function_clock.htm
> >>>>> It's not a method I like. When yours program is working, you can
> >>>>> do timings any way you like. (And since the code is C++ you might want
> >>>>> to look at std::chrono::high_resolution_clock.)
> >>>>>
> >>>>>> I want to know if your version is better than mine.
> >>>>>> When I am all done I want to have the best version.
> >>>>> Well, it's better because it's finished. It may be worse in other ways,
> >>>>> but you don't say what "best" means to you.
> >>>>
> >>>> Mine is certainly designed to scale so on this basis I will keep mine.
> >>>
> >>> You don't have a TM interpreter yet! So presumably you mean you'll keep
> >>> your design even though you don't know if mine scales. You have always
> >>> stated strong opinions based on little knowledge.
> >>>
> >> Because of the simplicity that you claimed it probably could not quite
> >> have the scalability that mine has.
> >>
> > You're using C++, so you need a class with the function to read the tape
> > at the current head position, a function to write a symbol to the tape at
> > the current head position, a function to move the head one place left,
> > and a function to move the head one place right.
> >
> > Also you are going to need a function to read a "window" round the tape
> > head, for visualisation purposes. That will be the hardest part, because the
> > "window" can extend beyond the tape's physical bounds.
> >
> > You might also need copy and "move" constructors, and maybe a constructor
> > to create a tape with initial contents (you could do this on top of the move
> > and write functions). You'll need a default constructor to create an
> > initially blank tape. Depending on your model, you might also have to write
> > an explicit destructor.
> >
> > Good software engineering practice is to write the interface first, then write
> > a simple implementation that doesn't have to be efficient or to scale up
> > to long tapes. You then write a more efficient implementation later, if it is
> > required.
> >
> > For an even odd decider, you won't need a very efficient tape at all. A human
> > can count values up to maybe 20 in unary notation, reliably. So you can really
> > only test for tapes with less than 20 symbols on them. That's tiny, even for a
> > ZX81.
> typedef unsigned char tape_element;
> // Tape_Type implements a two-way Turing machine tape.
> // Right contains Tape_Head >= 0 values (right expansion)
> // Left contains Tape_Head < 0 values (left expansion)
> //
> // Grows with Right.push_back() as Tape_Head increases above 0.
> // Grows with Left.push_back() as Tape_Head decreases below 0.
> //
> // Tape_Type has functionality very similar to std::deque
> // yet implements this functionality much more simply.
> // This saves time and space.
> //
> class Tape_Type
> {
>
> private:
> int Tape_Head = 0; // Can be negative
> std::vector<tape_element> Left; // Stores left expansion
> std::vector<tape_element> Right; // Stores right expansion
>
> tape_element& operator[](int index)
> {
> return index >= 0 ? Right[index] : Left[-index - 1];
> }
>
> public:
> tape_element& front( ) { return Left.back(); }
> tape_element& back() { return Right.back(); }
> void push_front(tape_element E) { Left.push_back(E); }
> void push_back(tape_element E) { Right.push_back(E); }
> void reserve(unsigned int N)
> { Left.reserve(N); Right.reserve(N); }
>
All above this should be "private". The tape only has move one space left / right
(either one function or two, it doesn't matter), Read() and Write() as public
members. That's for the strict Turing machine.
You'll also want an output function for visualisation, testing, and debugging,
which you've written.
> void Write(tape_element Y){ (*this)[Tape_Head] = Y; };
> tape_element Read() { return (*this)[Tape_Head]; };
>
> void move_head(char E)
> {
> if (E == 'L')
> move_left();
> else
> move_right();
> }
>
> void move_left()
> {
> Tape_Head--;
> int Left_Index = ((Tape_Head * -1) -1);
> if (Left_Index == Left.size())
> Left.push_back('_');
> }
>
> void move_right()
> {
> Tape_Head++;
> if (Tape_Head == Right.size())
> Right.push_back('_');
> }
>
> void Output()
> {
> printf("Tape_Type::Output()\n");
> if (Left.size())
> {
> int Last_One = Left.size() - 1;
> for (int N = Last_One; N >= 0; N--)
> {
> int TH = (N + 1) * -1; // determine Tape_Head from N
> printf("[%04d]:%c Left[%02d]\n", TH, Left[N], N);
> }
> }
> if (Right.size())
> for (int N = 0; N < Right.size(); N++)
> printf("[%04d]:%c Right[%02d]\n", N, Right[N], N);
> }
> };
>
A model with two vectors which grow form the initial zero position in opposite
directions is fine. The current tape position is the Tape_Head.variable, which is
a signed integer giving offset form the initial zero position. Again, that's fine.


Click here to read the complete article
Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<87czggtims.fsf@bsb.me.uk>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32462&group=comp.theory#32462

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Validating that the implementation meets the spec for TM transition function [ best tape ]
Date: Sat, 14 May 2022 13:15:39 +0100
Organization: A noiseless patient Spider
Lines: 11
Message-ID: <87czggtims.fsf@bsb.me.uk>
References: <t541t8$upu$1@dont-email.me>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com>
<87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com>
<87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com>
<87y1z5zoqu.fsf@bsb.me.uk> <20220513133840.0000732f@reddwarf.jmc>
<875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com>
<87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com>
<871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com>
<87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com>
<874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com>
<87h75tugo8.fsf@bsb.me.uk>
<f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
<45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com>
MIME-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="e15a6e7790c7684a121ff07a3ede6665";
logging-data="6527"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/DJsoWO7fz9IWTIXdlT/AJByRiGydhAKs="
Cancel-Lock: sha1:4gOb5mXpBglXF4dkVSKPHbTQ1TI=
sha1:afOCXZtB/O/Kv4NTGbefh8mZyK4=
X-BSB-Auth: 1.7da5c4beb6f50e2daa77.20220514131539BST.87czggtims.fsf@bsb.me.uk
 by: Ben - Sat, 14 May 2022 12:15 UTC

Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

> For an even odd decider, you won't need a very efficient tape at all. A human
> can count values up to maybe 20 in unary notation, reliably. So you can really
> only test for tapes with less than 20 symbols on them.

That's an odd remark. Why should the test be limited to what I can
count visually?

--
Ben.

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<Z9-dnbNQ54lnLuL_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32466&group=comp.theory#32466

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 14 May 2022 08:51:54 -0500
Date: Sat, 14 May 2022 08:51:54 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
Content-Language: en-US
Newsgroups: comp.theory
References: <t541t8$upu$1@dont-email.me>
<X9mdnVTySoUr5eD_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com> <87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com> <874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com> <87h75tugo8.fsf@bsb.me.uk>
<f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
<45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com>
<P8WdnRjqkK8g7-L_nZ2dnUU7_83NnZ2d@giganews.com>
<6490efea-5b5c-4695-85c6-5cfb9a36709en@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <6490efea-5b5c-4695-85c6-5cfb9a36709en@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <Z9-dnbNQ54lnLuL_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 196
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-HErn0z65xoUbyxRoAU81SHLH7vckbFr+HlQsQlIhS5Og1K/d2PYckiWvijLVaHh2m5zWtZC8m2yuNUb!CsupFz/FGg+ECl5Ohzl1avJaH3Nq2Dt8rlJGfg1MD1Pj3XskA8R+EqZt07+1mZ2hIxpHOgUyNjw=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 10228
 by: olcott - Sat, 14 May 2022 13:51 UTC

On 5/14/2022 5:30 AM, Malcolm McLean wrote:
> On Saturday, 14 May 2022 at 10:13:40 UTC+1, olcott wrote:
>> On 5/14/2022 3:54 AM, Malcolm McLean wrote:
>>> On Saturday, 14 May 2022 at 01:09:20 UTC+1, olcott wrote:
>>>> On 5/13/2022 7:00 PM, Ben wrote:
>>>>> olcott <No...@NoWhere.com> writes:
>>>>>
>>>>>> On 5/13/2022 5:57 PM, Ben wrote:
>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/13/2022 3:58 PM, Ben wrote:
>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 5/13/2022 2:12 PM, Ben wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 5/13/2022 1:45 PM, Ben wrote:
>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Flibble found a case where my member functions would need to be
>>>>>>>>>>>>>> extended and this extension may have a worse Big-O than std::deque in
>>>>>>>>>>>>>> some cases.
>>>>>>>>>>>>>
>>>>>>>>>>>>> As did everyone who glanced at the code for more than a few seconds. Or
>>>>>>>>>>>>> at least I sincerely hope they did. It's not hard to see that your code
>>>>>>>>>>>>> was wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> The details of std::deque is almost brand new to me.
>>>>>>>>>>>
>>>>>>>>>>> I guessed as much. Yet you claimed to have done better than the teams
>>>>>>>>>>> of experienced programmers who've worked on various C++ standard
>>>>>>>>>>> libraries after writing only a few lines of code? That level of
>>>>>>>>>>> delusion might lead someone to think they can solve the halting problem.
>>>>>>>>>>
>>>>>>>>>> None-the-less my version does perform better and is much simpler on
>>>>>>>>>> the operations that I need.
>>>>>>>>> What new delusion is this? Your "version" is not a deque. What is it a
>>>>>>>>> version of? What does it perform better than?
>>>>>>>>>
>>>>>>>>>>>> None-the-less my Tape_Type does seem optimal for a TM tape as long as
>>>>>>>>>>>> the speed with Tape_Type::reserve() beats some and matches the rest of
>>>>>>>>>>>> the speed of every operation of your std::string, otherwise I would go
>>>>>>>>>>>> for the simpler std::string version.
>>>>>>>>>>>
>>>>>>>>>>> Using reserve has no effect on the one test case I have for timing.
>>>>>>>>>>
>>>>>>>>>> What is the speed difference?
>>>>>>>>>
>>>>>>>>> Not reliably measurable. I could do more robust tests but that's not
>>>>>>>>> what I want to do today.
>>>>>>>>
>>>>>>>> This always works well for me.
>>>>>>>> https://www.tutorialspoint.com/c_standard_library/c_function_clock.htm
>>>>>>> It's not a method I like. When yours program is working, you can
>>>>>>> do timings any way you like. (And since the code is C++ you might want
>>>>>>> to look at std::chrono::high_resolution_clock.)
>>>>>>>
>>>>>>>> I want to know if your version is better than mine.
>>>>>>>> When I am all done I want to have the best version.
>>>>>>> Well, it's better because it's finished. It may be worse in other ways,
>>>>>>> but you don't say what "best" means to you.
>>>>>>
>>>>>> Mine is certainly designed to scale so on this basis I will keep mine.
>>>>>
>>>>> You don't have a TM interpreter yet! So presumably you mean you'll keep
>>>>> your design even though you don't know if mine scales. You have always
>>>>> stated strong opinions based on little knowledge.
>>>>>
>>>> Because of the simplicity that you claimed it probably could not quite
>>>> have the scalability that mine has.
>>>>
>>> You're using C++, so you need a class with the function to read the tape
>>> at the current head position, a function to write a symbol to the tape at
>>> the current head position, a function to move the head one place left,
>>> and a function to move the head one place right.
>>>
>>> Also you are going to need a function to read a "window" round the tape
>>> head, for visualisation purposes. That will be the hardest part, because the
>>> "window" can extend beyond the tape's physical bounds.
>>>
>>> You might also need copy and "move" constructors, and maybe a constructor
>>> to create a tape with initial contents (you could do this on top of the move
>>> and write functions). You'll need a default constructor to create an
>>> initially blank tape. Depending on your model, you might also have to write
>>> an explicit destructor.
>>>
>>> Good software engineering practice is to write the interface first, then write
>>> a simple implementation that doesn't have to be efficient or to scale up
>>> to long tapes. You then write a more efficient implementation later, if it is
>>> required.
>>>
>>> For an even odd decider, you won't need a very efficient tape at all. A human
>>> can count values up to maybe 20 in unary notation, reliably. So you can really
>>> only test for tapes with less than 20 symbols on them. That's tiny, even for a
>>> ZX81.
>> typedef unsigned char tape_element;
>> // Tape_Type implements a two-way Turing machine tape.
>> // Right contains Tape_Head >= 0 values (right expansion)
>> // Left contains Tape_Head < 0 values (left expansion)
>> //
>> // Grows with Right.push_back() as Tape_Head increases above 0.
>> // Grows with Left.push_back() as Tape_Head decreases below 0.
>> //
>> // Tape_Type has functionality very similar to std::deque
>> // yet implements this functionality much more simply.
>> // This saves time and space.
>> //
>> class Tape_Type
>> {
>>
>> private:
>> int Tape_Head = 0; // Can be negative
>> std::vector<tape_element> Left; // Stores left expansion
>> std::vector<tape_element> Right; // Stores right expansion
>>
>> tape_element& operator[](int index)
>> {
>> return index >= 0 ? Right[index] : Left[-index - 1];
>> }
>>
>> public:
>> tape_element& front( ) { return Left.back(); }
>> tape_element& back() { return Right.back(); }
>> void push_front(tape_element E) { Left.push_back(E); }
>> void push_back(tape_element E) { Right.push_back(E); }
>> void reserve(unsigned int N)
>> { Left.reserve(N); Right.reserve(N); }
>>
> All above this should be "private". The tape only has move one space left / right
> (either one function or two, it doesn't matter), Read() and Write() as public
> members. That's for the strict Turing machine.
> You'll also want an output function for visualisation, testing, and debugging,
> which you've written.
>> void Write(tape_element Y){ (*this)[Tape_Head] = Y; };
>> tape_element Read() { return (*this)[Tape_Head]; };
>>
>> void move_head(char E)
>> {
>> if (E == 'L')
>> move_left();
>> else
>> move_right();
>> }
>>
>> void move_left()
>> {
>> Tape_Head--;
>> int Left_Index = ((Tape_Head * -1) -1);
>> if (Left_Index == Left.size())
>> Left.push_back('_');
>> }
>>
>> void move_right()
>> {
>> Tape_Head++;
>> if (Tape_Head == Right.size())
>> Right.push_back('_');
>> }
>>
>> void Output()
>> {
>> printf("Tape_Type::Output()\n");
>> if (Left.size())
>> {
>> int Last_One = Left.size() - 1;
>> for (int N = Last_One; N >= 0; N--)
>> {
>> int TH = (N + 1) * -1; // determine Tape_Head from N
>> printf("[%04d]:%c Left[%02d]\n", TH, Left[N], N);
>> }
>> }
>> if (Right.size())
>> for (int N = 0; N < Right.size(); N++)
>> printf("[%04d]:%c Right[%02d]\n", N, Right[N], N);
>> }
>> };
>>
> A model with two vectors which grow form the initial zero position in opposite
> directions is fine. The current tape position is the Tape_Head.variable, which is
> a signed integer giving offset form the initial zero position. Again, that's fine.
>
> I'll think you'll find you need a less wordy "Output()" function, however.
> One advantage of Turing machines is that the symbols on the tape can be
> made human-readable. It's easy to scan a string of ascii characters which
> represents the current tape.
>
> Write some tests and see if this tape works.


Click here to read the complete article
Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<d6a83e4a-59b7-4d4f-aba4-b17483f2af87n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32485&group=comp.theory#32485

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:622a:1210:b0:2f3:da26:3778 with SMTP id y16-20020a05622a121000b002f3da263778mr9720164qtx.173.1652553466021;
Sat, 14 May 2022 11:37:46 -0700 (PDT)
X-Received: by 2002:a81:ad28:0:b0:2f7:b931:1074 with SMTP id
l40-20020a81ad28000000b002f7b9311074mr11440657ywh.177.1652553465830; Sat, 14
May 2022 11:37:45 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 14 May 2022 11:37:45 -0700 (PDT)
In-Reply-To: <87czggtims.fsf@bsb.me.uk>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:d1d4:fd2f:31d3:8f45;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:d1d4:fd2f:31d3:8f45
References: <t541t8$upu$1@dont-email.me> <2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com>
<87pmki1edk.fsf@bsb.me.uk> <MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com>
<87wneqyz6w.fsf@bsb.me.uk> <IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com>
<87y1z5zoqu.fsf@bsb.me.uk> <20220513133840.0000732f@reddwarf.jmc>
<875ym9z9et.fsf@bsb.me.uk> <44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com>
<87ilq9xodt.fsf@bsb.me.uk> <OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com>
<871qwxxn4u.fsf@bsb.me.uk> <ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com>
<87fsldw3np.fsf@bsb.me.uk> <Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com>
<874k1tvy63.fsf@bsb.me.uk> <zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com>
<87h75tugo8.fsf@bsb.me.uk> <f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
<45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com> <87czggtims.fsf@bsb.me.uk>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <d6a83e4a-59b7-4d4f-aba4-b17483f2af87n@googlegroups.com>
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Sat, 14 May 2022 18:37:46 +0000
Content-Type: text/plain; charset="UTF-8"
X-Received-Bytes: 2806
 by: Malcolm McLean - Sat, 14 May 2022 18:37 UTC

On Saturday, 14 May 2022 at 13:15:44 UTC+1, Ben wrote:
> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>
> > For an even odd decider, you won't need a very efficient tape at all. A human
> > can count values up to maybe 20 in unary notation, reliably. So you can really
> > only test for tapes with less than 20 symbols on them.
> That's an odd remark. Why should the test be limited to what I can
> count visually?
>
You have 21 consecutive 1s on the tape. The even/odd decider reports "parity even".
Now is that because of a bug in the decider, or because you have miscounted the
number of 1s? If the number of 1s is below 20, you can use fingers and toes to
get reliable count, but when it is above 20, this option is unavialable, and there's no
way of knowing.

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<7ad347a3-6820-4292-8894-b256a08332ban@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32486&group=comp.theory#32486

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:7f43:0:b0:2f3:d55d:7296 with SMTP id g3-20020ac87f43000000b002f3d55d7296mr9618607qtk.635.1652553538142;
Sat, 14 May 2022 11:38:58 -0700 (PDT)
X-Received: by 2002:a81:7b46:0:b0:2e1:5ae7:5789 with SMTP id
w67-20020a817b46000000b002e15ae75789mr12450012ywc.61.1652553537913; Sat, 14
May 2022 11:38:57 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 14 May 2022 11:38:57 -0700 (PDT)
In-Reply-To: <Z9-dnbNQ54lnLuL_nZ2dnUU7_8xh4p2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:d1d4:fd2f:31d3:8f45;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:d1d4:fd2f:31d3:8f45
References: <t541t8$upu$1@dont-email.me> <X9mdnVTySoUr5eD_nZ2dnUU7_8zNnZ2d@giganews.com>
<874k1u2vc7.fsf@bsb.me.uk> <2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com>
<87pmki1edk.fsf@bsb.me.uk> <MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com>
<87wneqyz6w.fsf@bsb.me.uk> <IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com>
<87y1z5zoqu.fsf@bsb.me.uk> <20220513133840.0000732f@reddwarf.jmc>
<875ym9z9et.fsf@bsb.me.uk> <44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com>
<87ilq9xodt.fsf@bsb.me.uk> <OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com>
<871qwxxn4u.fsf@bsb.me.uk> <ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com>
<87fsldw3np.fsf@bsb.me.uk> <Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com>
<874k1tvy63.fsf@bsb.me.uk> <zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com>
<87h75tugo8.fsf@bsb.me.uk> <f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
<45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com> <P8WdnRjqkK8g7-L_nZ2dnUU7_83NnZ2d@giganews.com>
<6490efea-5b5c-4695-85c6-5cfb9a36709en@googlegroups.com> <Z9-dnbNQ54lnLuL_nZ2dnUU7_8xh4p2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <7ad347a3-6820-4292-8894-b256a08332ban@googlegroups.com>
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Sat, 14 May 2022 18:38:58 +0000
Content-Type: text/plain; charset="UTF-8"
 by: Malcolm McLean - Sat, 14 May 2022 18:38 UTC

On Saturday, 14 May 2022 at 14:52:01 UTC+1, olcott wrote:
> On 5/14/2022 5:30 AM, Malcolm McLean wrote:
> > On Saturday, 14 May 2022 at 10:13:40 UTC+1, olcott wrote:
> >> On 5/14/2022 3:54 AM, Malcolm McLean wrote:
> >>> On Saturday, 14 May 2022 at 01:09:20 UTC+1, olcott wrote:
> >>>> On 5/13/2022 7:00 PM, Ben wrote:
> >>>>> olcott <No...@NoWhere.com> writes:
> >>>>>
> >>>>>> On 5/13/2022 5:57 PM, Ben wrote:
> >>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>
> >>>>>>>> On 5/13/2022 3:58 PM, Ben wrote:
> >>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>
> >>>>>>>>>> On 5/13/2022 2:12 PM, Ben wrote:
> >>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 5/13/2022 1:45 PM, Ben wrote:
> >>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> Flibble found a case where my member functions would need to be
> >>>>>>>>>>>>>> extended and this extension may have a worse Big-O than std::deque in
> >>>>>>>>>>>>>> some cases.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> As did everyone who glanced at the code for more than a few seconds. Or
> >>>>>>>>>>>>> at least I sincerely hope they did. It's not hard to see that your code
> >>>>>>>>>>>>> was wrong.
> >>>>>>>>>>>>
> >>>>>>>>>>>> The details of std::deque is almost brand new to me.
> >>>>>>>>>>>
> >>>>>>>>>>> I guessed as much. Yet you claimed to have done better than the teams
> >>>>>>>>>>> of experienced programmers who've worked on various C++ standard
> >>>>>>>>>>> libraries after writing only a few lines of code? That level of
> >>>>>>>>>>> delusion might lead someone to think they can solve the halting problem.
> >>>>>>>>>>
> >>>>>>>>>> None-the-less my version does perform better and is much simpler on
> >>>>>>>>>> the operations that I need.
> >>>>>>>>> What new delusion is this? Your "version" is not a deque. What is it a
> >>>>>>>>> version of? What does it perform better than?
> >>>>>>>>>
> >>>>>>>>>>>> None-the-less my Tape_Type does seem optimal for a TM tape as long as
> >>>>>>>>>>>> the speed with Tape_Type::reserve() beats some and matches the rest of
> >>>>>>>>>>>> the speed of every operation of your std::string, otherwise I would go
> >>>>>>>>>>>> for the simpler std::string version.
> >>>>>>>>>>>
> >>>>>>>>>>> Using reserve has no effect on the one test case I have for timing.
> >>>>>>>>>>
> >>>>>>>>>> What is the speed difference?
> >>>>>>>>>
> >>>>>>>>> Not reliably measurable. I could do more robust tests but that's not
> >>>>>>>>> what I want to do today.
> >>>>>>>>
> >>>>>>>> This always works well for me.
> >>>>>>>> https://www.tutorialspoint.com/c_standard_library/c_function_clock.htm
> >>>>>>> It's not a method I like. When yours program is working, you can
> >>>>>>> do timings any way you like. (And since the code is C++ you might want
> >>>>>>> to look at std::chrono::high_resolution_clock.)
> >>>>>>>
> >>>>>>>> I want to know if your version is better than mine.
> >>>>>>>> When I am all done I want to have the best version.
> >>>>>>> Well, it's better because it's finished. It may be worse in other ways,
> >>>>>>> but you don't say what "best" means to you.
> >>>>>>
> >>>>>> Mine is certainly designed to scale so on this basis I will keep mine.
> >>>>>
> >>>>> You don't have a TM interpreter yet! So presumably you mean you'll keep
> >>>>> your design even though you don't know if mine scales. You have always
> >>>>> stated strong opinions based on little knowledge.
> >>>>>
> >>>> Because of the simplicity that you claimed it probably could not quite
> >>>> have the scalability that mine has.
> >>>>
> >>> You're using C++, so you need a class with the function to read the tape
> >>> at the current head position, a function to write a symbol to the tape at
> >>> the current head position, a function to move the head one place left,
> >>> and a function to move the head one place right.
> >>>
> >>> Also you are going to need a function to read a "window" round the tape
> >>> head, for visualisation purposes. That will be the hardest part, because the
> >>> "window" can extend beyond the tape's physical bounds.
> >>>
> >>> You might also need copy and "move" constructors, and maybe a constructor
> >>> to create a tape with initial contents (you could do this on top of the move
> >>> and write functions). You'll need a default constructor to create an
> >>> initially blank tape. Depending on your model, you might also have to write
> >>> an explicit destructor.
> >>>
> >>> Good software engineering practice is to write the interface first, then write
> >>> a simple implementation that doesn't have to be efficient or to scale up
> >>> to long tapes. You then write a more efficient implementation later, if it is
> >>> required.
> >>>
> >>> For an even odd decider, you won't need a very efficient tape at all. A human
> >>> can count values up to maybe 20 in unary notation, reliably. So you can really
> >>> only test for tapes with less than 20 symbols on them. That's tiny, even for a
> >>> ZX81.
> >> typedef unsigned char tape_element;
> >> // Tape_Type implements a two-way Turing machine tape.
> >> // Right contains Tape_Head >= 0 values (right expansion)
> >> // Left contains Tape_Head < 0 values (left expansion)
> >> //
> >> // Grows with Right.push_back() as Tape_Head increases above 0.
> >> // Grows with Left.push_back() as Tape_Head decreases below 0.
> >> //
> >> // Tape_Type has functionality very similar to std::deque
> >> // yet implements this functionality much more simply.
> >> // This saves time and space.
> >> //
> >> class Tape_Type
> >> {
> >>
> >> private:
> >> int Tape_Head = 0; // Can be negative
> >> std::vector<tape_element> Left; // Stores left expansion
> >> std::vector<tape_element> Right; // Stores right expansion
> >>
> >> tape_element& operator[](int index)
> >> {
> >> return index >= 0 ? Right[index] : Left[-index - 1];
> >> }
> >>
> >> public:
> >> tape_element& front( ) { return Left.back(); }
> >> tape_element& back() { return Right.back(); }
> >> void push_front(tape_element E) { Left.push_back(E); }
> >> void push_back(tape_element E) { Right.push_back(E); }
> >> void reserve(unsigned int N)
> >> { Left.reserve(N); Right.reserve(N); }
> >>
> > All above this should be "private". The tape only has move one space left / right
> > (either one function or two, it doesn't matter), Read() and Write() as public
> > members. That's for the strict Turing machine.
> > You'll also want an output function for visualisation, testing, and debugging,
> > which you've written.
> >> void Write(tape_element Y){ (*this)[Tape_Head] = Y; };
> >> tape_element Read() { return (*this)[Tape_Head]; };
> >>
> >> void move_head(char E)
> >> {
> >> if (E == 'L')
> >> move_left();
> >> else
> >> move_right();
> >> }
> >>
> >> void move_left()
> >> {
> >> Tape_Head--;
> >> int Left_Index = ((Tape_Head * -1) -1);
> >> if (Left_Index == Left.size())
> >> Left.push_back('_');
> >> }
> >>
> >> void move_right()
> >> {
> >> Tape_Head++;
> >> if (Tape_Head == Right.size())
> >> Right.push_back('_');
> >> }
> >>
> >> void Output()
> >> {
> >> printf("Tape_Type::Output()\n");
> >> if (Left.size())
> >> {
> >> int Last_One = Left.size() - 1;
> >> for (int N = Last_One; N >= 0; N--)
> >> {
> >> int TH = (N + 1) * -1; // determine Tape_Head from N
> >> printf("[%04d]:%c Left[%02d]\n", TH, Left[N], N);
> >> }
> >> }
> >> if (Right.size())
> >> for (int N = 0; N < Right.size(); N++)
> >> printf("[%04d]:%c Right[%02d]\n", N, Right[N], N);
> >> }
> >> };
> >>
> > A model with two vectors which grow form the initial zero position in opposite
> > directions is fine. The current tape position is the Tape_Head.variable, which is
> > a signed integer giving offset form the initial zero position. Again, that's fine.
> >
> > I'll think you'll find you need a less wordy "Output()" function, however.
> > One advantage of Turing machines is that the symbols on the tape can be
> > made human-readable. It's easy to scan a string of ascii characters which
> > represents the current tape.
> >
> > Write some tests and see if this tape works.
> It works.
>
Excellent.
Now we need to construct the rest of the machine.


Click here to read the complete article
Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<FZSdnfeHeZihZOL_nZ2dnUU7-afNnZ2d@brightview.co.uk>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32487&group=comp.theory#32487

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!nntp.brightview.co.uk!news.brightview.co.uk.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 14 May 2022 13:47:24 -0500
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
Newsgroups: comp.theory
References: <t541t8$upu$1@dont-email.me>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com> <87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com> <874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com> <87h75tugo8.fsf@bsb.me.uk>
<f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
<45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com>
<87czggtims.fsf@bsb.me.uk>
<d6a83e4a-59b7-4d4f-aba4-b17483f2af87n@googlegroups.com>
From: news.dea...@darjeeling.plus.com (Mike Terry)
Date: Sat, 14 May 2022 19:47:23 +0100
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:60.0) Gecko/20100101
Firefox/60.0 SeaMonkey/2.53.7.1
MIME-Version: 1.0
In-Reply-To: <d6a83e4a-59b7-4d4f-aba4-b17483f2af87n@googlegroups.com>
Content-Type: text/plain; charset=windows-1252; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <FZSdnfeHeZihZOL_nZ2dnUU7-afNnZ2d@brightview.co.uk>
Lines: 21
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-1Y1iyqCeJyxjN+d0q6yRPTBlLuDd2E/QrwlYzZk3/V8UVk/h4P1GZFNao/OpUv+Bs3I4nmRi6MHk4+Y!f5kz8T2bGw6+XHrO1CY6cM1yHgqzqRbmQyY0mumTxfs22RBxrdLKyOJ+ujFFX+OrcZCuObOtyEw7!vmTSnTNysNhKe4IYiwAORF8bCN4=
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3176
 by: Mike Terry - Sat, 14 May 2022 18:47 UTC

On 14/05/2022 19:37, Malcolm McLean wrote:
> On Saturday, 14 May 2022 at 13:15:44 UTC+1, Ben wrote:
>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>
>>> For an even odd decider, you won't need a very efficient tape at all. A human
>>> can count values up to maybe 20 in unary notation, reliably. So you can really
>>> only test for tapes with less than 20 symbols on them.
>> That's an odd remark. Why should the test be limited to what I can
>> count visually?
>>
> You have 21 consecutive 1s on the tape. The even/odd decider reports "parity even".
> Now is that because of a bug in the decider, or because you have miscounted the
> number of 1s? If the number of 1s is below 20, you can use fingers and toes to
> get reliable count, but when it is above 20, this option is unavialable, and there's no
> way of knowing.
>

What we need is two more TMs: one to take a number n and double it, and one to take a number n and
double it and add 1. Then we can use those output tapes to test the Even/Odd TM for some large
numbers! :)

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<5K-dnRwTU56eZuL_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32488&group=comp.theory#32488

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 14 May 2022 13:54:59 -0500
Date: Sat, 14 May 2022 13:54:59 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
Content-Language: en-US
Newsgroups: comp.theory
References: <t541t8$upu$1@dont-email.me> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com> <87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com> <874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com> <87h75tugo8.fsf@bsb.me.uk>
<f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
<45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com>
<P8WdnRjqkK8g7-L_nZ2dnUU7_83NnZ2d@giganews.com>
<6490efea-5b5c-4695-85c6-5cfb9a36709en@googlegroups.com>
<Z9-dnbNQ54lnLuL_nZ2dnUU7_8xh4p2d@giganews.com>
<7ad347a3-6820-4292-8894-b256a08332ban@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <7ad347a3-6820-4292-8894-b256a08332ban@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <5K-dnRwTU56eZuL_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 203
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-z7xbLF9ZjJfVLMsFnrQPFR7xKhDqIzNpmeDiEo0K7QRgEbbe+5R+rpYHupnxSTqWL7xeYo7cbKXpnWf!2KXpE/tKILRLeLPctuAA+pFkaN0d4xdT9oDAEOdtF7ynejfbFnyR1huGive4DLGOjKCexXNWaYk=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 10850
 by: olcott - Sat, 14 May 2022 18:54 UTC

On 5/14/2022 1:38 PM, Malcolm McLean wrote:
> On Saturday, 14 May 2022 at 14:52:01 UTC+1, olcott wrote:
>> On 5/14/2022 5:30 AM, Malcolm McLean wrote:
>>> On Saturday, 14 May 2022 at 10:13:40 UTC+1, olcott wrote:
>>>> On 5/14/2022 3:54 AM, Malcolm McLean wrote:
>>>>> On Saturday, 14 May 2022 at 01:09:20 UTC+1, olcott wrote:
>>>>>> On 5/13/2022 7:00 PM, Ben wrote:
>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/13/2022 5:57 PM, Ben wrote:
>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 5/13/2022 3:58 PM, Ben wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 5/13/2022 2:12 PM, Ben wrote:
>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 5/13/2022 1:45 PM, Ben wrote:
>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Flibble found a case where my member functions would need to be
>>>>>>>>>>>>>>>> extended and this extension may have a worse Big-O than std::deque in
>>>>>>>>>>>>>>>> some cases.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> As did everyone who glanced at the code for more than a few seconds. Or
>>>>>>>>>>>>>>> at least I sincerely hope they did. It's not hard to see that your code
>>>>>>>>>>>>>>> was wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The details of std::deque is almost brand new to me.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I guessed as much. Yet you claimed to have done better than the teams
>>>>>>>>>>>>> of experienced programmers who've worked on various C++ standard
>>>>>>>>>>>>> libraries after writing only a few lines of code? That level of
>>>>>>>>>>>>> delusion might lead someone to think they can solve the halting problem.
>>>>>>>>>>>>
>>>>>>>>>>>> None-the-less my version does perform better and is much simpler on
>>>>>>>>>>>> the operations that I need.
>>>>>>>>>>> What new delusion is this? Your "version" is not a deque. What is it a
>>>>>>>>>>> version of? What does it perform better than?
>>>>>>>>>>>
>>>>>>>>>>>>>> None-the-less my Tape_Type does seem optimal for a TM tape as long as
>>>>>>>>>>>>>> the speed with Tape_Type::reserve() beats some and matches the rest of
>>>>>>>>>>>>>> the speed of every operation of your std::string, otherwise I would go
>>>>>>>>>>>>>> for the simpler std::string version.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Using reserve has no effect on the one test case I have for timing.
>>>>>>>>>>>>
>>>>>>>>>>>> What is the speed difference?
>>>>>>>>>>>
>>>>>>>>>>> Not reliably measurable. I could do more robust tests but that's not
>>>>>>>>>>> what I want to do today.
>>>>>>>>>>
>>>>>>>>>> This always works well for me.
>>>>>>>>>> https://www.tutorialspoint.com/c_standard_library/c_function_clock.htm
>>>>>>>>> It's not a method I like. When yours program is working, you can
>>>>>>>>> do timings any way you like. (And since the code is C++ you might want
>>>>>>>>> to look at std::chrono::high_resolution_clock.)
>>>>>>>>>
>>>>>>>>>> I want to know if your version is better than mine.
>>>>>>>>>> When I am all done I want to have the best version.
>>>>>>>>> Well, it's better because it's finished. It may be worse in other ways,
>>>>>>>>> but you don't say what "best" means to you.
>>>>>>>>
>>>>>>>> Mine is certainly designed to scale so on this basis I will keep mine.
>>>>>>>
>>>>>>> You don't have a TM interpreter yet! So presumably you mean you'll keep
>>>>>>> your design even though you don't know if mine scales. You have always
>>>>>>> stated strong opinions based on little knowledge.
>>>>>>>
>>>>>> Because of the simplicity that you claimed it probably could not quite
>>>>>> have the scalability that mine has.
>>>>>>
>>>>> You're using C++, so you need a class with the function to read the tape
>>>>> at the current head position, a function to write a symbol to the tape at
>>>>> the current head position, a function to move the head one place left,
>>>>> and a function to move the head one place right.
>>>>>
>>>>> Also you are going to need a function to read a "window" round the tape
>>>>> head, for visualisation purposes. That will be the hardest part, because the
>>>>> "window" can extend beyond the tape's physical bounds.
>>>>>
>>>>> You might also need copy and "move" constructors, and maybe a constructor
>>>>> to create a tape with initial contents (you could do this on top of the move
>>>>> and write functions). You'll need a default constructor to create an
>>>>> initially blank tape. Depending on your model, you might also have to write
>>>>> an explicit destructor.
>>>>>
>>>>> Good software engineering practice is to write the interface first, then write
>>>>> a simple implementation that doesn't have to be efficient or to scale up
>>>>> to long tapes. You then write a more efficient implementation later, if it is
>>>>> required.
>>>>>
>>>>> For an even odd decider, you won't need a very efficient tape at all. A human
>>>>> can count values up to maybe 20 in unary notation, reliably. So you can really
>>>>> only test for tapes with less than 20 symbols on them. That's tiny, even for a
>>>>> ZX81.
>>>> typedef unsigned char tape_element;
>>>> // Tape_Type implements a two-way Turing machine tape.
>>>> // Right contains Tape_Head >= 0 values (right expansion)
>>>> // Left contains Tape_Head < 0 values (left expansion)
>>>> //
>>>> // Grows with Right.push_back() as Tape_Head increases above 0.
>>>> // Grows with Left.push_back() as Tape_Head decreases below 0.
>>>> //
>>>> // Tape_Type has functionality very similar to std::deque
>>>> // yet implements this functionality much more simply.
>>>> // This saves time and space.
>>>> //
>>>> class Tape_Type
>>>> {
>>>>
>>>> private:
>>>> int Tape_Head = 0; // Can be negative
>>>> std::vector<tape_element> Left; // Stores left expansion
>>>> std::vector<tape_element> Right; // Stores right expansion
>>>>
>>>> tape_element& operator[](int index)
>>>> {
>>>> return index >= 0 ? Right[index] : Left[-index - 1];
>>>> }
>>>>
>>>> public:
>>>> tape_element& front( ) { return Left.back(); }
>>>> tape_element& back() { return Right.back(); }
>>>> void push_front(tape_element E) { Left.push_back(E); }
>>>> void push_back(tape_element E) { Right.push_back(E); }
>>>> void reserve(unsigned int N)
>>>> { Left.reserve(N); Right.reserve(N); }
>>>>
>>> All above this should be "private". The tape only has move one space left / right
>>> (either one function or two, it doesn't matter), Read() and Write() as public
>>> members. That's for the strict Turing machine.
>>> You'll also want an output function for visualisation, testing, and debugging,
>>> which you've written.
>>>> void Write(tape_element Y){ (*this)[Tape_Head] = Y; };
>>>> tape_element Read() { return (*this)[Tape_Head]; };
>>>>
>>>> void move_head(char E)
>>>> {
>>>> if (E == 'L')
>>>> move_left();
>>>> else
>>>> move_right();
>>>> }
>>>>
>>>> void move_left()
>>>> {
>>>> Tape_Head--;
>>>> int Left_Index = ((Tape_Head * -1) -1);
>>>> if (Left_Index == Left.size())
>>>> Left.push_back('_');
>>>> }
>>>>
>>>> void move_right()
>>>> {
>>>> Tape_Head++;
>>>> if (Tape_Head == Right.size())
>>>> Right.push_back('_');
>>>> }
>>>>
>>>> void Output()
>>>> {
>>>> printf("Tape_Type::Output()\n");
>>>> if (Left.size())
>>>> {
>>>> int Last_One = Left.size() - 1;
>>>> for (int N = Last_One; N >= 0; N--)
>>>> {
>>>> int TH = (N + 1) * -1; // determine Tape_Head from N
>>>> printf("[%04d]:%c Left[%02d]\n", TH, Left[N], N);
>>>> }
>>>> }
>>>> if (Right.size())
>>>> for (int N = 0; N < Right.size(); N++)
>>>> printf("[%04d]:%c Right[%02d]\n", N, Right[N], N);
>>>> }
>>>> };
>>>>
>>> A model with two vectors which grow form the initial zero position in opposite
>>> directions is fine. The current tape position is the Tape_Head.variable, which is
>>> a signed integer giving offset form the initial zero position. Again, that's fine.
>>>
>>> I'll think you'll find you need a less wordy "Output()" function, however.
>>> One advantage of Turing machines is that the symbols on the tape can be
>>> made human-readable. It's easy to scan a string of ascii characters which
>>> represents the current tape.
>>>
>>> Write some tests and see if this tape works.
>> It works.
>>
> Excellent.
> Now we need to construct the rest of the machine.


Click here to read the complete article
Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<871qwwsz7a.fsf@bsb.me.uk>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32489&group=comp.theory#32489

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Validating that the implementation meets the spec for TM transition function [ best tape ]
Date: Sat, 14 May 2022 20:15:21 +0100
Organization: A noiseless patient Spider
Lines: 22
Message-ID: <871qwwsz7a.fsf@bsb.me.uk>
References: <t541t8$upu$1@dont-email.me>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com>
<87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com>
<87y1z5zoqu.fsf@bsb.me.uk> <20220513133840.0000732f@reddwarf.jmc>
<875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com>
<87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com>
<871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com>
<87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com>
<874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com>
<87h75tugo8.fsf@bsb.me.uk>
<f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
<45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com>
<87czggtims.fsf@bsb.me.uk>
<d6a83e4a-59b7-4d4f-aba4-b17483f2af87n@googlegroups.com>
MIME-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="e15a6e7790c7684a121ff07a3ede6665";
logging-data="13364"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19467RkCBf81B7GK+X0UM/6k2WbazWnpNI="
Cancel-Lock: sha1:q6M4B55d7LPR7ZD09nAqsuMBDcM=
sha1:feYA3i/y8UWSd3Z8HlY4JD/TA0o=
X-BSB-Auth: 1.9712a2bf52e4cc43ac3c.20220514201521BST.871qwwsz7a.fsf@bsb.me.uk
 by: Ben - Sat, 14 May 2022 19:15 UTC

Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

> On Saturday, 14 May 2022 at 13:15:44 UTC+1, Ben wrote:
>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>
>> > For an even odd decider, you won't need a very efficient tape at all. A human
>> > can count values up to maybe 20 in unary notation, reliably. So you can really
>> > only test for tapes with less than 20 symbols on them.
>> That's an odd remark. Why should the test be limited to what I can
>> count visually?
>>
> You have 21 consecutive 1s on the tape. The even/odd decider reports
> "parity even". Now is that because of a bug in the decider, or
> because you have miscounted the number of 1s? If the number of 1s is
> below 20, you can use fingers and toes to get reliable count, but when
> it is above 20, this option is unavialable, and there's no way of
> knowing.

There's no smiley, but you are joking, right?

--
Ben.

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<2a6b4f1c-00f8-49a4-ba81-b6d435c58b4cn@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32490&group=comp.theory#32490

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:622a:188a:b0:2f3:f4a8:ac9b with SMTP id v10-20020a05622a188a00b002f3f4a8ac9bmr9747718qtc.396.1652557965567;
Sat, 14 May 2022 12:52:45 -0700 (PDT)
X-Received: by 2002:a0d:ccc2:0:b0:2fe:dd33:c5ed with SMTP id
o185-20020a0dccc2000000b002fedd33c5edmr1970442ywd.65.1652557965346; Sat, 14
May 2022 12:52:45 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 14 May 2022 12:52:45 -0700 (PDT)
In-Reply-To: <871qwwsz7a.fsf@bsb.me.uk>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:75f4:cd33:735a:a531;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:75f4:cd33:735a:a531
References: <t541t8$upu$1@dont-email.me> <MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com>
<87wneqyz6w.fsf@bsb.me.uk> <IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com>
<87y1z5zoqu.fsf@bsb.me.uk> <20220513133840.0000732f@reddwarf.jmc>
<875ym9z9et.fsf@bsb.me.uk> <44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com>
<87ilq9xodt.fsf@bsb.me.uk> <OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com>
<871qwxxn4u.fsf@bsb.me.uk> <ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com>
<87fsldw3np.fsf@bsb.me.uk> <Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com>
<874k1tvy63.fsf@bsb.me.uk> <zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com>
<87h75tugo8.fsf@bsb.me.uk> <f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com>
<45c82b50-7015-45ef-93ac-e2db40b48199n@googlegroups.com> <87czggtims.fsf@bsb.me.uk>
<d6a83e4a-59b7-4d4f-aba4-b17483f2af87n@googlegroups.com> <871qwwsz7a.fsf@bsb.me.uk>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <2a6b4f1c-00f8-49a4-ba81-b6d435c58b4cn@googlegroups.com>
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Sat, 14 May 2022 19:52:45 +0000
Content-Type: text/plain; charset="UTF-8"
X-Received-Bytes: 3947
 by: Malcolm McLean - Sat, 14 May 2022 19:52 UTC

On Saturday, 14 May 2022 at 20:15:25 UTC+1, Ben wrote:
> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>
> > On Saturday, 14 May 2022 at 13:15:44 UTC+1, Ben wrote:
> >> Malcolm McLean <malcolm.ar...@gmail.com> writes:
> >>
> >> > For an even odd decider, you won't need a very efficient tape at all. A human
> >> > can count values up to maybe 20 in unary notation, reliably. So you can really
> >> > only test for tapes with less than 20 symbols on them.
> >> That's an odd remark. Why should the test be limited to what I can
> >> count visually?
> >>
> > You have 21 consecutive 1s on the tape. The even/odd decider reports
> > "parity even". Now is that because of a bug in the decider, or
> > because you have miscounted the number of 1s? If the number of 1s is
> > below 20, you can use fingers and toes to get reliable count, but when
> > it is above 20, this option is unavialable, and there's no way of
> > knowing.
> There's no smiley, but you are joking, right?
>
Yes. In reality, tests often fail because of a bug in the test code rather than
the function under test. You must check both pieces of code. That leads to
the risk of a "fix" to the test code cancelling out a bug in the target function.
You just have to tolerate that possibility. Otherwise you get an infinite regression
of tests to test test code.

But it's easy to test simple Turing machines on small unary numbers, and you
can see at a glance whether the results are correct or not. Because of the way
Turing machines work, you can usually be pretty certain that correct results
on small, countable integers will scale up to arbitrarily long integers.

If you test on large unary integers, you need some way of counting the results
automatically. Also, you can't dry run the machine on large input. But some
tests, like busy beaver 5, are perfectly good tests, and need automatic checking.

Re: Validating that the implementation meets the spec for TM transition function [ best tape ]

<-KadnWw-YfAuex7_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32545&group=comp.theory#32545

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 17 May 2022 13:17:23 -0500
Date: Tue, 17 May 2022 13:17:23 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Validating that the implementation meets the spec for TM
transition function [ best tape ]
Content-Language: en-US
Newsgroups: comp.theory
References: <t541t8$upu$1@dont-email.me> <874k1u2vc7.fsf@bsb.me.uk>
<2e-dnTfLY8FJC-D_nZ2dnUU7_8xh4p2d@giganews.com> <87pmki1edk.fsf@bsb.me.uk>
<MeOdncVeZaeHMOD_nZ2dnUU7_8xh4p2d@giganews.com> <87wneqyz6w.fsf@bsb.me.uk>
<IsSdnaQ2qJzQWOD_nZ2dnUU7_83NnZ2d@giganews.com> <87y1z5zoqu.fsf@bsb.me.uk>
<20220513133840.0000732f@reddwarf.jmc> <875ym9z9et.fsf@bsb.me.uk>
<44CdnUwP0pbxDeP_nZ2dnUU7_81g4p2d@giganews.com> <87ilq9xodt.fsf@bsb.me.uk>
<OdqdnRWhpOuQN-P_nZ2dnUU7_8zNnZ2d@giganews.com> <871qwxxn4u.fsf@bsb.me.uk>
<ibSdnZplz8XxLOP_nZ2dnUU7_83NnZ2d@giganews.com> <87fsldw3np.fsf@bsb.me.uk>
<Kb2dnUS7ONJVVOP_nZ2dnUU7_81QAAAA@giganews.com> <874k1tvy63.fsf@bsb.me.uk>
<zaWdnfcK_d13f-P_nZ2dnUU7_81g4p2d@giganews.com> <87h75tugo8.fsf@bsb.me.uk>
<f8ednb92fY60buP_nZ2dnUU7_81g4p2d@giganews.com> <87zgjlt14r.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87zgjlt14r.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <-KadnWw-YfAuex7_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 27
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-zt0jDhXOjQFfrt3J0Ma5+6AwRsjAMPkx4I3yGpWK0Uv/kO1AD+pAiJS2cJkXWBY6t3cg098G+DBKFuc!GCPz5w/yyMAp4DCYsprXIKWXA5AZ3NqKcz0R/HetEi1r2bn1QqPiEYsmQE1cgMFNnkt8gp0pnMo=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 2883
X-Received-Bytes: 2974
 by: olcott - Tue, 17 May 2022 18:17 UTC

On 5/13/2022 7:21 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 5/13/2022 7:00 PM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>
>>>> Mine is certainly designed to scale so on this basis I will keep mine.
>>>
>>> You don't have a TM interpreter yet! So presumably you mean you'll keep
>>> your design even though you don't know if mine scales. You have always
>>> stated strong opinions based on little knowledge.
>>
>> Because of the simplicity that you claimed it probably could not quite
>> have the scalability that mine has.
>
> Yours does not "scale" to even the simplest TM because it does not yet
> exist.
>

There are probably about two lines of code that are out of place.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Pages:12345678
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor