Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > sci.logic > #170308 > unrolled thread
| Started by | George Greene <greeneg@email.unc.edu> |
|---|---|
| First post | 2018-01-16 13:25 -0800 |
| Last post | 2018-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.
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 →
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-16 13:25 -0800 |
| Subject | Re: 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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | Peter Percival <peterxpercival@hotmail.com> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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