Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > sci.logic > #170308 > unrolled thread

Re: Infinitely Recursive input on HP Proofs

Started byGeorge Greene <greeneg@email.unc.edu>
First post2018-01-16 13:25 -0800
Last post2018-01-22 18:10 -0800
Articles 20 on this page of 78 — 7 participants

Back to article view | Back to sci.logic

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.


Contents

  Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-16 13:25 -0800
    Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-16 14:09 -0800
      Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-17 20:05 -0800
        Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-17 20:28 -0800
          Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-17 21:09 -0800
            Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-17 21:15 -0800
              Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-18 09:37 +0000
                Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 10:50 -0800
      Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 07:57 -0800
        Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-01-18 16:28 +0000
          Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 10:22 -0800
            Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 10:30 -0800
              Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 10:51 -0800
    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-17 01:09 +0000
      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 08:18 -0800
        Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 10:01 -0800
          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 10:22 -0800
            Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-21 20:58 -0800
              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 15:45 -0800
                Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 18:18 -0800
        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-19 01:04 +0000
          Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 17:54 -0800
            Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 19:12 -0800
              Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 19:32 -0800
                Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 20:06 -0800
                  Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 20:20 -0800
                    Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 21:10 -0800
                      Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-20 00:06 -0800
              Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 19:36 -0800
          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 18:50 -0800
            Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 19:38 -0800
            Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-20 00:00 +0000
              Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-20 00:12 -0800
              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-21 07:19 -0800
                Re: Infinitely Recursive input on HP Proofs Jim Burns <james.g.burns@att.net> - 2018-01-21 21:32 -0500
                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 15:22 -0800
                    Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 17:31 -0800
                Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-22 02:40 +0000
                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 14:59 -0800
                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-23 01:58 +0000
                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 18:17 -0800
                        Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 18:34 -0800
                          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 19:02 -0800
                            Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 21:30 -0800
                              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 21:35 -0800
                                Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-23 11:43 +0000
                                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 08:31 -0800
                                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-23 20:30 +0000
                                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 14:11 -0800
                                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-24 01:20 +0000
                                          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 17:56 -0800
                                            Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-25 02:04 +0000
                                              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-24 18:14 -0800
                                                Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-25 02:38 +0000
                                                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-24 18:48 -0800
                                                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-25 04:07 +0000
                                Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-23 22:05 -0800
                                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 22:16 -0800
                                    Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-24 19:43 -0800
                                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-24 20:17 -0800
                                        Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-24 20:57 -0800
                                          Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-24 21:00 -0800
                                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-25 11:31 +0000
                                          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-25 07:28 -0800
                            Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-23 22:09 -0800
                              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 22:27 -0800
                                Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-24 19:48 -0800
          Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-01-21 17:41 +0000
            Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-22 01:18 +0000
              Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-01-22 12:38 +0000
            Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-21 20:49 -0800
            Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-21 20:51 -0800
              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 15:24 -0800
                Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 17:32 -0800
                Re: Infinitely Recursive input on HP Proofs Mikko <mikko.levanto@outlook.com> - 2018-01-23 20:15 +0200
                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 14:13 -0800
              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 15:40 -0800
                Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 18:10 -0800

Page 1 of 4  [1] 2 3 4  Next page →


#170308 — Re: Infinitely Recursive input on HP Proofs

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-16 13:25 -0800
SubjectRe: Infinitely Recursive input on HP Proofs
Message-ID<f9d28ff7-1661-4386-a136-0329a36137d9@googlegroups.com>
On Tuesday, January 16, 2018 at 1:13:42 AM UTC-5, Pete Olcott wrote:
> On 3/15/2017 12:12 PM, Ben Bacarisse
>       wrote:
> 
>     
>     
>       I'll cut to the chase...
> peteolcott <pete...@gmail.com> writes:
> <snip>
> 
>       
>         So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2)
> the execution trace of Wm_1 indicates that it makes a copy of Wm_2
> which for clarity we will call Wm_3. 
> 
> The next step of the execution trace of Wm_1 indicates that it begins 
> its own evaluation execution trace of Wm_2 Wm_3. 
> 
> The execution trace of Wm_2 indicates that it makes a copy of Wm_3
> which for clarity we will call Wm_4.
> 
>       
>       None of the Wm have an execution trace.  They are stings in the alphabet
> of the TM H (and H^).  The only thing that can have has any "execution
> trace" is H^ and we have no idea what it does after copying the tape
> other than it behaves like some other machine called H.
> 
> You don't understand Linz's notation, and you don't understand what H^
> is.  And, as usual, you a confusing machines with representations of
> machines.
> 
> <snip>
> 
>     
>     
> 
>     
>     Maybe this much more
>         precise wording will answer your prior objections.


*N*O*T*H*I*N*G* will answer any of BB's objections.
His assessment of the situation is correct.
Mine largely matches it.  His point about NONE of the
Wm's having an execution trace IS CORRECT -- they ARE NOT
programs -- they ARE STRINGS.  The fact that these strings
are the code OF PROGRAMS is NOT relevant.  It still TAKES A
MACHINE -- an H-something -- to DO some execution that can
get traced.  NO w-something EVER performs execution that
can be traced.  No code-file is SELF-executing! The MACHINE, The H-something,
has to do the executing.


> 
>       
> 
>     http://liarparadox.org/HP_Infinite_Recursion.pdf
>       // zoom in to see high resolution detail
> 
>     Ĥ
>         is being applied to its own TM description ŵ.
>       // See top of page 320
> 
>       
> 
>       // Definition of Ĥ (page 319) with
>     detail
>         added
>       from
>       Figure 12.2
> 
>       // and Correction
>       (no finite state machine can have two start states): 
> 
>       // q0
>       changed to qx 
> 
>       
> 
>     Final
>         Definition of Ĥ after correction and added detail
> 
>       q0
>       Wm ⊢* Ĥ qx

Okay, sort of.

>       Wm Wm ⊢* Ĥ qy
>         qa ∞ 

This was never really correct to begin with.
After Ĥ doubles its input, Ĥ *CALLS*H'* on the doubled
input.  So even though your description above has
H-HAT going to qy and qa, what IS ACTUALLY HAPPENING
is H-PRIME (being RUN BY H-hat, as a part of H-hat)
going to qy and qa.

That is what is so shitty about this presentation (of Linz's).
It is impossible to say whether it is H-hat or H-prime (or H)
that is doing something, if one calls a second which then calls
a third.  H-hat is actually doing ALL the work but it is doing it
BY doing work LIKE H-prime does, which, partly, does WHAT H does.

 //
>     Correction
>         and Detail
> 
>       q0
>       Wm ⊢* Ĥ qx
That is fine but the continuation is not good...
>       Wm Wm ⊢* Ĥ y1 qn y2 // Correction
The ACTUAL correction would read something like
      qx  Wm Wm ⊢* Ĥ y1 qn y2 ,
since Linz's notation ALWAYS starts with the state where you are beginning.
You are just assuming continuation from the previous/last state,
which is correct, but again, the question is HOW TO WRITE it clearly,
and Linz just fails massively.  You need a simpler presentation than
the one he is giving you.

>       
> 
>       

>     Would
>           Ĥ transition to its state (qy) or ((qn)) on ŵ (a TM
>           description of
>           itself) ?

It is impossible to say what  Ĥ would do on ŵ because THAT DEPENDS
on what JUST-PLAIN-H would do on (ŵ,ŵ).  Which in turn circularly
depends on what Ĥ would do on ŵ.  WITHOUT KNOWING
what JUST-PLAIN-H would do on (ŵ,ŵ), you have TO SPLIT
that question into two cases.  To continue reasoning, you have to say,
ASSUME H(ŵ,ŵ) would halt-YES(neaning H-hat-halts-on-w-hat)
and see what happens, AND THEN,
ASSUME H(ŵ,ŵ) would halt-NO(meaning H-hat-DOESN'T-halt-on-w-hat)
and see what happens.

What happens IN BOTH cases is that YOU GET A CONTRADICTION.
Therefore H does not exist.
That winds up entailing that H-prime and H-hat don't exist either
but that's not the point -- by construction, BOTH of those HAVE to exist
if H exists.
The alternative to calling this a proof that "H doesn't exist" is to
call it a proof that *NO* H (since we haven't made any assumptions
about H beyond that it expects its input to look like 2 strings, the first
of which can be parsed as the program-code for a TM) can satisfy the spec
of "always halts with the correct answer about whether the machine coded
by its first inpur string halts when that machine is given H's 2nd-input
string as its (only) input-string".  Assuming that H satisfies that spec
leads to a contradiciton, and this is true FOR ARBITRARY H, therefore
No H can satisfy that spec.

>     This
>           is my analysis of these facts:

It's wrong on several levels.

> 
>         
> 
>     To
>           answer this question we perform an execution trace on Ĥ.

You don't have to keep talking about "traces" that WE perform!
WE DON'T DO ANYTHING!
* Ĥ * runs and *IT* does stuff!  All we do is WATCH!
 
> 
>       The
>       first thing that Ĥ
>         does is make
>       a
>       copy of its input, for clarity we will call this copy ŵ2.
> 
>       The
>       next thing that Ĥ
>         does begin
>       to
>       evaluate what
>         ŵ
>         would do on
>       its
>       input ŵ2, at state qx.

Not exactly. What H-hat does NEXT is CALL H-PRIME, and have *IT* perform
this evaluation. H-hat IS WRITTEN to have the code of H-PRIME executed
next.  You need to identify H-prime RATHER THAN H-hat as the routine/machine
being executed here.  And noboedy ever evaluates "what w-hat would do" becuase
w-hat IS A STRING, SO IT NEVER DOES ANYTHING.  This string is the code for
a program but IT IS THE RUNNING PROGRAM, THE TM RUNNING that code-string,
that "does something", NOT the string itself.  In this case, the TM
running the program coded by the string w-hat is H-PRIME.

> 
>     The execution trace of the above definition proves this
>       result to this point .

No, it doesn't because traces aren't relevant in the first place and you
are overlooking the fact that H-hat calls H-prime which then calls H.
You can't keep this straight if you keep talking about and only about what
H-hat is doing.

[toc] | [next] | [standalone]


#170317

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-16 14:09 -0800
Message-ID<13c934f4-569d-41c9-8275-a400e5d4c414@googlegroups.com>
In reply to#170308
On Tuesday, January 16, 2018 at 4:53:12 PM UTC-5, Pete Olcott wrote:
       
>             The execution trace of the above definition proves this
>       result to this point .
> 
>       
>       No, it doesn't because traces aren't relevant in the first place and you
> are overlooking the fact that H-hat calls H-prime which then calls H.
>     
>     
> 
>     Bullshit you dumb bunny !!!

LISTEN, YOU *IGNORANT* bitch:
*I*HAVE*TWO*DEGREES* in this shit.
UNlike you, *I*UNDERSTAND* what Linz is saying.
YOU DO NOT.

WE *KNOW* this stuff --
YOU DON'T.
WE CAN READ Linz-- YOU CAN'T.

WE not ONLY UNDERstand Linz -- which you don't --
WE OVERstand Linz's treatment of this and CAN write
AND HAVE written BETTER treatments OURSELVES.


> 
>     
> 
>     
>       You can't keep this straight if you keep talking about and only about what
> H-hat is doing.
> 
>     
>     You seem be too dumb
>           to even see what the textbook says. 

I see perfectly well what the textbook says, but unlike you,
I ALSO KNOW WHAT IS HAPPENING, and know that the way the textbook
presents it isn't the only way to see it.
If H-hat were the only thing that mattered, they would NOT HAVE NEEDED
TO BOTHER DEFINING H-PRIME.


> 
>           I spent at least 12 hours writing this stuff, and you can't
>           even 
> 
>           bother to pay attention to direct quotes.

You're just lying.  I understand the direct quotes and you don't -- that is all.

> 
>         
> 
>     Bottom
>             of page 319 direct quote
> 
>     From
>       H'
>         we construct another Turing machine Ĥ.
>         This new machine 
>     
> 
>     takes
>         as input Wm, copies it, and then behaves
>                   exactly like H'.

EXACTLY.  AND IN ORDER to behave exactly like H', it has to be in THE SAME states that H' was in and do the SAME things with the SAME state-transitions and outputs that H' would do.  WHILE we are talking about the behavior of H-hat
doing this, WE ARE ALSO TALKING ABOUT H-prime.  If you have ever written code
in a 3rd-generation language then you understand the concept of a subroutine
or procedure -- sometimes one program CALLS ANOTHER and it doesn't stop being
itself WHILE ALSO being/executing the component program!

>         Then the 
>     
> 
>     action
>         of Ĥ
>         is such that 
>     
> 
>     
> 
>      q0
>             Wm ⊢* Ĥ
>             q0 Wm Wm ⊢* Ĥ
>             ∞, 
>     
> 
>     
> 
>     if
>         M applied to WM halts, and 
>     
> 
>     
> 
>      q0
>             Wm ⊢* Ĥ
>             q0 Wm Wm ⊢* Ĥ
>             y1 qn y2,
>           
> 
>         if
>         M applied to WM does not halt. 

Yeah, sure, but that doesn't contradict anything I said.

>     
> 
>     
> 
>     Top
>             of page 320 direct quote
> 
>     Now
>         if Ĥ
>           is
>           a Turing machine,
>         so that it will have some description in ∑*,
> 
>     say
>       ŵ.
>         This string, in addition to being the description
>           of Ĥ
>         can also be used
> 
>     as
>         input string. We can therefore legitimately ask what
>           would happen if Ĥ
>           is
> 
>     applied
>           to ŵ.
>       
>     
> 
>     
> 
>     H is changed into H' becoming H' (H is now gone). 

H IS *NOT* gone, you idiot!  IT OCCURS AS A PART OF H-prime!

> 
>     H' is changed into Ĥ becoming Ĥ  (H' is now gone). 
H-prime IS NOT gone!  It occurs INSIDE H-hat!

DAMN!

These things are STRINGS.  They are ABSTRACT.
They can occur IN MULTIPLE places just like the string "halt" occurs
in multiple places on this page!

> 
>           You
>             can't even do an execution trace of Ĥ until you know this.

You can't do an exectuion trace of H-hat until you know that it has
H-prime as a subroutine, and that H-prime in turn has H.

The way Linz is describing this IS RETARDED.
If you read THE OTHER SECTION OF THE BOOK on how to combine TMs into more
complicated TMs, you might get a clue.

[toc] | [prev] | [next] | [standalone]


#170401

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-17 20:05 -0800
Message-ID<e24d6450-ee51-4b74-898b-d7492b2ecb27@googlegroups.com>
In reply to#170317
On Tuesday, January 16, 2018 at 5:27:00 PM UTC-5, Pete Olcott wrote:
> On 1/16/2018 4:09 PM, George Greene
>       wrote:
> 
>     
>     
>       On Tuesday, January 16, 2018 at 4:53:12 PM UTC-5, Pete Olcott wrote:
>        
> 
>       
>                     The execution trace of the above definition proves this
>       result to this point .
> 
>       
>       No, it doesn't because traces aren't relevant in the first place and you
> are overlooking the fact that H-hat calls H-prime which then calls H.
>     
>     
> 
>     Bullshit you dumb bunny !!!
> 
>       
>       LISTEN, YOU *IGNORANT* bitch:
> *I*HAVE*TWO*DEGREES* in this shit.
> UNlike you, *I*UNDERSTAND* what Linz is saying.
> YOU DO NOT.
> 
> WE *KNOW* this stuff --
> YOU DON'T.
> WE CAN READ Linz-- YOU CAN'T.
> 
> WE not ONLY UNDERstand Linz -- which you don't --
> WE OVERstand Linz's treatment of this and CAN write
> AND HAVE written BETTER treatments OURSELVES.
> 
> 
> 
>       
>             
> 
>     
>       You can't keep this straight if you keep talking about and only about what
> H-hat is doing.
> 
>     
>     You seem be too dumb
>           to even see what the textbook says. 
> 
>       
>       I see perfectly well what the textbook says, but unlike you,
> I ALSO KNOW WHAT IS HAPPENING, and know that the way the textbook
> presents it isn't the only way to see it.
> If H-hat were the only thing that mattered, they would NOT HAVE NEEDED
> TO BOTHER DEFINING H-PRIME.
> 
> 
> 
>       
>                   I spent at least 12 hours writing this stuff, and you can't
>           even 
> 
>           bother to pay attention to direct quotes.
> 
>       
>       You're just lying.  I understand the direct quotes and you don't -- that is all.
> 
> 
>       
>                 
> 
>     Bottom
>             of page 319 direct quote
> 
>     From
>       H'
>         we construct another Turing machine Ĥ.
>         This new machine 
>     
> 
>     takes
>         as input Wm, copies it, and then behaves
>                   exactly like H'.
> 
>       
>       EXACTLY.  AND IN ORDER to behave exactly like H', it has to be in THE SAME states that H' was in and do the SAME things with the SAME state-transitions and outputs that H' would do.  
>     
>     
> 
>     Except these identical states are at the end of a sequence beginning
>     with the states that were prepended to form Ĥ, the resulting machine
>     is henceforth always referred to as Ĥ. 

Yes, but that DOES NOT CONTRADICT ANYthing that I just said!  IT IS A FACT ABOUT 
H^ THAT IT CALLS H'.  It is a fact about H^ THAT IT EMULATES H'.  IT IS A FACT ABOUT H^ that H' occurs inside it.  You can't keep talking about these machines like it's THE MACHINE that matters!  IT'S THE *PROGRAM* that matters!  It's THE ALGORITHM that is actually being talked about!  And while you can't fit one physical machine inside another, you CAN write a program incorporatin code-fragments from another program or invoking a subroutine from a library!

>

[toc] | [prev] | [next] | [standalone]


#170406

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-17 20:28 -0800
Message-ID<01689fc2-fcfc-42af-9188-e0ec93af460e@googlegroups.com>
In reply to#170401
On Wednesday, January 17, 2018 at 10:05:21 PM UTC-6, George Greene wrote:
> On Tuesday, January 16, 2018 at 5:27:00 PM UTC-5, Pete Olcott wrote:
> > On 1/16/2018 4:09 PM, George Greene
> >       wrote:
> > 
> >     
> >     
> >       On Tuesday, January 16, 2018 at 4:53:12 PM UTC-5, Pete Olcott wrote:
> >        
> > 
> >       
> >                     The execution trace of the above definition proves this
> >       result to this point .
> > 
> >       
> >       No, it doesn't because traces aren't relevant in the first place and you
> > are overlooking the fact that H-hat calls H-prime which then calls H.
> >     
> >     
> > 
> >     Bullshit you dumb bunny !!!
> > 
> >       
> >       LISTEN, YOU *IGNORANT* bitch:
> > *I*HAVE*TWO*DEGREES* in this shit.
> > UNlike you, *I*UNDERSTAND* what Linz is saying.
> > YOU DO NOT.
> > 
> > WE *KNOW* this stuff --
> > YOU DON'T.
> > WE CAN READ Linz-- YOU CAN'T.
> > 
> > WE not ONLY UNDERstand Linz -- which you don't --
> > WE OVERstand Linz's treatment of this and CAN write
> > AND HAVE written BETTER treatments OURSELVES.
> > 
> > 
> > 
> >       
> >             
> > 
> >     
> >       You can't keep this straight if you keep talking about and only about what
> > H-hat is doing.
> > 
> >     
> >     You seem be too dumb
> >           to even see what the textbook says. 
> > 
> >       
> >       I see perfectly well what the textbook says, but unlike you,
> > I ALSO KNOW WHAT IS HAPPENING, and know that the way the textbook
> > presents it isn't the only way to see it.
> > If H-hat were the only thing that mattered, they would NOT HAVE NEEDED
> > TO BOTHER DEFINING H-PRIME.
> > 
> > 
> > 
> >       
> >                   I spent at least 12 hours writing this stuff, and you can't
> >           even 
> > 
> >           bother to pay attention to direct quotes.
> > 
> >       
> >       You're just lying.  I understand the direct quotes and you don't -- that is all.
> > 
> > 
> >       
> >                 
> > 
> >     Bottom
> >             of page 319 direct quote
> > 
> >     From
> >       H'
> >         we construct another Turing machine Ĥ.
> >         This new machine 
> >     
> > 
> >     takes
> >         as input Wm, copies it, and then behaves
> >                   exactly like H'.
> > 
> >       
> >       EXACTLY.  AND IN ORDER to behave exactly like H', it has to be in THE SAME states that H' was in and do the SAME things with the SAME state-transitions and outputs that H' would do.  
> >     
> >     
> > 
> >     Except these identical states are at the end of a sequence beginning
> >     with the states that were prepended to form Ĥ, the resulting machine
> >     is henceforth always referred to as Ĥ. 
> 
> Yes, but that DOES NOT CONTRADICT ANYthing that I just said!  IT IS A FACT ABOUT 
> H^ THAT IT CALLS H'.  It is a fact about H^ THAT IT EMULATES H'.  IT IS A FACT ABOUT H^ that H' occurs inside it.  You can't keep talking about these machines like it's THE MACHINE that matters!  IT'S THE *PROGRAM* that matters!  It's THE ALGORITHM that is actually being talked about!  And while you can't fit one physical machine inside another, you CAN write a program incorporatin code-fragments from another program or invoking a subroutine from a library!
> 
> >

Since other people have had great difficulty understanding Linz because of a key mistake in his text I summed up all of the aspects that I am referring to on this link. I am only referring to the single machine Ĥ, as I have documented. 

http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ 

I also spent hours recreating a single finite state transition diagram corresponding to the corrected version of his finite state transition sequence. 

The key insight The I have had yesterday is translating the HP proof 
into HOL (with self reference semantics), (Minimal Type Theory without Types). 

Now it becomes clear (finally after all these years) that the only
reason that the HP exists is because incorrect input was not rejected.

I have known this since at least 2004, now Pathological self-reference 
(copyright 2004) is finally formalized.

[toc] | [prev] | [next] | [standalone]


#170408

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-17 21:09 -0800
Message-ID<dc79a1ce-f73f-445d-941f-82370bfd13a2@googlegroups.com>
In reply to#170406
On Wednesday, January 17, 2018 at 11:28:41 PM UTC-5, peteolcott wrote:
> Since other people have had great difficulty understanding Linz because of a key mistake in his text

Your difficulties have nothing to do with that mistake, and that mistake didn't stop anyone else from understanding what was happening.  Your use of "because" here delusional.

> I summed up all of the aspects that I
> am referring to on this link. I am only referring
> to the single machine Ĥ, as I have documented.

You ARE LYING. Neither you nor anyone else CAN "document" referring "only to
the single machine Ĥ" BECAUSE Ĥ *IS*DEFINED* as calling H' and H' is defined as calling H.  ALL PERSONS MUST NECESSARILY refer to both H' and H when they run Ĥ -- Ĥ ITSELF says THAT ABOUT itself according to ITS OWN definition and ITS OWN code-string.

[toc] | [prev] | [next] | [standalone]


#170409

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-17 21:15 -0800
Message-ID<af00b147-3301-4dcd-8447-059f2a40cf69@googlegroups.com>
In reply to#170408
On Wednesday, January 17, 2018 at 11:09:31 PM UTC-6, George Greene wrote:
> On Wednesday, January 17, 2018 at 11:28:41 PM UTC-5, peteolcott wrote:
> > Since other people have had great difficulty understanding Linz because of a key mistake in his text
> 
> Your difficulties have nothing to do with that mistake, and that mistake didn't stop anyone else from understanding what was happening.  Your use of "because" here delusional.
> 
> > I summed up all of the aspects that I
> > am referring to on this link. I am only referring
> > to the single machine Ĥ, as I have documented.
> 
> You ARE LYING. Neither you nor anyone else CAN "document" referring "only to
> the single machine Ĥ" BECAUSE Ĥ *IS*DEFINED* as calling H' and H' is defined as calling H.  ALL PERSONS MUST NECESSARILY refer to both H' and H when they run Ĥ -- Ĥ ITSELF says THAT ABOUT itself according to ITS OWN definition and ITS OWN code-string.

Ben already explained that you are incorrect about this. 
So it looks like you may lack the capacity to understand this stuff.

[toc] | [prev] | [next] | [standalone]


#170422

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-01-18 09:37 +0000
Message-ID<87shb333up.fsf@bsb.me.uk>
In reply to#170409
peteolcott <peterolcott2@gmail.com> writes:

> On Wednesday, January 17, 2018 at 11:09:31 PM UTC-6, George Greene wrote:
>> On Wednesday, January 17, 2018 at 11:28:41 PM UTC-5, peteolcott wrote:
>> > Since other people have had great difficulty understanding Linz because of a key mistake in his text
>> 
>> Your difficulties have nothing to do with that mistake, and that mistake didn't stop anyone else from understanding what was happening.  Your use of "because" here delusional.
>> 
>> > I summed up all of the aspects that I
>> > am referring to on this link. I am only referring
>> > to the single machine Ĥ, as I have documented.
>> 
>> You ARE LYING. Neither you nor anyone else CAN "document" referring
>> "only to the single machine Ĥ" BECAUSE Ĥ *IS*DEFINED* as calling H'
>> and H' is defined as calling H.  ALL PERSONS MUST NECESSARILY refer
>> to both H' and H when they run Ĥ -- Ĥ ITSELF says THAT ABOUT itself
>> according to ITS OWN definition and ITS OWN code-string.
>
> Ben already explained that you are incorrect about this.

No.

> So it looks like you may lack the capacity to understand this stuff.

George understands this material perfectly well but you don't.  More
then a decade studying this material and you still can't write out a
correct proof of this simple theorem.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#170447

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-18 10:50 -0800
Message-ID<a4a70cc1-5cbd-4179-b293-c6a65f81d448@googlegroups.com>
In reply to#170422
On Thursday, January 18, 2018 at 11:39:11 AM UTC-5, Pete Olcott wrote:
>     Here
>       is the part that George is not getting when he says that H_Hat
>       calls H_Prime: 

*FUCK* you.
H-hat DOES call H'.  IT IS DEFINED AS calling H'.  Similarly, H' is defined
as calling H.

> 
>     
> 
>     Definition
>                     9.1, page 233, Linz 1990
> 
>     
> 
>     A
>                     Turing Machine M is defined by
> 
>                                  
>                     M = (Q, ∑,  Γ, δ , q0, ◻, F), 
> 
>                     where 
> 
>                     Q   
>                       is a finite set of internal states,
> 
>                     ∑     
>                     is a finite set of symbols called the input
>                     alphabet,
> 
>                     Γ   
>                       is a finite set of symbols called the tape
>                     alphabet,
> 
>                     δ   
>                       is the transition function,
> 
>                     q0 ∈ Q     
>                     is the initial state,

NO, dumbass -- that is not the part THAT ANYbody is failing to get.
Presenting this as a 6-tuple has ALWAYS been semi-RETARDED, though.
WHAT ACTUALLY MATTERS here IS  δ .  The rest of it is just bookkeeping
ENABLING the specification of  δ .   δ has NOT been clearly defined if
you don't know what its start-state is, but knowing that is more properly
thought of AS PART OF the definition of  δ rather than something else.

THE POINT is that  δ represents A PROGRAM, A SUBROUTINE, AN ALGORITHM.



You didn't even SAY anything in this post except what the canonical textbook
definition is. THAT DOES NOT PRECLUDE one TM calling another!
That just means that the definition for the caller's  δ is going to
include some states and paths that look exactly like the other machine's
 δ .  The fact that the states might need renaming or initially had names
that would overlap DOES NOT MATTER.  You can define the caller with state-
names guaranteed not to conflict with those of any other program it might
need to call.  You can define them all to use massively overlapping state-names.
IT WON'T MATTER.  It will still be the case that H^ as Linz wrote it IS DEFINED
as calling H', and H' IS WRITTEN TO call H.

[toc] | [prev] | [next] | [standalone]


#170432

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-18 07:57 -0800
Message-ID<e2510605-11d9-4962-829d-4bb80d947668@googlegroups.com>
In reply to#170317
On Tuesday, January 16, 2018 at 5:27:00 PM UTC-5, Pete Olcott wrote:

>     This is not how TM's work. I have been a software engineer for
>       three decades
THEN*FUCK* you.
If you have been a software engineer for ANY length of time THEN YOU KNOW
the difference between software and hardware AND YOU DON'T KNOW SHIT about TMs!
TMs *ARE*NOT* *M's*!  TMs ARE *NOT* *HARDWARE*!!
TMs ARE *SOFTWARE*!

You need to think of the TM
AS A SUBROUTINE, AS A PROGRAM.
Programs call other programs all the time.
If you are a software engineer THEN YOU ALREADY UNDERSTAND THE PARADIGM.

WHAT IS HAPPENING HERE IS SOME DEFINITIONS OF SOME *FUNCTIONS*, WITH
ARGUMENTS.

H(m,i): { not actually codeable, but supposedly behaves this way }
        If the TM whose code-string is m halts on input i,
         then halt returning true/yes,
         else halt returnign false/no.

H'(m,i): If H(m,i) then Loop
           else halt returning true/yes.

H^(s): If H'(s,s) Then halt.


So when you call H^(h^), it accordingly asks
       If H'(h^,h^) Then Loop else halt.
So when you THEN TRACE this H' call, IT  calls
       If H(h^,h^) Then Loop.
So the trace has to continue by evaluating H(h^,h^), i.e., by asking
whether H^(h^) halts.
Well, we are unfortunately IN THE MIDDLE OF EVALUATING H^(h^) RIGHT NOW,
so we DON'T KNOW yet whether it halts or not.  But this proof must split here
INTO TWO CASES: necessarily, EITHER H^(h^) halts OR IT DOESN'T.

So, IN THE FIRST CASE: assume H(h^,h^) returns true becuase H^(h^) does in fact halt: THEN, if this call to H returns true (we are unwinding the trace now),
its caller H'(h^,h^) WILL LOOP (that's the definition of H').
If this call to H' loops, then H^, WHICH MADE THAT CALL, MUST LOOP also --
its first line "If H'(h^,h^) then {whatever}" will never finish because
H'(h^,h^) is never returning a value because it is looping, so in this case,
H^(h^)LOOPS.  THIS IS A CONTRADICTION, either of our assumptions or of 
the spec for H: in this case, H(h^,h^) RETURNED TRUE, meaning that H^(h^)
had to halt, BUT IT DOESN'T (it loops in this case).

That leaves the second case: we must instead assume that H(h^,h^) returns
false, asserting that H^(h^) loops.  But when H(h^,h^) returns false,
H'(h^,h^) RETURNS TRUE, to ITS caller, which was H^.  This causes H^ to halt,
which contradictions H's claim that H(h^,h^) was false because H^(h^) looped.

[toc] | [prev] | [next] | [standalone]


#170434

FromPeter Percival <peterxpercival@hotmail.com>
Date2018-01-18 16:28 +0000
Message-ID<p3qhvt$quo$1@news.albasani.net>
In reply to#170432
George Greene wrote:
> On Tuesday, January 16, 2018 at 5:27:00 PM UTC-5, Pete Olcott wrote:
> 
>>      This is not how TM's work. I have been a software engineer for
>>        three decades
> THEN*FUCK* you.
> If you have been a software engineer for ANY length of time THEN YOU KNOW
> the difference between software and hardware AND YOU DON'T KNOW SHIT about TMs!
> TMs *ARE*NOT* *M's*!  TMs ARE *NOT* *HARDWARE*!!
> TMs ARE *SOFTWARE*!

Or neither.  They are in fact abstractions that cannot possibly be 
realized either as software or hardware.  (I'm using the words 
'software' and 'hardware' as a software engineer, or indeed the man in 
the street, would use them.)

[toc] | [prev] | [next] | [standalone]


#170443

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-18 10:22 -0800
Message-ID<d81bf355-85a4-4b87-901d-a66f9cce2697@googlegroups.com>
In reply to#170434
On Thursday, January 18, 2018 at 11:28:49 AM UTC-5, Peter Percival wrote:
> George Greene wrote:
> > On Tuesday, January 16, 2018 at 5:27:00 PM UTC-5, Pete Olcott wrote:
> > 
> >>      This is not how TM's work. I have been a software engineer for
> >>        three decades
> > THEN*FUCK* you.
> > If you have been a software engineer for ANY length of time THEN YOU KNOW
> > the difference between software and hardware AND YOU DON'T KNOW SHIT about TMs!
> > TMs *ARE*NOT* *M's*!  TMs ARE *NOT* *HARDWARE*!!
> > TMs ARE *SOFTWARE*!
> 
> Or neither.

YOU PERSONALLY ARE THINKING OF THEM *AS*HARDWARE*!
If you know they are abstractions THEN STOP that!
You know that programs can contain instances of other programs
as parts.  You know that one subroutine can call another.
THAT IS ALL THAT IS HAPPENING with H^, H', and H in Linz's
example.  You are just confusing yourself by trying to think of
H^ as "the only machine" -- the times and places where it is 
EMULATING OTHER MACHINES are BETTER though of as 1 program calling
another.

> They are in fact abstractions that cannot possibly be 
> realized either as software or hardware. 

That's ridiculous.  EVERY STRING -- EVERY LETTER -- is an abstraction.
That does not stop us from USING PHYSICAL INSTANCES of them to communicate.
The program that just doubles its string argument -- in addition to being
an abstraction -- CAN ALSO BE WRITTEN and does in fact do that in the
real world, in many different languages.

> (I'm using the words  'software' and 'hardware' as
> a software engineer, or indeed the man in 
> the street, would use them.)

Exactly, but you are NOT getting this "abstraction" thing right
AT ALL!  The man in the street DOESN'T use that word!

The archetypical example of an abstraction is a sign or symbol or letter
of the alphabet.  "The letter a" doesn't physically exist anywhere and is
certainly not equal to any of the individual printed a's that got physically
realized anywhere.  But once you know that letters are abstractions, you
know that strings of them are abstractions, and once you know that these
strings can make words in languages, you know that some of these languages
can be programming languages and that programs, since they are strings
in these languages, ARE ALSO ABSTRACTIONS.  Software *IS* abstraction, so
it MAKES NO sense to say,as you did above, that TMs are abstractions that
"can't be realized in" software -- TMs *ARE* software.

[toc] | [prev] | [next] | [standalone]


#170445

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-18 10:30 -0800
Message-ID<2eb1652f-15f1-4e7d-90ed-9bc9e514d360@googlegroups.com>
In reply to#170443
On Thursday, January 18, 2018 at 12:23:02 PM UTC-6, George Greene wrote:
> On Thursday, January 18, 2018 at 11:28:49 AM UTC-5, Peter Percival wrote:
> > George Greene wrote:
> > > On Tuesday, January 16, 2018 at 5:27:00 PM UTC-5, Pete Olcott wrote:
> > > 
> > >>      This is not how TM's work. I have been a software engineer for
> > >>        three decades
> > > THEN*FUCK* you.
> > > If you have been a software engineer for ANY length of time THEN YOU KNOW
> > > the difference between software and hardware AND YOU DON'T KNOW SHIT about TMs!
> > > TMs *ARE*NOT* *M's*!  TMs ARE *NOT* *HARDWARE*!!
> > > TMs ARE *SOFTWARE*!
> > 
> > Or neither.
> 
> YOU PERSONALLY ARE THINKING OF THEM *AS*HARDWARE*!
> If you know they are abstractions THEN STOP that!

So you don't even know that the term {finite state machine means} an abstract machine. 

These abstract finite state machines (implemented in C++) were fully operational before I even filed the patents. 

https://patents.google.com/patent/US7046848B1/en?oq=7046848    --
https://patents.google.com/patent/US9171207B1/en?oq=9171207++  --

[toc] | [prev] | [next] | [standalone]


#170448

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-18 10:51 -0800
Message-ID<c5b7406d-4bc4-4fed-8c56-ae1ecac2377b@googlegroups.com>
In reply to#170445
On Thursday, January 18, 2018 at 1:30:14 PM UTC-5, peteolcott wrote:
> On Thursday, January 18, 2018 at 12:23:02 PM UTC-6, George Greene wrote:
> > YOU PERSONALLY ARE THINKING OF THEM *AS*HARDWARE*!
> > If you know they are abstractions THEN STOP that!
> 
> So you don't even know that the term
> {finite state machine means} an abstract machine. 

It means a lot of different things.
Stop talking about what you think I do or don't know.
I have the transcript.
Given that the adminstrators of the Comp.Sci. GRE and
and the Computer Science departments of two universities know I know,
IT DOESN'T MATTER than YOU choose to use this or that term in a slightly
different way from the rest of the world.

[toc] | [prev] | [next] | [standalone]


#170332

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-01-17 01:09 +0000
Message-ID<87o9lt47gd.fsf@bsb.me.uk>
In reply to#170308
George Greene <greeneg@email.unc.edu> writes:
<snip>
> The ACTUAL correction would read something like
>       qx  Wm Wm ⊢* Ĥ y1 qn y2 ,
> since Linz's notation ALWAYS starts with the state where you are beginning.
> You are just assuming continuation from the previous/last state,
> which is correct, but again, the question is HOW TO WRITE it clearly,
> and Linz just fails massively.

Linz has a notation that could have been used to clear this up but it's
even more cumbersome: q_(A,0) for state 0 of machine A.  And while it
makes it clear what states belong to which machine that also obscures
the fact the all the machines in the construction share a lot of states
and transitions.  Do you say that q_(H,i) = q_(H',i) for all n states of
H, or do you allow them to be distinct provided the state transitions
are preserved by the correspondence between them?

It makes no odds, of course, since all that matters is the behaviour,
but when talking about states and transitions and traces you have to say
one way or the other.  Basically, the description is at the wrong level.
The level that matters is of computations and compositions of
computations.

The lambda calculus works at the right level for this, but there is so
much more technical material to cover before students feel that a lambda
form really encapsulates the idea of an effective procedure that any
advantage this presentation may have is undone.

TM's are so simple to explain and so obviously capture the basic idea of
doing something mechanically that they are the natural choice.  What is
needed is a presentation that uses TMs but that works at a level higher
than the states and the transitions.  You can make it formal, but you do
that when explaining general constructs like

   A | B

(A then B) which is a TM whose delta function takes the final state (or
states) of A to the initial state of B.  Even this detail is fiddly, but
once you have it out of the way, you are talking at a higher level, much
as you like to talk about one machine calling another.

The other basic construct used in the proof is

  A ? B : C

which is a machine that "does" B from A's accepting states and C from
it's rejecting ones (so A | B is really A ? B : B).

By the way, I usually try to avoid talking about calling a machine
because it suggests a function call that could, in theory, be nested and
that returns to somewhere.  Obviously you can model that with TM's, but
a more natural computing metaphor is just a jump or goto.

<snip>
-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#170433

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-18 08:18 -0800
Message-ID<9c66444f-a6e3-430b-9e92-152080000df2@googlegroups.com>
In reply to#170332
On Tuesday, January 16, 2018 at 7:09:26 PM UTC-6, Ben Bacarisse wrote:
> George Greene writes:
> <snip>
> > The ACTUAL correction would read something like
> >       qx  Wm Wm ⊢* Ĥ y1 qn y2 ,
> > since Linz's notation ALWAYS starts with the state where you are beginning.
> > You are just assuming continuation from the previous/last state,
> > which is correct, but again, the question is HOW TO WRITE it clearly,
> > and Linz just fails massively.
> 
> Linz has a notation that could have been used to clear this up but it's
> even more cumbersome: q_(A,0) for state 0 of machine A.  And while it
> makes it clear what states belong to which machine that also obscures
> the fact the all the machines in the construction share a lot of states
> and transitions.  Do you say that q_(H,i) = q_(H',i) for all n states of
> H, 

That would be a neat trick since H and H' have mutually exclusive states.

[toc] | [prev] | [next] | [standalone]


#170440

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-18 10:01 -0800
Message-ID<3d72a35a-0053-4311-ade8-a282fda4135b@googlegroups.com>
In reply to#170433
On Thursday, January 18, 2018 at 11:18:37 AM UTC-5, peteolcott wrote:
> That would be a neat trick since H and H' have mutually exclusive states.

Of course they do, but it just plain DOESN'T MATTER.
H^ is emulating H' -- it is doing exactly what H' does -- so IT DOESN'T MATTER
whether you are labeling the states the-same-as or differently-from what they
get labeled in the other TM.

Your EVEN THINKING OF the TM's as naming MACHINES as opposed to PROGRAMS
is THE THING THAT IS MESSING YOU UP here.
I KNOW you know the difference between a PC and a subroutine!
The TMs we are defining here -- they are basically defined by that transition
matrix -- need to be thought of AS CODE, AS SOFTWARE, NOT as hardware!

You canNOT TAKE one TM (all it P) and say at time 1), TM P has transition matrix O in it and runs program O, but at time 2) TM P gets O replaced by Q and runs a different program Q.    The TM AT ALL TIMES *IS* the ONE program that it IS and runs, EVEN if that program calls or emulates other programs!

[toc] | [prev] | [next] | [standalone]


#170442

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-18 10:22 -0800
Message-ID<9c5cfddf-608a-408c-883f-182d706c9c6d@googlegroups.com>
In reply to#170440
On Thursday, January 18, 2018 at 12:01:48 PM UTC-6, George Greene wrote:
> On Thursday, January 18, 2018 at 11:18:37 AM UTC-5, peteolcott wrote:
> > That would be a neat trick since H and H' have mutually exclusive states.
> 
> Of course they do, but it just plain DOESN'T MATTER.

It doesn't matter the H transitions to its final state ((qy)) and
H' does not have a final state ((qy)) ? 

You think that I don't know how finite state machines work when I 
have two US patents on finite state machines? 

https://patents.google.com/patent/US7046848B1/en?oq=7046848 
https://patents.google.com/patent/US9171207B1/en?oq=9171207++

[toc] | [prev] | [next] | [standalone]


#170736

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-21 20:58 -0800
Message-ID<6ffdd47a-34b9-4bb4-8767-7db002fd64c5@googlegroups.com>
In reply to#170442
On Thursday, January 18, 2018 at 1:22:32 PM UTC-5, peteolcott wrote:
> On Thursday, January 18, 2018 at 12:01:48 PM UTC-6, George Greene wrote:
> > On Thursday, January 18, 2018 at 11:18:37 AM UTC-5, peteolcott wrote:
> > > That would be a neat trick since H and H' have mutually exclusive states.
> > 
> > Of course they do, but it just plain DOESN'T MATTER.
> 
> It doesn't matter the H transitions to its final state ((qy)) and
> H' does not have a final state ((qy)) ? 

H' DOES have a final state  SOME of the time!
And all of the states H SHARES with H' ARE NOT mutually exclusive!


> You think that I don't know how finite state machines work when I 
> have two US patents on finite state machines? 

I was talking about TURING MACHINES.  And if you are going to insist on
calling Turing Machines "Finite State Machines" THEN YES, YOU DON'T know the lingo.

And the patent office DEFINITELY has NEVER known shit about this stuff.


> https://patents.google.com/patent/US7046848B1/en?oq=7046848 

That is a patent for a DFA, which is exactly what everybody normally
means by "finite state machine", and which IS NOT a Turing Machine!
Conversely, whether a TM is or isn't "a finite state machine" is complicated,
but usually, WE SPEAK AS THOUGH it is NOT, so YOU SHOULD not be speaking
HERE as though IT IS.

[toc] | [prev] | [next] | [standalone]


#170780

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-22 15:45 -0800
Message-ID<f62f9a55-d67a-4ace-a4b0-db649423fc5e@googlegroups.com>
In reply to#170736
On Sunday, January 21, 2018 at 10:58:21 PM UTC-6, George Greene wrote:
> On Thursday, January 18, 2018 at 1:22:32 PM UTC-5, peteolcott wrote:
> > On Thursday, January 18, 2018 at 12:01:48 PM UTC-6, George Greene wrote:
> > > On Thursday, January 18, 2018 at 11:18:37 AM UTC-5, peteolcott wrote:
> > > > That would be a neat trick since H and H' have mutually exclusive states.
> > > 
> > > Of course they do, but it just plain DOESN'T MATTER.
> > 
> > It doesn't matter the H transitions to its final state ((qy)) and
> > H' does not have a final state ((qy)) ? 
> 
> H' DOES have a final state  SOME of the time!
> And all of the states H SHARES with H' ARE NOT mutually exclusive!
> 

I am going to simply assume that you are being dishonest.
The text is clear that is is creating one machine on the
basis of another for the purpose of explanation. 

It appears that you do not want to have an honest conversation
and actually address my key points. 

[toc] | [prev] | [next] | [standalone]


#170789

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-22 18:18 -0800
Message-ID<b77d4e12-30a7-4479-8cc1-964c52feddae@googlegroups.com>
In reply to#170780
On Monday, January 22, 2018 at 6:46:00 PM UTC-5, peteolcott wrote:
> I am going to simply assume that you are being dishonest.
> The text is clear that is is creating one machine on the
> basis of another for the purpose of explanation. 

EXACTLY. THAT DOES NOT contradict anything I said.


> It appears that you do not want to have an honest conversation
> and actually address my key points.

You have no key points.
You keep acting like the fact that two TMs are physically different means
that one can't "be part of" another.

What you are not seeing is the fact that DESPITE the fact that TMs are
described as "machines', WHAT MATTERS IS the state-transition-function;
what matters is THE SOFTWARE, THE PROGRAM, running in the machine.
THAT 
is what defines the identity of the machine.

While you may not be able to see how one machine could be physically contained
in another (they both have distinct tapes and tape-heads, so that's clearly
not going to work, regardless of whether their states can overlap), YOU CAN
CERTAINLY SEE how one -- it doesn't matter, anything that can be written
will do -- POEM or SONG could be contained in another.

We can analogize H, H', and H^ to 3 poems.

Suppose there were a poem (with only one verse) called Hiawatha.
You could write another poem called
"The Prime of Hiawatha".
You could choose to make this poem have 2 verses and make its
first verse just THE POEM "Hiawatha", ALL OVER AGAIN.
You could then write a second verse talking about how what happened
to and with Hiawatha during the prime of his life, from age 21-35,
was the opposite of what you might have expected given what you heard
in the first poem whose title was just his name.

Then you could write a third poem,
"The Hat of Hiawatha", WITH THREE verses, the first two verses of which
were just "The Prime of Hiawatha" ALL OVER AGAIN, followed by a third
verse about what happened to him after he made -- out of the hide of
a raccoon -- a cap that he wore for the rest of his life.

THAT IS ALL that is going on here.
H^ is like A PROGRAM that contains code THAT IS QUOTED VERBATIM FROM ANOTHER
program.
Just as one poem could contain stanzas from another.

IT'S THE PROGRAMS that matter, NOT THE PHYSICAL MACHINES.

If I had it to do over again I would say "H^ emulates H' and H' emulates H",
just TO AVOID CONFUSING you by saying "calls".

Whether you think Linz;s diagrams say the same as what I am saying or
something different IS MOOT -- I KNOW WHAT HE MEANS, and you STILL DON'T YET.

[toc] | [prev] | [next] | [standalone]


Page 1 of 4  [1] 2 3 4  Next page →

Back to top | Article view | sci.logic


csiph-web