On 2/23/22 11:31 PM, olcott wrote:
On 2/23/2022 9:36 PM, Richard Damon wrote:
Then Analytic Truth is a sub-set of Truth. Just like the set of black
cats doesn't contain all cats.
Yes it is yet it encompasses all of mathematics and logic.
As I think back, I now remember on key fact that you are missing.
Analytic Truth requires Proof in a Finite (or sometimes Enumerable)
number of proof steps.
Mathematics introduces the concept of UnEnumeratable sets and this is
what breaks the concept of Truth must be Provable. Some things can be
shown true only by a 'meta-analysis' that looks at an uncountable number
of Proof Steps, which Analytic Truth can not handle, thus it can
establish facts that are not Analytically provable.
This also shows where you logic breaks down, you have show an inability
to actually think about things that can become infinite. The problem
with you H is that it actually needs infinite time to make a valid
decision, but it needs to make it in a finite time, and thus it fails.
It needs to find a value N that is greater than N + k where k > 0, and
just assumes it can find one, when it doesn't exist.
Missing out on the details of the infinite leads to Fallacious and
Invalid Logic, so your proof just FAILS.
On 2/24/22 10:24 AM, olcott wrote:
On 2/24/2022 6:43 AM, Richard Damon wrote:
On 2/23/22 11:31 PM, olcott wrote:
On 2/23/2022 9:36 PM, Richard Damon wrote:
Then Analytic Truth is a sub-set of Truth. Just like the set of
black cats doesn't contain all cats.
Yes it is yet it encompasses all of mathematics and logic.
As I think back, I now remember on key fact that you are missing.
Analytic Truth requires Proof in a Finite (or sometimes Enumerable)
number of proof steps.
The body of analytic truth is simply a set of true sentences that are
connected together semantically.
Mathematics introduces the concept of UnEnumeratable sets and this is
what breaks the concept of Truth must be Provable. Some things can be
shown true only by a 'meta-analysis' that looks at an uncountable
number of Proof Steps, which Analytic Truth can not handle, thus it
can establish facts that are not Analytically provable.
This merely requires algorithmic compression. We can know that there
is no maximum integer without having to actually count to infinity.
But you can't compress ALL things. Your assupmtion that you can is a
fallacy. For instance, you assume there must be a finite pattern that H
can detect in its simulation of <H^> <H^> that correctly indicates that
the pattern will repeat forever, when I have shown that no such pattern exists, as ANY pattern of N steps that H uses and then goes to H.Qn
means that there IS a number K > N such that H^ applied to <H^> halts in
K steps, thus H was wrong.
This also shows where you logic breaks down, you have show an
inability to actually think about things that can become infinite.
The problem with you H is that it actually needs infinite time to
make a valid decision, but it needs to make it in a finite time, and
thus it fails.
That makes the utterly moronic assumption that the most intelligent
and knowledgeable person in the universe could not possibly spot the
infinite loop in the code shown below in less then infinite time:
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit >> [0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
Fallacy of proof by example. FAIL.
That pattern is NOT in H^ applied to <H^>.
I never claimed that H couldn't detect SOME infinite loops,
just that it
can not detect an actual infinite loop in H^ applied to <H^> and go to
H.Qn (for H^ built on that H).
It needs to find a value N that is greater than N + k where k > 0,
and just assumes it can find one, when it doesn't exist.
Missing out on the details of the infinite leads to Fallacious and
Invalid Logic, so your proof just FAILS.
Richard Damon wrote:
On 2/24/22 12:01 PM, olcott wrote:...
On 2/24/2022 10:55 AM, Richard Damon wrote:
On 2/24/22 10:24 AM, olcott wrote:
That makes the utterly moronic assumption that the most intelligent
and knowledgeable person in the universe could not possibly spot
the infinite loop in the code shown below in less then infinite time: >>>>>
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
Fallacy of proof by example. FAIL.
That pattern is NOT in H^ applied to <H^>.
I never claimed that H couldn't detect SOME infinite loops,
You claimed that H could not correctly report that the above is an in
finite loop because if H stops simulating it then it is no longer an
infinite loop.
LIAR.
I said it could not do it for H^ applied to <H^>
Shows how much you understand the truth.
The (allowed) 'pathological self-reference' in H^ <H^> is what defeats
H here.
Your REPEATED misquoting of people and misuse of definitions just show
that YOU are a pathological LIAR and there is no Truth in you. YOU are
the one destined to be destroyed in the lake of fire to use the
passage you like to quote.
This excerpt from this thread is absolutely devastating for Olcott, not
only showing how fallacious is his claims, but how small integrity he
has.
On 2/22/22 11:05 PM, olcott wrote:
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
This doesn't present the pattern you just claim, so you just committed
that fallacy of the Red Herring.
On 2/24/22 12:01 PM, olcott wrote:
On 2/24/2022 10:55 AM, Richard Damon wrote:
On 2/24/22 10:24 AM, olcott wrote:
On 2/24/2022 6:43 AM, Richard Damon wrote:
On 2/23/22 11:31 PM, olcott wrote:
On 2/23/2022 9:36 PM, Richard Damon wrote:
Then Analytic Truth is a sub-set of Truth. Just like the set of
black cats doesn't contain all cats.
Yes it is yet it encompasses all of mathematics and logic.
As I think back, I now remember on key fact that you are missing.
Analytic Truth requires Proof in a Finite (or sometimes Enumerable)
number of proof steps.
The body of analytic truth is simply a set of true sentences that
are connected together semantically.
Mathematics introduces the concept of UnEnumeratable sets and this
is what breaks the concept of Truth must be Provable. Some things
can be shown true only by a 'meta-analysis' that looks at an
uncountable number of Proof Steps, which Analytic Truth can not
handle, thus it can establish facts that are not Analytically
provable.
This merely requires algorithmic compression. We can know that there
is no maximum integer without having to actually count to infinity.
But you can't compress ALL things. Your assupmtion that you can is a
fallacy. For instance, you assume there must be a finite pattern that
H can detect in its simulation of <H^> <H^> that correctly indicates
that the pattern will repeat forever, when I have shown that no such
pattern exists, as ANY pattern of N steps that H uses and then goes
to H.Qn means that there IS a number K > N such that H^ applied to
<H^> halts in K steps, thus H was wrong.
This also shows where you logic breaks down, you have show an
inability to actually think about things that can become infinite.
The problem with you H is that it actually needs infinite time to
make a valid decision, but it needs to make it in a finite time,
and thus it fails.
That makes the utterly moronic assumption that the most intelligent
and knowledgeable person in the universe could not possibly spot the
infinite loop in the code shown below in less then infinite time:
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
Fallacy of proof by example. FAIL.
That pattern is NOT in H^ applied to <H^>.
I never claimed that H couldn't detect SOME infinite loops,
You claimed that H could not correctly report that the above is an in
finite loop because if H stops simulating it then it is no longer an
infinite loop.
LIAR.So you acknowledge that in the C/x86, H does correctly decide that _Infinite_Loop() never halts ?
I said it could not do it for H^ applied to <H^>
Shows how much you understand the truth.
On 2/24/22 12:01 PM, olcott wrote:
On 2/24/2022 10:55 AM, Richard Damon wrote:
On 2/24/22 10:24 AM, olcott wrote:
On 2/24/2022 6:43 AM, Richard Damon wrote:
On 2/23/22 11:31 PM, olcott wrote:
On 2/23/2022 9:36 PM, Richard Damon wrote:
Then Analytic Truth is a sub-set of Truth. Just like the set of
black cats doesn't contain all cats.
Yes it is yet it encompasses all of mathematics and logic.
As I think back, I now remember on key fact that you are missing.
Analytic Truth requires Proof in a Finite (or sometimes Enumerable)
number of proof steps.
The body of analytic truth is simply a set of true sentences that
are connected together semantically.
Mathematics introduces the concept of UnEnumeratable sets and this
is what breaks the concept of Truth must be Provable. Some things
can be shown true only by a 'meta-analysis' that looks at an
uncountable number of Proof Steps, which Analytic Truth can not
handle, thus it can establish facts that are not Analytically
provable.
This merely requires algorithmic compression. We can know that there
is no maximum integer without having to actually count to infinity.
But you can't compress ALL things. Your assupmtion that you can is a
fallacy. For instance, you assume there must be a finite pattern that
H can detect in its simulation of <H^> <H^> that correctly indicates
that the pattern will repeat forever, when I have shown that no such
pattern exists, as ANY pattern of N steps that H uses and then goes
to H.Qn means that there IS a number K > N such that H^ applied to
<H^> halts in K steps, thus H was wrong.
This also shows where you logic breaks down, you have show an
inability to actually think about things that can become infinite.
The problem with you H is that it actually needs infinite time to
make a valid decision, but it needs to make it in a finite time,
and thus it fails.
That makes the utterly moronic assumption that the most intelligent
and knowledgeable person in the universe could not possibly spot the
infinite loop in the code shown below in less then infinite time:
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
Fallacy of proof by example. FAIL.
That pattern is NOT in H^ applied to <H^>.
I never claimed that H couldn't detect SOME infinite loops,
You claimed that H could not correctly report that the above is an in
finite loop because if H stops simulating it then it is no longer an
infinite loop.
LIAR.
On 2/22/22 11:05 PM, olcott wrote:
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
This doesn't present the pattern you just claim, so you just committed
that fallacy of the Red Herring.
On 2/24/22 2:39 PM, olcott wrote:
On 2/24/2022 12:51 PM, Richard Damon wrote:
On 2/24/22 12:52 PM, olcott wrote:
On 2/24/2022 11:32 AM, Richard Damon wrote:
On 2/24/22 12:01 PM, olcott wrote:So you acknowledge that in the C/x86, H does correctly decide that
On 2/24/2022 10:55 AM, Richard Damon wrote:
On 2/24/22 10:24 AM, olcott wrote:
On 2/24/2022 6:43 AM, Richard Damon wrote:
On 2/23/22 11:31 PM, olcott wrote:
On 2/23/2022 9:36 PM, Richard Damon wrote:
Then Analytic Truth is a sub-set of Truth. Just like the set >>>>>>>>>>> of black cats doesn't contain all cats.
Yes it is yet it encompasses all of mathematics and logic.
As I think back, I now remember on key fact that you are
missing. Analytic Truth requires Proof in a Finite (or
sometimes Enumerable) number of proof steps.
The body of analytic truth is simply a set of true sentences
that are connected together semantically.
Mathematics introduces the concept of UnEnumeratable sets and >>>>>>>>> this is what breaks the concept of Truth must be Provable. Some >>>>>>>>> things can be shown true only by a 'meta-analysis' that looks >>>>>>>>> at an uncountable number of Proof Steps, which Analytic Truth >>>>>>>>> can not handle, thus it can establish facts that are not
Analytically provable.
This merely requires algorithmic compression. We can know that >>>>>>>> there is no maximum integer without having to actually count to >>>>>>>> infinity.
But you can't compress ALL things. Your assupmtion that you can
is a fallacy. For instance, you assume there must be a finite
pattern that H can detect in its simulation of <H^> <H^> that
correctly indicates that the pattern will repeat forever, when I >>>>>>> have shown that no such pattern exists, as ANY pattern of N steps >>>>>>> that H uses and then goes to H.Qn means that there IS a number K >>>>>>> > N such that H^ applied to <H^> halts in K steps, thus H was wrong. >>>>>>>
This also shows where you logic breaks down, you have show an >>>>>>>>> inability to actually think about things that can become
infinite. The problem with you H is that it actually needs
infinite time to make a valid decision, but it needs to make it >>>>>>>>> in a finite time, and thus it fails.
That makes the utterly moronic assumption that the most
intelligent and knowledgeable person in the universe could not >>>>>>>> possibly spot the infinite loop in the code shown below in less >>>>>>>> then infinite time:
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
Fallacy of proof by example. FAIL.
That pattern is NOT in H^ applied to <H^>.
I never claimed that H couldn't detect SOME infinite loops,
You claimed that H could not correctly report that the above is an >>>>>> in finite loop because if H stops simulating it then it is no
longer an infinite loop.
LIAR.
I said it could not do it for H^ applied to <H^>
Shows how much you understand the truth.
_Infinite_Loop() never halts ?
I don't know, because it has never been proven, just claimed.
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit >> [0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
In other words you still believe that it may be impossibly difficult
to tell that the instruction at machine address 00000949 performs an
unconditional branch to the machine address 00000949 ?
Again, the deceptive clipping of quotes.
You asked me if I agreed your program could do this.
My answer was I wasn't sure because you have ever actually shown how youprobram works, or even real proof that it does. My doubts are in your
ability to program.
On 2/24/22 12:52 PM, olcott wrote:
On 2/24/2022 11:32 AM, Richard Damon wrote:
On 2/24/22 12:01 PM, olcott wrote:So you acknowledge that in the C/x86, H does correctly decide that
On 2/24/2022 10:55 AM, Richard Damon wrote:
On 2/24/22 10:24 AM, olcott wrote:
On 2/24/2022 6:43 AM, Richard Damon wrote:
On 2/23/22 11:31 PM, olcott wrote:
On 2/23/2022 9:36 PM, Richard Damon wrote:
Then Analytic Truth is a sub-set of Truth. Just like the set of >>>>>>>>> black cats doesn't contain all cats.
Yes it is yet it encompasses all of mathematics and logic.
As I think back, I now remember on key fact that you are missing. >>>>>>> Analytic Truth requires Proof in a Finite (or sometimes
Enumerable) number of proof steps.
The body of analytic truth is simply a set of true sentences that
are connected together semantically.
Mathematics introduces the concept of UnEnumeratable sets and
this is what breaks the concept of Truth must be Provable. Some
things can be shown true only by a 'meta-analysis' that looks at >>>>>>> an uncountable number of Proof Steps, which Analytic Truth can
not handle, thus it can establish facts that are not Analytically >>>>>>> provable.
This merely requires algorithmic compression. We can know that
there is no maximum integer without having to actually count to
infinity.
But you can't compress ALL things. Your assupmtion that you can is
a fallacy. For instance, you assume there must be a finite pattern
that H can detect in its simulation of <H^> <H^> that correctly
indicates that the pattern will repeat forever, when I have shown
that no such pattern exists, as ANY pattern of N steps that H uses
and then goes to H.Qn means that there IS a number K > N such that
H^ applied to <H^> halts in K steps, thus H was wrong.
This also shows where you logic breaks down, you have show an
inability to actually think about things that can become
infinite. The problem with you H is that it actually needs
infinite time to make a valid decision, but it needs to make it
in a finite time, and thus it fails.
That makes the utterly moronic assumption that the most
intelligent and knowledgeable person in the universe could not
possibly spot the infinite loop in the code shown below in less
then infinite time:
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
Fallacy of proof by example. FAIL.
That pattern is NOT in H^ applied to <H^>.
I never claimed that H couldn't detect SOME infinite loops,
You claimed that H could not correctly report that the above is an
in finite loop because if H stops simulating it then it is no longer
an infinite loop.
LIAR.
I said it could not do it for H^ applied to <H^>
Shows how much you understand the truth.
_Infinite_Loop() never halts ?
I don't know, because it has never been proven, just claimed.
On 2022-02-24 13:33, olcott wrote:
On 2/24/2022 2:22 PM, André G. Isaak wrote:
On 2022-02-24 12:39, olcott wrote:
<snip>
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
In other words you still believe that it may be impossibly difficult
to tell that the instruction at machine address 00000949 performs an
unconditional branch to the machine address 00000949 ?
Your obtuseness knows no bounds.
No one has disputed that it is possible to recognise that the above
is an infinite loop (Richard expressed doubts that *you* were
competent enough to write a program to recognize this, not that such
a program could be written).
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Yet he keeps claiming that the more complex case of embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
is impossible to correctly report because if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
its simulation then ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies infinitely nested >> simulation and if does not abort its simulation then is cannot report.
That is a separate issue, concerned with whether the infinite recursion
you claim exists actually exists. My post wasn't concerned with that
issue (though Richard is correct)
Why not address the ACTUAL point of my post.
How exactly is your
embedded_H supposed to recognize infinite recursion? Please elaborate on
the 'string comparison' you claim is involved.
André
This is precisely analogous the the C/x86 H _Infinite_Loop() not being
able to report that _Infinite_Loop() is an infinite loop because when
H aborts its simulation _Infinite_Loop() stops running.
But the "infinite behaviour pattern" that your embedded_H is supposed
to recognize doesn't remotely resemble the pattern above, so the fact
that the above pattern can be trivially recognized provides *no*
evidence that the pattern found in embedded_H can be algorithmically
recognized whatsoever. Ergo, it is entirely pointless for you to keep
raising this example. It is an entirely irrelevant example; a red
herring.
The "infinite recursion" you claim exists when embedded_H is applied
to <H^> <H^> requires that your embedded_H be able to recognize that
H^ includes a copy of embedded_H within it, not just to find some
instance of "HERE: goto HERE" like above.
You've claimed that this can be done with string comparison, but to
compare strings you need TWO STRINGS TO COMPARE. embedded_H only
takes a SINGLE string (or rather two copies of a single string) as
its input. So what exactly is it supposed to compare this string to?
On 2022-02-24 12:39, olcott wrote:
<snip>
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit >> [0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
In other words you still believe that it may be impossibly difficult
to tell that the instruction at machine address 00000949 performs an
unconditional branch to the machine address 00000949 ?
Your obtuseness knows no bounds.
No one has disputed that it is possible to recognise that the above is
an infinite loop (Richard expressed doubts that *you* were competent
enough to write a program to recognize this, not that such a program
could be written).
But the "infinite behaviour pattern" that your embedded_H is supposed to recognize doesn't remotely resemble the pattern above, so the fact that
the above pattern can be trivially recognized provides *no* evidence
that the pattern found in embedded_H can be algorithmically recognized whatsoever. Ergo, it is entirely pointless for you to keep raising this example. It is an entirely irrelevant example; a red herring.
The "infinite recursion" you claim exists when embedded_H is applied to
<H^> <H^> requires that your embedded_H be able to recognize that H^
includes a copy of embedded_H within it, not just to find some instance
of "HERE: goto HERE" like above.
You've claimed that this can be done with string comparison, but to
compare strings you need TWO STRINGS TO COMPARE. embedded_H only takes a SINGLE string (or rather two copies of a single string) as its input. So
what exactly is it supposed to compare this string to?
André
On 2/24/22 3:33 PM, olcott wrote:
On 2/24/2022 2:22 PM, André G. Isaak wrote:
On 2022-02-24 12:39, olcott wrote:
<snip>
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
In other words you still believe that it may be impossibly difficult
to tell that the instruction at machine address 00000949 performs an
unconditional branch to the machine address 00000949 ?
Your obtuseness knows no bounds.
No one has disputed that it is possible to recognise that the above
is an infinite loop (Richard expressed doubts that *you* were
competent enough to write a program to recognize this, not that such
a program could be written).
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Yet he keeps claiming that the more complex case of embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
is impossible to correctly report because if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
its simulation then ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies infinitely nested >> simulation and if does not abort its simulation then is cannot report.
This is precisely analogous the the C/x86 H _Infinite_Loop() not being
able to report that _Infinite_Loop() is an infinite loop because when
H aborts its simulation _Infinite_Loop() stops running.
The fact that you don't understand the difference between H needing to analyse a simple infinite loop, and H needing to analyse something that
uses a copy of H in it, shows you just don't understand the problem.
You seem oblivious that before you can even create the H^ to test H
with, H has to be made into a fixed algorithm. with fully defined
behavior. This means that the argument about what woud happen if H
didn't abort at the point it does abort is irrelevent.
On 2022-02-24 13:56, olcott wrote:
On 2/24/2022 2:39 PM, André G. Isaak wrote:
On 2022-02-24 13:33, olcott wrote:
On 2/24/2022 2:22 PM, André G. Isaak wrote:
On 2022-02-24 12:39, olcott wrote:
<snip>
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
In other words you still believe that it may be impossibly
difficult to tell that the instruction at machine address 00000949 >>>>>> performs an unconditional branch to the machine address 00000949 ?
Your obtuseness knows no bounds.
No one has disputed that it is possible to recognise that the above
is an infinite loop (Richard expressed doubts that *you* were
competent enough to write a program to recognize this, not that
such a program could be written).
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Yet he keeps claiming that the more complex case of embedded_H ⟨Ĥ⟩ >>>> ⟨Ĥ⟩ is impossible to correctly report because if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
aborts its simulation then ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies infinitely
nested simulation and if does not abort its simulation then is
cannot report.
That is a separate issue, concerned with whether the infinite
recursion you claim exists actually exists. My post wasn't concerned
with that issue (though Richard is correct)
Until it is understood that embedded_H recognizing the infinitely
nested simulation of its input: ⟨Ĥ⟩ ⟨Ĥ⟩ is not a categorical
impossibility I have no motivation what-so-ever to proceed to any
subsequent steps.
But that is *exactly* the step I am asking you about below. I am asking
you HOW your embedded_H recognizes infinitely nested recursion.
This is
NOT the same problem as recognizing an infinite loop.
So how *exactly* does embedded_H recognize when it is being simulated recursively?
Put slightly differently, when you call embedded_H ⟨X⟩ ⟨X⟩ how does it
distinguish between cases where X = Ĥ (i.e cases where X contains a copy
of embedded_H) and cases where X does not equal Ĥ (i.e. cases which do
not involve recursion)?
String comparison won't work. So how do you achieve this?
André
People that are only looking for one excuse or another to reject my
work and have interest at all in understanding what I am saying must
acknowledge each incremental step of mutual agreement before I will
proceed to any subsequent steps.
Why not address the ACTUAL point of my post.
I just explained why.
How exactly is your embedded_H supposed to recognize infinite
recursion? Please elaborate on the 'string comparison' you claim is
involved.
André
This is precisely analogous the the C/x86 H _Infinite_Loop() not
being able to report that _Infinite_Loop() is an infinite loop
because when H aborts its simulation _Infinite_Loop() stops running.
But the "infinite behaviour pattern" that your embedded_H is
supposed to recognize doesn't remotely resemble the pattern above,
so the fact that the above pattern can be trivially recognized
provides *no* evidence that the pattern found in embedded_H can be
algorithmically recognized whatsoever. Ergo, it is entirely
pointless for you to keep raising this example. It is an entirely
irrelevant example; a red herring.
The "infinite recursion" you claim exists when embedded_H is
applied to <H^> <H^> requires that your embedded_H be able to
recognize that H^ includes a copy of embedded_H within it, not just
to find some instance of "HERE: goto HERE" like above.
You've claimed that this can be done with string comparison, but to
compare strings you need TWO STRINGS TO COMPARE. embedded_H only
takes a SINGLE string (or rather two copies of a single string) as
its input. So what exactly is it supposed to compare this string to?
On 2022-02-24 16:41, olcott wrote:
On 2/24/2022 3:38 PM, André G. Isaak wrote:
On 2022-02-24 13:56, olcott wrote:
On 2/24/2022 2:39 PM, André G. Isaak wrote:
On 2022-02-24 13:33, olcott wrote:
On 2/24/2022 2:22 PM, André G. Isaak wrote:
On 2022-02-24 12:39, olcott wrote:
<snip>
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
In other words you still believe that it may be impossibly
difficult to tell that the instruction at machine address
00000949 performs an unconditional branch to the machine address >>>>>>>> 00000949 ?
Your obtuseness knows no bounds.
No one has disputed that it is possible to recognise that the
above is an infinite loop (Richard expressed doubts that *you*
were competent enough to write a program to recognize this, not
that such a program could be written).
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Yet he keeps claiming that the more complex case of embedded_H ⟨Ĥ⟩ >>>>>> ⟨Ĥ⟩ is impossible to correctly report because if embedded_H ⟨Ĥ⟩
⟨Ĥ⟩ aborts its simulation then ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies
infinitely nested simulation and if does not abort its simulation
then is cannot report.
That is a separate issue, concerned with whether the infinite
recursion you claim exists actually exists. My post wasn't
concerned with that issue (though Richard is correct)
Until it is understood that embedded_H recognizing the infinitely
nested simulation of its input: ⟨Ĥ⟩ ⟨Ĥ⟩ is not a categorical >>>> impossibility I have no motivation what-so-ever to proceed to any
subsequent steps.
But that is *exactly* the step I am asking you about below. I am
asking you HOW your embedded_H recognizes infinitely nested recursion.
When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Then these steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
⟨Ĥ5⟩...
The above repeating pattern shows that the correctly simulated input
to embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively >> proving that this simulated input never halts.
If a TM cannot detect what is obvious for humans to see then the
notion of computation is artificially constrained and thus defined
incorrectly.
It is only obvious to a person who has a piece of information that the
TM does not have; namely, that the string passed to Ĥ is a
representation of Ĥ. You need to show how a TM can determine that its
input string is a representation of *itself*. If you can't do this, your solution is unworkable.
And your position that computations are 'defined incorrectly' is absurd. That's like claiming that since people can swim and cars cannot, cars
are 'incorrectly defined'.
Computations aren't an attempt to model what people can or cannot do.
André
On 2/24/22 6:41 PM, olcott wrote:It is at this point on this issue that other reviewers such as {Kaz,
On 2/24/2022 3:38 PM, André G. Isaak wrote:
On 2022-02-24 13:56, olcott wrote:
On 2/24/2022 2:39 PM, André G. Isaak wrote:
On 2022-02-24 13:33, olcott wrote:
On 2/24/2022 2:22 PM, André G. Isaak wrote:
On 2022-02-24 12:39, olcott wrote:
<snip>
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
In other words you still believe that it may be impossibly
difficult to tell that the instruction at machine address
00000949 performs an unconditional branch to the machine address >>>>>>>> 00000949 ?
Your obtuseness knows no bounds.
No one has disputed that it is possible to recognise that the
above is an infinite loop (Richard expressed doubts that *you*
were competent enough to write a program to recognize this, not
that such a program could be written).
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Yet he keeps claiming that the more complex case of embedded_H ⟨Ĥ⟩ >>>>>> ⟨Ĥ⟩ is impossible to correctly report because if embedded_H ⟨Ĥ⟩
⟨Ĥ⟩ aborts its simulation then ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies
infinitely nested simulation and if does not abort its simulation
then is cannot report.
That is a separate issue, concerned with whether the infinite
recursion you claim exists actually exists. My post wasn't
concerned with that issue (though Richard is correct)
Until it is understood that embedded_H recognizing the infinitely
nested simulation of its input: ⟨Ĥ⟩ ⟨Ĥ⟩ is not a categorical >>>> impossibility I have no motivation what-so-ever to proceed to any
subsequent steps.
But that is *exactly* the step I am asking you about below. I am
asking you HOW your embedded_H recognizes infinitely nested recursion.
When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Then these steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
⟨Ĥ5⟩...
The above repeating pattern shows that the correctly simulated input
to embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively >> proving that this simulated input never halts.
If a TM cannot detect what is obvious for humans to see then the
notion of computation is artificially constrained and thus defined
incorrectly.
Except that the pattern only happens if H never aborts it simulation, at which point H has failed by not answering.
On 2/24/22 9:38 PM, olcott wrote:
On 2/24/2022 8:30 PM, Python wrote:
olcott wrote:
On 2/24/2022 7:13 PM, Python wrote:
olcott wrote:
On 2/24/2022 2:22 PM, André G. Isaak wrote:No it is not.
On 2022-02-24 12:39, olcott wrote:
<snip>
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
In other words you still believe that it may be impossibly
difficult to tell that the instruction at machine address
00000949 performs an unconditional branch to the machine address >>>>>>>> 00000949 ?
Your obtuseness knows no bounds.
No one has disputed that it is possible to recognise that the
above is an infinite loop (Richard expressed doubts that *you*
were competent enough to write a program to recognize this, not
that such a program could be written).
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Yet he keeps claiming that the more complex case of embedded_H ⟨Ĥ⟩ >>>>>> ⟨Ĥ⟩ is impossible to correctly report because if embedded_H ⟨Ĥ⟩
⟨Ĥ⟩ aborts its simulation then ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies
infinitely nested simulation and if does not abort its simulation
then is cannot report.
This is precisely analogous the the C/x86 H _Infinite_Loop() not
being able to report that _Infinite_Loop() is an infinite loop
because when H aborts its simulation _Infinite_Loop() stops running. >>>>>
A mindless naysayer.
Didn't even you noticed the sophistry of your argument?
If you think there is an actual error take a shot, this is not about
rhetoric.
I think he is just pointing out that YOUR style is to just mindly object
to what people say without actually trying to understand their arguments.
You have been shown to be wrong so many times, but you never point out
an actual error in the refutations, but just say they must be wrong.
On 2/24/22 10:13 PM, olcott wrote:As soon as embedded_H sees the same infinitely repeating pattern that we
On 2/24/2022 8:46 PM, Richard Damon wrote:
On 2/24/22 9:38 PM, olcott wrote:
On 2/24/2022 8:30 PM, Python wrote:
olcott wrote:
On 2/24/2022 7:13 PM, Python wrote:
olcott wrote:
On 2/24/2022 2:22 PM, André G. Isaak wrote:
On 2022-02-24 12:39, olcott wrote:
<snip>
_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949 ; right here nitwit
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]
In other words you still believe that it may be impossibly >>>>>>>>>> difficult to tell that the instruction at machine address
00000949 performs an unconditional branch to the machine
address 00000949 ?
Your obtuseness knows no bounds.
No one has disputed that it is possible to recognise that the >>>>>>>>> above is an infinite loop (Richard expressed doubts that *you* >>>>>>>>> were competent enough to write a program to recognize this, not >>>>>>>>> that such a program could be written).
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Yet he keeps claiming that the more complex case of embedded_H >>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is impossible to correctly report because if embedded_H
⟨Ĥ⟩ ⟨Ĥ⟩ aborts its simulation then ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies
infinitely nested simulation and if does not abort its
simulation then is cannot report.
This is precisely analogous the the C/x86 H _Infinite_Loop() not >>>>>>>> being able to report that _Infinite_Loop() is an infinite loop >>>>>>>> because when H aborts its simulation _Infinite_Loop() stops
running.
No it is not.
A mindless naysayer.
Didn't even you noticed the sophistry of your argument?
If you think there is an actual error take a shot, this is not about
rhetoric.
I think he is just pointing out that YOUR style is to just mindly
object to what people say without actually trying to understand their
arguments.
You have been shown to be wrong so many times, but you never point
out an actual error in the refutations, but just say they must be wrong. >>>
When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Then these steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
⟨Ĥ5⟩...
Your key rebuttal that embedded_H cannot possibly recognize the
recursive simulation structure of embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ was based on >> rejecting the whole idea of simulating halt deciders.
LIE.
It is based on the fact that embedded_H must be a defined algorithm that
is consistent.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 104:53:37 |
| Calls: | 6,660 |
| Calls today: | 2 |
| Files: | 12,209 |
| Messages: | 5,335,309 |