On 5/19/22 11:22 PM, olcott wrote:
> On 5/19/2022 10:07 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/19/2022 8:58 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/19/2022 7:52 PM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/19/2022 7:23 PM, Ben wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>>> H(P,P) == false is wrong about the halting of P(P) and the
>>>>>>>>>> trace does
>>>>>>>>>> not back-up what you say your H is doing.  There's nothing
>>>>>>>>>> left here.
>>>>>>>>>> But there's always the TM emulator...  How's that coming along?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> There are about two lines of code that are out-of-place. I have
>>>>>>>>> been
>>>>>>>>> ill and had other issues that I had to deal with.
>>>>>>>>
>>>>>>>> So maybe another month or so and you can start to write a parity
>>>>>>>> checking TM?  Those out-of-place lines can be a bugger to find ;-)
>>>>>>>
>>>>>>> I planned on having this done by now. The problem seems to be
>>>>>>> that the
>>>>>>> specification of the state transition function is not precise
>>>>>>> enough.
>>>>>> Unlikely.
>>>>>>
>>>>>>> A transition rule of a Turing machine has the following form
>>>>>>> δ(p, X) = (q, Y, L).
>>>>>>>
>>>>>>> pXYqL
>>>>>>> This means that from state p, on reading the symbol X on the tape,
>>>>>>>      the machine moves to state q,
>>>>>>>      replaces X with Y and
>>>>>>>      moves the tape head to the left.
>>>>>>>
>>>>>>>      void move_left();    // Tape_Head--; Left.push_back(0); as
>>>>>>> needed
>>>>>>>      void move_right();   // Tape_Head++; Left.push_back(0); as
>>>>>>> needed
>>>>>>>      void Write(tape_element Y){ this->operator[](Tape_Head) = Y; };
>>>>>>>      tape_element Read()       { return
>>>>>>> this->operator[](Tape_Head); };
>>>>>>>
>>>>>>> For example, the quintuple 'SCcsm' is executed by the machine:
>>>>>>> If it is in state 'S' and is reading the symbol 'C' on the tape then
>>>>>>> (a) make a transition to state 's'.
>>>>>>> (b) overwrite the symbol 'C' on the tape with the symbol 'c'.
>>>>>>> (c) move the tape reading head one symbol to the left or right
>>>>>>>         according to whether 'm' is 'l' or 'r'.
>>>>>>>
>>>>>>> When I implement it exactly as specified the behavior of my TM on
>>>>>>> the
>>>>>>> Paren.tm is not the same as the original TM.exe.
>>>>>>
>>>>>> It's called a bug.  I am amazed that your reaction to the fact
>>>>>> that your
>>>>>> program does not do what it should is that the specification is
>>>>>> wrong.
>>>>>> It's just a common or garden bug.
>>>>>
>>>>> I do all of the steps in the exact order that they are specified and
>>>>> it does not work. The problem is that the spec is vague on which input
>>>>> symbol is required for the state transition.
>>>>
>>>> I see nothing vague about it.  δ(p, X) = (q, Y, L) means that in state
>>>> p, with X at the tape head, replace the X with Y, move the head left
>>>> and enter state q.
>>>
>>> That does not actually work.
>>
>> It's the definition of the state transition function.  It is what it
>> is.  Here is the TM you talked about (paren.tm) accepting a string:
>>
>> $ ./tm -f paren.tm "(())"
>>         0
>> ______________________________[0|(]())___________________________
>>         1
>> _____________________________([0|(]))____________________________
>>         2
>> ____________________________(([0|)])_____________________________
>>         3
>> _____________________________([1|(]A)____________________________
>>         4
>> ____________________________(A[0|A])_____________________________
>>         5
>> ___________________________(AA[0|)]______________________________
>>         6
>> ____________________________(A[1|A]A_____________________________
>>         7
>> _____________________________([1|A]AA____________________________
>>         8
>> ______________________________[1|(]AAA___________________________
>>         9
>> _____________________________A[0|A]AA____________________________
>>        10
>> ____________________________AA[0|A]A_____________________________
>>        11
>> ___________________________AAA[0|A]______________________________
>>        12
>> __________________________AAAA[0|_]______________________________
>>        13
>> ___________________________AAA[2|A]______________________________
>>        14
>> ____________________________AA[2|A]A_____________________________
>>        15
>> _____________________________A[2|A]AA____________________________
>>        16
>> ______________________________[2|A]AAA___________________________
>>        17
>> ______________________________[2|_]AAAA__________________________
>>        18
>> ______________________________[Y|A]AAA___________________________
>> accept after 18 steps.
>>
>
> I can't quote tell what that says. The original TM.exe provides a good
> trace.

Not even knowing his program I can read it.

In the middle is the current state in brackets []

to the left of that is the tape to the left of the head.

to the right of that is the tape under the head and to the right.

Thus the first line says we started in state 0, with a tape that says ((()))

And the first instruction stayed in state 0, and moved to the write
without changing the tape (or writing a ( over the existing ( )
>
>
> tm> read tm paren
> tm> set tape ((()))
> tm> set trace tape
> tm> go
>
> ((()))
> ^
>     state: 0,  next quint: 0((0R

We are in 0, tape is ( quint is 0((0R
so change the tape at this spot to ( (no change), go to state 0, and
move tape to the right.

> ((()))
> ^
>     state: 0,  next quint: 0((0R
> ((()))
> ^
>     state: 0,  next quint: 0((0R
> ((()))
>   ^
>     state: 0,  next quint: 0)A1L

A change, state 0 with tape being ), this quint is 0)A1L
so switch to state 1, replace the ) with an A and move left

>
> (((A))
>  ^
>     state: 1,  next quint: 1(A0R

Now in state 1, with tape being (, this quint is 1(A0R

go back to state 0, change the ( to an A, and move left.

That is action exactly per the specifications, even if you don't
understand them.

> ((AA))
>   ^
>     state: 0,  next quint: 0AA0R
> ((AA))
>     ^
>     state: 0,  next quint: 0)A1L
> ((AAA)
>    ^
>     state: 1,  next quint: 1AA1L
> ((AAA)
>   ^
>     state: 1,  next quint: 1AA1L
> ((AAA)
>  ^
>     state: 1,  next quint: 1(A0R
> (AAAA)
>   ^
>     state: 0,  next quint: 0AA0R
> (AAAA)
>    ^
>     state: 0,  next quint: 0AA0R
> (AAAA)
>     ^
>     state: 0,  next quint: 0AA0R
> (AAAA)
>      ^
>     state: 0,  next quint: 0)A1L
> (AAAAA
>     ^
>     state: 1,  next quint: 1AA1L
> (AAAAA
>    ^
>     state: 1,  next quint: 1AA1L
> (AAAAA
>   ^
>     state: 1,  next quint: 1AA1L
> (AAAAA
>  ^
>     state: 1,  next quint: 1AA1L
> (AAAAA
> ^
>     state: 1,  next quint: 1(A0R
> AAAAAA
>  ^
>     state: 0,  next quint: 0AA0R
> AAAAAA
>   ^
>     state: 0,  next quint: 0AA0R
> AAAAAA
>    ^
>     state: 0,  next quint: 0AA0R
> AAAAAA
>     ^
>     state: 0,  next quint: 0AA0R
> AAAAAA
>      ^
>     state: 0,  next quint: 0AA0R
> AAAAAA
>       ^
>     state: 0,  next quint: 0  2L
> AAAAAA
>      ^
>     state: 2,  next quint: 2AA2L
> AAAAAA
>     ^
>     state: 2,  next quint: 2AA2L
> AAAAAA
>    ^
>     state: 2,  next quint: 2AA2L
> AAAAAA
>   ^
>     state: 2,  next quint: 2AA2L
> AAAAAA
>  ^
>     state: 2,  next quint: 2AA2L
> AAAAAA
> ^
>     state: 2,  next quint: 2AA2L
>  AAAAAA
> ^
>     state: 2,  next quint: 2  YR
>  AAAAAA
>  ^
>     state: Y,  next quint: (none)
> Halted in final state Y
> tm>
>
>
>> What states does your interpreter show the TM going through?
>>
>>>>> The second spec says transition specifies this:
>>>>>       Quintuple QT(current_state->state, Tape.Read());
>>>>> and that does not work.
>>>>
>>>> People will help you debug the code if you post it.  And if you think
>>>> there is something vague, ask for clarification.
>>>
>>> I want to do this only my own.
>>
>> I wish you well.
>
> It has my highest development priority.
> Personal matters have a higher priority.
>
> I have been just a little too weak to handle those personal matters.
> I expect to be better by tomorrow when my immune system starts to
> return. There are two days in every chemo cycle when I have zero immune
> system. Yesterday was one of these days.
>
>>
>>>> The code fragment you posted some while back was all wrong, but I
>>>> imagine you've moved on from that now.
>>
>
>