How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion, this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input
manifesting as decider/input self-referencial conflation, resulting in the contradiction at the heart of the halting problem being a category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion, this
being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input
manifesting as decider/input self-referencial conflation, resulting in
the contradiction at the heart of the halting problem being a category
(type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided via a representation. The act of representation lets us convert items of
category Program to the category of Finite String which can be an input.
The "Pathological Input" *IS* a Program, built by the simple rules of composition that are allowed in the system.
What is the category error?
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion, this
being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input
manifesting as decider/input self-referencial conflation, resulting in
the contradiction at the heart of the halting problem being a category
(type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided via a
representation. The act of representation lets us convert items of
category Program to the category of Finite String which can be an input.
Those two categories you have identified are different hence the category error.
The "Pathological Input" *IS* a Program, built by the simple rules of
composition that are allowed in the system.
Such composition is invalid.
What is the category error?
A category error (also called a category mistake) happens when we talk
about something as if it belonged to a logical or ontological class it
simply doesn’t fit. In other words, we mis-sort an object, property, or question into the wrong “bin,” so the statement can’t possibly be true or
false—it’s just confused. -- ChatGPT
/Flibble
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion, this
being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input
manifesting as decider/input self-referencial conflation, resulting in >>>> the contradiction at the heart of the halting problem being a category >>>> (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided via a >>> representation. The act of representation lets us convert items of
category Program to the category of Finite String which can be an input.
Those two categories you have identified are different hence the category
error.
That is correct. A running program and an input finite
string ARE NOT THE SAME.
The "Pathological Input" *IS* a Program, built by the simple rules of
composition that are allowed in the system.
Such composition is invalid.
Richard is trying to get away with saying that a
finite string THAT IS NOT A RUNNING PROGRAM
<IS> A RUNNING PROGRAM
What is the category error?
A category error (also called a category mistake) happens when we talk
about something as if it belonged to a logical or ontological class it
simply doesn’t fit. In other words, we mis-sort an object, property, or
question into the wrong “bin,” so the statement can’t possibly be true or
false—it’s just confused. -- ChatGPT
/Flibble
Like the question: What time is it (yes or no)?
I came up with that 20 years ago during my work on the HP.
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE NOT
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion, this >>>>> being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input
manifesting as decider/input self-referencial conflation, resulting
in the contradiction at the heart of the halting problem being a
category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided
via a representation. The act of representation lets us convert items
of category Program to the category of Finite String which can be an
input.
Those two categories you have identified are different hence the
category error.
THE SAME.
But there is a direct relationship between the two.
But they are related to each other,
Richard is trying to get away with saying that a finite string THAT ISThe "Pathological Input" *IS* a Program, built by the simple rules of
composition that are allowed in the system.
Such composition is invalid.
NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAM
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite
recursion, this
being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input
manifesting as decider/input self-referencial conflation,
resulting in
the contradiction at the heart of the halting problem being a
category
(type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but
provided via a
representation. The act of representation lets us convert
items of
category Program to the category of Finite String which can be
an input.
Those two categories you have identified are different hence
the category
error.
That is correct. A running program and an input finite
string ARE NOT THE SAME.
The "Pathological Input" *IS* a Program, built by the simple
rules of
composition that are allowed in the system.
Such composition is invalid.
Richard is trying to get away with saying that a
finite string THAT IS NOT A RUNNING PROGRAM
<IS> A RUNNING PROGRAM
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE NOT
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion, this >>>>>> being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input
manifesting as decider/input self-referencial conflation, resulting >>>>>> in the contradiction at the heart of the halting problem being a
category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided
via a representation. The act of representation lets us convert items >>>>> of category Program to the category of Finite String which can be an >>>>> input.
Those two categories you have identified are different hence the
category error.
THE SAME.
But there is a direct relationship between the two.
But they are related to each other,
Richard is trying to get away with saying that a finite string THAT ISThe "Pathological Input" *IS* a Program, built by the simple rules of >>>>> composition that are allowed in the system.
Such composition is invalid.
NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAM
Even if there is some perceived relationship between the two different categories it doesn't mean there still isn't a category error.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one learns), but the question “Who is taller, the lesson?” commits a category error because
a lesson isn’t the kind of thing that has height, regardless of its pedagogical ties to people.
* Cross-category operations are often legitimate—until you confuse levels. – We can plot the graph of a function (an object in analytic geometry)
that encodes the set of ordered pairs (a distinct mathematical category). Recognizing the mapping is fine; calling the graph “a set of numbers” in place of the function is a category slip.
* Philosophical classics.
– Gilbert Ryle’s famous example: someone is shown colleges, libraries, dorms, then asks “But where is the University?” The buildings bear institutional relations to the university, yet “the University” isn’t an
extra building; treating it as one is a category mistake.
/Flibble
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE NOT
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion,
this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input >>>>>>> manifesting as decider/input self-referencial conflation,
resulting in the contradiction at the heart of the halting problem >>>>>>> being a category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided >>>>>> via a representation. The act of representation lets us convert
items of category Program to the category of Finite String which
can be an input.
Those two categories you have identified are different hence the
category error.
THE SAME.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string THATThe "Pathological Input" *IS* a Program, built by the simple rules >>>>>> of composition that are allowed in the system.
Such composition is invalid.
IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAM
Even if there is some perceived relationship between the two different
categories it doesn't mean there still isn't a category error.
So, what is the error, since the input *IS* the finite string that was
built by the program representation operation, and thus *IS* what an
input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one learns),
but the question “Who is taller, the lesson?” commits a category error >> because a lesson isn’t the kind of thing that has height, regardless of
its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't
understand what a representation is.
The input is a finite string that represents a program.
On 5/10/2025 9:51 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input >>>>>>>>> manifesting in a simulating halt decider as infinite recursion, >>>>>>>>> this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input >>>>>>>>> manifesting as decider/input self-referencial conflation,
resulting in the contradiction at the heart of the halting
problem being a category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but
provided via a representation. The act of representation lets us >>>>>>>> convert items of category Program to the category of Finite
String which can be an input.
Those two categories you have identified are different hence the >>>>>>> category error.
NOT THE SAME.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string THAT >>>>>> IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAMThe "Pathological Input" *IS* a Program, built by the simple
rules of composition that are allowed in the system.
Such composition is invalid.
Even if there is some perceived relationship between the two
different categories it doesn't mean there still isn't a category
error.
So, what is the error, since the input *IS* the finite string that was
built by the program representation operation, and thus *IS* what an
input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one
learns), but the question “Who is taller, the lesson?” commits a
category error because a lesson isn’t the kind of thing that has
height, regardless of its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't
understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are different
categories ergo we have a category error.
/Flibble
This made no difference difference until my simulating termination
analyzer discovered they they don't always have the same behavior as was merely presumed for 90 years.
A halt decider was "defined" to report on the behavior of the direct execution of the input ONLY because no one knew that it could possibly
be different behavior than what the input finite string specifies.
Everyone here takes this false assumption as the infallible word of God.
A textbook says it therefore it must be infallible.
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE NOT >>>>> THE SAME.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input >>>>>>>> manifesting in a simulating halt decider as infinite recursion, >>>>>>>> this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input >>>>>>>> manifesting as decider/input self-referencial conflation,
resulting in the contradiction at the heart of the halting problem >>>>>>>> being a category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided >>>>>>> via a representation. The act of representation lets us convert
items of category Program to the category of Finite String which >>>>>>> can be an input.
Those two categories you have identified are different hence the
category error.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string THATThe "Pathological Input" *IS* a Program, built by the simple rules >>>>>>> of composition that are allowed in the system.
Such composition is invalid.
IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAM
Even if there is some perceived relationship between the two different
categories it doesn't mean there still isn't a category error.
So, what is the error, since the input *IS* the finite string that was
built by the program representation operation, and thus *IS* what an
input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one learns), >>> but the question “Who is taller, the lesson?” commits a category error >>> because a lesson isn’t the kind of thing that has height, regardless of >>> its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't
understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are different
categories ergo we have a category error.
On 5/10/2025 10:11 PM, Mr Flibble wrote:
On Sat, 10 May 2025 22:00:26 -0500, olcott wrote:
On 5/10/2025 9:51 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE >>>>>>>> NOT THE SAME.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological >>>>>>>>>>> input manifesting in a simulating halt decider as infinite >>>>>>>>>>> recursion, this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical >>>>>>>>>>> input manifesting as decider/input self-referencial
conflation, resulting in the contradiction at the heart of the >>>>>>>>>>> halting problem being a category (type) error, i.e.
ill-formed.
These two refutations are related but not exactly the same. >>>>>>>>>>>
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but
provided via a representation. The act of representation lets >>>>>>>>>> us convert items of category Program to the category of Finite >>>>>>>>>> String which can be an input.
Those two categories you have identified are different hence the >>>>>>>>> category error.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string >>>>>>>> THAT IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAMThe "Pathological Input" *IS* a Program, built by the simple >>>>>>>>>> rules of composition that are allowed in the system.
Such composition is invalid.
Even if there is some perceived relationship between the two
different categories it doesn't mean there still isn't a category
error.
So, what is the error, since the input *IS* the finite string that
was built by the program representation operation, and thus *IS*
what an input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one
learns), but the question “Who is taller, the lesson?” commits a >>>>>> category error because a lesson isn’t the kind of thing that has >>>>>> height, regardless of its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't
understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are different
categories ergo we have a category error.
/Flibble
This made no difference difference until my simulating termination
analyzer discovered they they don't always have the same behavior as
was merely presumed for 90 years.
A halt decider was "defined" to report on the behavior of the direct
execution of the input ONLY because no one knew that it could possibly
be different behavior than what the input finite string specifies.
Everyone here takes this false assumption as the infallible word of
God.
A textbook says it therefore it must be infallible.
Yes, the reason why these two different categories cause a category
error is because of the self-referential dependency between them, which
manifests as infinite recursion in your simulating halt decider case.
/Flibble
Yes exactly !!!
It is great that some people are not so indoctrinated by dogma that they
can actually think for themselves and not merely follow the herd.
On 5/10/2025 10:45 PM, Mr Flibble wrote:
On Sat, 10 May 2025 22:16:21 -0500, olcott wrote:
On 5/10/2025 10:11 PM, Mr Flibble wrote:
On Sat, 10 May 2025 22:00:26 -0500, olcott wrote:
On 5/10/2025 9:51 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote: >>>>>>>>>>>That is correct. A running program and an input finite string >>>>>>>>>> ARE NOT THE SAME.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological >>>>>>>>>>>>> input manifesting in a simulating halt decider as infinite >>>>>>>>>>>>> recursion, this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical >>>>>>>>>>>>> input manifesting as decider/input self-referencial
conflation, resulting in the contradiction at the heart of >>>>>>>>>>>>> the halting problem being a category (type) error, i.e. >>>>>>>>>>>>> ill-formed.
These two refutations are related but not exactly the same. >>>>>>>>>>>>>
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but >>>>>>>>>>>> provided via a representation. The act of representation lets >>>>>>>>>>>> us convert items of category Program to the category of >>>>>>>>>>>> Finite String which can be an input.
Those two categories you have identified are different hence >>>>>>>>>>> the category error.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string >>>>>>>>>> THAT IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAMThe "Pathological Input" *IS* a Program, built by the simple >>>>>>>>>>>> rules of composition that are allowed in the system.
Such composition is invalid.
Even if there is some perceived relationship between the two
different categories it doesn't mean there still isn't a category >>>>>>>> error.
So, what is the error, since the input *IS* the finite string that >>>>>>> was built by the program representation operation, and thus *IS* >>>>>>> what an input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one >>>>>>>> learns), but the question “Who is taller, the lesson?” commits a >>>>>>>> category error because a lesson isn’t the kind of thing that has >>>>>>>> height, regardless of its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't >>>>>>> understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are different >>>>>> categories ergo we have a category error.
/Flibble
This made no difference difference until my simulating termination
analyzer discovered they they don't always have the same behavior as >>>>> was merely presumed for 90 years.
A halt decider was "defined" to report on the behavior of the direct >>>>> execution of the input ONLY because no one knew that it could
possibly be different behavior than what the input finite string
specifies.
Everyone here takes this false assumption as the infallible word of
God.
A textbook says it therefore it must be infallible.
Yes, the reason why these two different categories cause a category
error is because of the self-referential dependency between them,
which manifests as infinite recursion in your simulating halt decider
case.
/Flibble
Yes exactly !!!
It is great that some people are not so indoctrinated by dogma that
they can actually think for themselves and not merely follow the herd.
Not sure about following the herd: I do have a computer science degree
(BSc (Hons)) but I don't recall us covering the halting problem in any
lectures although to be fair I skipped quite a few lectures to write a
MUD, learning C in the process.
/Flibble
The Halting Problem was only covered in the comp theory course that is
no longer offered. I learned C back when K & R was the official
standard. Been doing mostly C++ for the last 25 years.
On 5/10/2025 11:09 PM, Mr Flibble wrote:
On Sat, 10 May 2025 23:05:17 -0500, olcott wrote:
On 5/10/2025 10:45 PM, Mr Flibble wrote:
On Sat, 10 May 2025 22:16:21 -0500, olcott wrote:
On 5/10/2025 10:11 PM, Mr Flibble wrote:
On Sat, 10 May 2025 22:00:26 -0500, olcott wrote:
On 5/10/2025 9:51 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote: >>>>>>>>>>>>>That is correct. A running program and an input finite string >>>>>>>>>>>> ARE NOT THE SAME.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological >>>>>>>>>>>>>>> input manifesting in a simulating halt decider as infinite >>>>>>>>>>>>>>> recursion, this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical >>>>>>>>>>>>>>> input manifesting as decider/input self-referencial >>>>>>>>>>>>>>> conflation, resulting in the contradiction at the heart of >>>>>>>>>>>>>>> the halting problem being a category (type) error, i.e. >>>>>>>>>>>>>>> ill-formed.
These two refutations are related but not exactly the >>>>>>>>>>>>>>> same.
/Flibble
And the problem is that you use incorrect categories. >>>>>>>>>>>>>>
The decider needs to be of the category "Program". >>>>>>>>>>>>>>
The input also needs to be of the category "Program", but >>>>>>>>>>>>>> provided via a representation. The act of representation >>>>>>>>>>>>>> lets us convert items of category Program to the category >>>>>>>>>>>>>> of Finite String which can be an input.
Those two categories you have identified are different hence >>>>>>>>>>>>> the category error.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite >>>>>>>>>>>> string THAT IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAM >>>>>>>>>>>>The "Pathological Input" *IS* a Program, built by the >>>>>>>>>>>>>> simple rules of composition that are allowed in the system. >>>>>>>>>>>>>Such composition is invalid.
Even if there is some perceived relationship between the two >>>>>>>>>> different categories it doesn't mean there still isn't a
category error.
So, what is the error, since the input *IS* the finite string >>>>>>>>> that was built by the program representation operation, and thus >>>>>>>>> *IS* what an input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one >>>>>>>>>> learns), but the question “Who is taller, the lesson?” commits >>>>>>>>>> a category error because a lesson isn’t the kind of thing that >>>>>>>>>> has height, regardless of its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't >>>>>>>>> understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are
different categories ergo we have a category error.
/Flibble
This made no difference difference until my simulating termination >>>>>>> analyzer discovered they they don't always have the same behavior >>>>>>> as was merely presumed for 90 years.
A halt decider was "defined" to report on the behavior of the
direct execution of the input ONLY because no one knew that it
could possibly be different behavior than what the input finite
string specifies.
Everyone here takes this false assumption as the infallible word >>>>>>> of God.
A textbook says it therefore it must be infallible.
Yes, the reason why these two different categories cause a category >>>>>> error is because of the self-referential dependency between them,
which manifests as infinite recursion in your simulating halt
decider case.
/Flibble
Yes exactly !!!
It is great that some people are not so indoctrinated by dogma that
they can actually think for themselves and not merely follow the
herd.
Not sure about following the herd: I do have a computer science
degree (BSc (Hons)) but I don't recall us covering the halting
problem in any lectures although to be fair I skipped quite a few
lectures to write a MUD, learning C in the process.
/Flibble
The Halting Problem was only covered in the comp theory course that is
no longer offered. I learned C back when K & R was the official
standard. Been doing mostly C++ for the last 25 years.
Been doing mostly C++ for the last 33 years.
/Flibble
I love it. I use it as C with classes.
I never needed anything besides this and the standard template library.
I use std::vector for every array. Never had to deal with the tedium of memory management in my life.
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion, this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input
manifesting as decider/input self-referencial conflation, resulting in the contradiction at the heart of the halting problem being a category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE NOT >>>>> THE SAME.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input >>>>>>>> manifesting in a simulating halt decider as infinite recursion, >>>>>>>> this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input >>>>>>>> manifesting as decider/input self-referencial conflation,
resulting in the contradiction at the heart of the halting problem >>>>>>>> being a category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided >>>>>>> via a representation. The act of representation lets us convert
items of category Program to the category of Finite String which >>>>>>> can be an input.
Those two categories you have identified are different hence the
category error.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string THATThe "Pathological Input" *IS* a Program, built by the simple rules >>>>>>> of composition that are allowed in the system.
Such composition is invalid.
IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAM
Even if there is some perceived relationship between the two different
categories it doesn't mean there still isn't a category error.
So, what is the error, since the input *IS* the finite string that was
built by the program representation operation, and thus *IS* what an
input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one learns), >>> but the question “Who is taller, the lesson?” commits a category error >>> because a lesson isn’t the kind of thing that has height, regardless of >>> its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't
understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are different
categories ergo we have a category error.
/Flibble
On 5/10/2025 9:51 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE NOT >>>>>> THE SAME.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input >>>>>>>>> manifesting in a simulating halt decider as infinite recursion, >>>>>>>>> this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input >>>>>>>>> manifesting as decider/input self-referencial conflation,
resulting in the contradiction at the heart of the halting problem >>>>>>>>> being a category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided >>>>>>>> via a representation. The act of representation lets us convert >>>>>>>> items of category Program to the category of Finite String which >>>>>>>> can be an input.
Those two categories you have identified are different hence the >>>>>>> category error.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string THAT >>>>>> IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAMThe "Pathological Input" *IS* a Program, built by the simple rules >>>>>>>> of composition that are allowed in the system.
Such composition is invalid.
Even if there is some perceived relationship between the two different >>>> categories it doesn't mean there still isn't a category error.
So, what is the error, since the input *IS* the finite string that was
built by the program representation operation, and thus *IS* what an
input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one learns), >>>> but the question “Who is taller, the lesson?” commits a category error >>>> because a lesson isn’t the kind of thing that has height, regardless of >>>> its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't
understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are different
categories ergo we have a category error.
/Flibble
This made no difference difference until my simulating
termination analyzer discovered they they don't always
have the same behavior as was merely presumed for 90
years.
A halt decider was "defined" to report on the behavior
of the direct execution of the input ONLY because no
one knew that it could possibly be different behavior
than what the input finite string specifies.
Everyone here takes this false assumption as the
infallible word of God. A textbook says it therefore
it must be infallible.
On Sat, 10 May 2025 22:00:26 -0500, olcott wrote:
On 5/10/2025 9:51 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE >>>>>>> NOT THE SAME.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input >>>>>>>>>> manifesting in a simulating halt decider as infinite recursion, >>>>>>>>>> this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input >>>>>>>>>> manifesting as decider/input self-referencial conflation,
resulting in the contradiction at the heart of the halting >>>>>>>>>> problem being a category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same. >>>>>>>>>>
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but
provided via a representation. The act of representation lets us >>>>>>>>> convert items of category Program to the category of Finite
String which can be an input.
Those two categories you have identified are different hence the >>>>>>>> category error.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string THAT >>>>>>> IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAMThe "Pathological Input" *IS* a Program, built by the simple >>>>>>>>> rules of composition that are allowed in the system.
Such composition is invalid.
Even if there is some perceived relationship between the two
different categories it doesn't mean there still isn't a category
error.
So, what is the error, since the input *IS* the finite string that was >>>> built by the program representation operation, and thus *IS* what an
input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one
learns), but the question “Who is taller, the lesson?” commits a >>>>> category error because a lesson isn’t the kind of thing that has
height, regardless of its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't
understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are different
categories ergo we have a category error.
/Flibble
This made no difference difference until my simulating termination
analyzer discovered they they don't always have the same behavior as was
merely presumed for 90 years.
A halt decider was "defined" to report on the behavior of the direct
execution of the input ONLY because no one knew that it could possibly
be different behavior than what the input finite string specifies.
Everyone here takes this false assumption as the infallible word of God.
A textbook says it therefore it must be infallible.
Yes, the reason why these two different categories cause a category error
is because of the self-referential dependency between them, which
manifests as infinite recursion in your simulating halt decider case.
/Flibble
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:No. HHH has a string representation, like every program.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion, this
being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input
manifesting as decider/input self-referencial conflation, resulting in
the contradiction at the heart of the halting problem being a category
(type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided via
a representation. The act of representation lets us convert items of
category Program to the category of Finite String which can be an
input.
Those two categories you have identified are different hence the
category error.
No. DDD has only a function call, a condition, and an infinite loop.The "Pathological Input" *IS* a Program, built by the simple rules ofSuch composition is invalid.
composition that are allowed in the system.
Am Sat, 10 May 2025 23:56:36 +0000 schrieb Mr Flibble:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:
On 5/10/25 4:38 PM, Mr Flibble wrote:
No. HHH has a string representation, like every program.How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion, this
being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input
manifesting as decider/input self-referencial conflation, resulting
in the contradiction at the heart of the halting problem being a
category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided via
a representation. The act of representation lets us convert items of
category Program to the category of Finite String which can be an
input.
Those two categories you have identified are different hence the
category error.
No. DDD has only a function call, a condition, and an infinite loop.The "Pathological Input" *IS* a Program, built by the simple rules ofSuch composition is invalid.
composition that are allowed in the system.
On Sun, 11 May 2025 11:49:50 +0000, joes wrote:There is no conflation. HHH is passed a representation of a program.
Am Sat, 10 May 2025 23:56:36 +0000 schrieb Mr Flibble:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:
No. Conflating a program with a string representation of the sameNo. HHH has a string representation, like every program.And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided
via a representation. The act of representation lets us convert items
of category Program to the category of Finite String which can be an
input.
Those two categories you have identified are different hence the
category error.
program in the manner of a self-referential dependency is a category
(type) error.
Nothing is ill-formed about these three things.No. It is ill-formed due to the category error.No. DDD has only a function call, a condition, and an infinite loop.The "Pathological Input" *IS* a Program, built by the simple rules ofSuch composition is invalid.
composition that are allowed in the system.
On 5/10/25 11:11 PM, Mr Flibble wrote:
On Sat, 10 May 2025 22:00:26 -0500, olcott wrote:
On 5/10/2025 9:51 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE >>>>>>>> NOT THE SAME.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological >>>>>>>>>>> input manifesting in a simulating halt decider as infinite >>>>>>>>>>> recursion, this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical >>>>>>>>>>> input manifesting as decider/input self-referencial
conflation, resulting in the contradiction at the heart of the >>>>>>>>>>> halting problem being a category (type) error, i.e.
ill-formed.
These two refutations are related but not exactly the same. >>>>>>>>>>>
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but
provided via a representation. The act of representation lets >>>>>>>>>> us convert items of category Program to the category of Finite >>>>>>>>>> String which can be an input.
Those two categories you have identified are different hence the >>>>>>>>> category error.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string >>>>>>>> THAT IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAMThe "Pathological Input" *IS* a Program, built by the simple >>>>>>>>>> rules of composition that are allowed in the system.
Such composition is invalid.
Even if there is some perceived relationship between the two
different categories it doesn't mean there still isn't a category
error.
So, what is the error, since the input *IS* the finite string that
was built by the program representation operation, and thus *IS*
what an input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one
learns), but the question “Who is taller, the lesson?” commits a >>>>>> category error because a lesson isn’t the kind of thing that has >>>>>> height, regardless of its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't
understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are different
categories ergo we have a category error.
/Flibble
This made no difference difference until my simulating termination
analyzer discovered they they don't always have the same behavior as
was merely presumed for 90 years.
A halt decider was "defined" to report on the behavior of the direct
execution of the input ONLY because no one knew that it could possibly
be different behavior than what the input finite string specifies.
Everyone here takes this false assumption as the infallible word of
God.
A textbook says it therefore it must be infallible.
Yes, the reason why these two different categories cause a category
error is because of the self-referential dependency between them, which
manifests as infinite recursion in your simulating halt decider case.
/Flibble
Which isn't a category error. Your problem is you invoke category errors
in defining your categories.
On Sun, 11 May 2025 06:58:42 -0400, Richard Damon wrote:
On 5/10/25 11:11 PM, Mr Flibble wrote:
On Sat, 10 May 2025 22:00:26 -0500, olcott wrote:
On 5/10/2025 9:51 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE >>>>>>>>> NOT THE SAME.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological >>>>>>>>>>>> input manifesting in a simulating halt decider as infinite >>>>>>>>>>>> recursion, this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical >>>>>>>>>>>> input manifesting as decider/input self-referencial
conflation, resulting in the contradiction at the heart of the >>>>>>>>>>>> halting problem being a category (type) error, i.e.
ill-formed.
These two refutations are related but not exactly the same. >>>>>>>>>>>>
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but >>>>>>>>>>> provided via a representation. The act of representation lets >>>>>>>>>>> us convert items of category Program to the category of Finite >>>>>>>>>>> String which can be an input.
Those two categories you have identified are different hence the >>>>>>>>>> category error.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string >>>>>>>>> THAT IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAMThe "Pathological Input" *IS* a Program, built by the simple >>>>>>>>>>> rules of composition that are allowed in the system.
Such composition is invalid.
Even if there is some perceived relationship between the two
different categories it doesn't mean there still isn't a category >>>>>>> error.
So, what is the error, since the input *IS* the finite string that >>>>>> was built by the program representation operation, and thus *IS*
what an input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one
learns), but the question “Who is taller, the lesson?” commits a >>>>>>> category error because a lesson isn’t the kind of thing that has >>>>>>> height, regardless of its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't
understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are different
categories ergo we have a category error.
/Flibble
This made no difference difference until my simulating termination
analyzer discovered they they don't always have the same behavior as
was merely presumed for 90 years.
A halt decider was "defined" to report on the behavior of the direct
execution of the input ONLY because no one knew that it could possibly >>>> be different behavior than what the input finite string specifies.
Everyone here takes this false assumption as the infallible word of
God.
A textbook says it therefore it must be infallible.
Yes, the reason why these two different categories cause a category
error is because of the self-referential dependency between them, which
manifests as infinite recursion in your simulating halt decider case.
/Flibble
Which isn't a category error. Your problem is you invoke category errors
in defining your categories.
You are simply mistaken, just like Turing and all that followed were mistaken: diagonalization cannot take place because the self-referential dependency is a category error: this is what was overlooked.
/Flibble
On Sun, 11 May 2025 11:49:50 +0000, joes wrote:
Am Sat, 10 May 2025 23:56:36 +0000 schrieb Mr Flibble:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:No. HHH has a string representation, like every program.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion, this >>>>> being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input
manifesting as decider/input self-referencial conflation, resulting
in the contradiction at the heart of the halting problem being a
category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided via >>>> a representation. The act of representation lets us convert items of
category Program to the category of Finite String which can be an
input.
Those two categories you have identified are different hence the
category error.
No. Conflating a program with a string representation of the same program
in the manner of a self-referential dependency is a category (type) error.
No. DDD has only a function call, a condition, and an infinite loop.The "Pathological Input" *IS* a Program, built by the simple rules ofSuch composition is invalid.
composition that are allowed in the system.
No. It is ill-formed due to the category error.
/Flibble
On 5/12/2025 2:19 AM, Mikko wrote:
On 2025-05-11 03:11:43 +0000, Mr Flibble said:
On Sat, 10 May 2025 22:00:26 -0500, olcott wrote:
On 5/10/2025 9:51 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE >>>>>>>>> NOT THE SAME.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input >>>>>>>>>>>> manifesting in a simulating halt decider as infinite recursion, >>>>>>>>>>>> this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical >>>>>>>>>>>> input
manifesting as decider/input self-referencial conflation, >>>>>>>>>>>> resulting in the contradiction at the heart of the halting >>>>>>>>>>>> problem being a category (type) error, i.e. ill-formed. >>>>>>>>>>>>
These two refutations are related but not exactly the same. >>>>>>>>>>>>
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but >>>>>>>>>>> provided via a representation. The act of representation lets us >>>>>>>>>>> convert items of category Program to the category of Finite >>>>>>>>>>> String which can be an input.
Those two categories you have identified are different hence the >>>>>>>>>> category error.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string >>>>>>>>> THATThe "Pathological Input" *IS* a Program, built by the simple >>>>>>>>>>> rules of composition that are allowed in the system.
Such composition is invalid.
IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAM
Even if there is some perceived relationship between the two
different categories it doesn't mean there still isn't a category >>>>>>> error.
So, what is the error, since the input *IS* the finite string that >>>>>> was
built by the program representation operation, and thus *IS* what an >>>>>> input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one
learns), but the question “Who is taller, the lesson?” commits a >>>>>>> category error because a lesson isn’t the kind of thing that has >>>>>>> height, regardless of its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't
understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are different
categories ergo we have a category error.
/Flibble
This made no difference difference until my simulating termination
analyzer discovered they they don't always have the same behavior as
was
merely presumed for 90 years.
A halt decider was "defined" to report on the behavior of the direct
execution of the input ONLY because no one knew that it could possibly >>>> be different behavior than what the input finite string specifies.
Everyone here takes this false assumption as the infallible word of
God.
A textbook says it therefore it must be infallible.
Yes, the reason why these two different categories cause a category
error
is because of the self-referential dependency between them, which
manifests as infinite recursion in your simulating halt decider case.
That is contradicto in adiecto: a refertial dependncy between two
entities
of different categories cannot be self-referential. An entity can have a
self-referential dependncy only to itself and it is always of the same
category as it is itself.
Referential dependency.
void bar()
{
foo();
}
void foo()
{
bar();
}
On 5/12/2025 2:32 AM, Mikko wrote:
On 2025-05-11 11:52:05 +0000, Mr Flibble said:
On Sun, 11 May 2025 11:49:50 +0000, joes wrote:
Am Sat, 10 May 2025 23:56:36 +0000 schrieb Mr Flibble:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:No. HHH has a string representation, like every program.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input
manifesting in a simulating halt decider as infinite recursion, this >>>>>>> being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input >>>>>>> manifesting as decider/input self-referencial conflation, resulting >>>>>>> in the contradiction at the heart of the halting problem being a >>>>>>> category (type) error, i.e. ill-formed.
These two refutations are related but not exactly the same.
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but provided >>>>>> via
a representation. The act of representation lets us convert items of >>>>>> category Program to the category of Finite String which can be an
input.
Those two categories you have identified are different hence the
category error.
No. Conflating a program with a string representation of the same
program
in the manner of a self-referential dependency is a category (type)
error.
There are several meanings for the word "program" but a common one is a
string that specifies what shall happen when the program is executed.
One possible string representation of that string is the string itself.
A better name is computational unit.
On 5/12/2025 2:19 AM, Mikko wrote:
On 2025-05-11 03:11:43 +0000, Mr Flibble said:
On Sat, 10 May 2025 22:00:26 -0500, olcott wrote:
On 5/10/2025 9:51 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:49:41 -0400, Richard Damon wrote:
On 5/10/25 9:18 PM, Mr Flibble wrote:
On Sat, 10 May 2025 21:07:34 -0400, Richard Damon wrote:
On 5/10/25 9:00 PM, olcott wrote:
On 5/10/2025 6:56 PM, Mr Flibble wrote:
On Sat, 10 May 2025 18:40:53 -0400, Richard Damon wrote:That is correct. A running program and an input finite string ARE >>>>>>>>> NOT THE SAME.
On 5/10/25 4:38 PM, Mr Flibble wrote:
How my refutation differs to Peter's:
* Peter refutes the halting problem based on pathological input >>>>>>>>>>>> manifesting in a simulating halt decider as infinite recursion, >>>>>>>>>>>> this being treated as non-halting.
* Flibble refutes the halting problem based on patholgical input >>>>>>>>>>>> manifesting as decider/input self-referencial conflation, >>>>>>>>>>>> resulting in the contradiction at the heart of the halting >>>>>>>>>>>> problem being a category (type) error, i.e. ill-formed. >>>>>>>>>>>>
These two refutations are related but not exactly the same. >>>>>>>>>>>>
/Flibble
And the problem is that you use incorrect categories.
The decider needs to be of the category "Program".
The input also needs to be of the category "Program", but >>>>>>>>>>> provided via a representation. The act of representation lets us >>>>>>>>>>> convert items of category Program to the category of Finite >>>>>>>>>>> String which can be an input.
Those two categories you have identified are different hence the >>>>>>>>>> category error.
But there is a direct relationship between the two.
But they are related to each other,Richard is trying to get away with saying that a finite string THAT >>>>>>>>> IS NOT A RUNNING PROGRAM <IS> A RUNNING PROGRAMThe "Pathological Input" *IS* a Program, built by the simple >>>>>>>>>>> rules of composition that are allowed in the system.
Such composition is invalid.
Even if there is some perceived relationship between the two
different categories it doesn't mean there still isn't a category >>>>>>> error.
So, what is the error, since the input *IS* the finite string that was >>>>>> built by the program representation operation, and thus *IS* what an >>>>>> input needs to be.
Why relationship doesn’t rescue the mistake:
* Shared context ≠ shared type.
– A pupil and a teacher are clearly related (one teaches, one
learns), but the question “Who is taller, the lesson?” commits a >>>>>>> category error because a lesson isn’t the kind of thing that has >>>>>>> height, regardless of its pedagogical ties to people.
Which doesn't apply here, and you are just indicationg you don't
understand what a representation is.
The input is a finite string that represents a program.
A program and a finite string representing a program are different
categories ergo we have a category error.
/Flibble
This made no difference difference until my simulating termination
analyzer discovered they they don't always have the same behavior as was >>>> merely presumed for 90 years.
A halt decider was "defined" to report on the behavior of the direct
execution of the input ONLY because no one knew that it could possibly >>>> be different behavior than what the input finite string specifies.
Everyone here takes this false assumption as the infallible word of God. >>>> A textbook says it therefore it must be infallible.
Yes, the reason why these two different categories cause a category error >>> is because of the self-referential dependency between them, which
manifests as infinite recursion in your simulating halt decider case.
That is contradicto in adiecto: a refertial dependncy between two entities >> of different categories cannot be self-referential. An entity can have a
self-referential dependncy only to itself and it is always of the same
category as it is itself.
Referential dependency.
void bar()
{
foo();
}
void foo()
{
bar();
}
On 5/12/2025 9:38 AM, Richard Heathfield wrote:
On 12/05/2025 15:32, olcott wrote:
On 5/12/2025 2:32 AM, Mikko wrote:
On 2025-05-11 11:52:05 +0000, Mr Flibble said:
On Sun, 11 May 2025 11:49:50 +0000, joes wrote:
<snip>
No. HHH has a string representation, like every program.
No. Conflating a program with a string representation of the same program >>>>> in the manner of a self-referential dependency is a category (type) error.
There are several meanings for the word "program" but a common one is a >>>> string that specifies what shall happen when the program is executed.
One possible string representation of that string is the string itself. >>>>
A better name is computational unit.
That's a terrible name. But okay, if you think it's better, who is
anyone here to stop you using it? Just don't expect me to.
What other name encompasses
(a) subroutines
(b) programs
(c) integrated systems comprised of many programs
On 2025-05-12 15:51:21 +0000, olcott said:
On 5/12/2025 9:38 AM, Richard Heathfield wrote:
On 12/05/2025 15:32, olcott wrote:
On 5/12/2025 2:32 AM, Mikko wrote:
On 2025-05-11 11:52:05 +0000, Mr Flibble said:
On Sun, 11 May 2025 11:49:50 +0000, joes wrote:
<snip>
No. HHH has a string representation, like every program.
No. Conflating a program with a string representation of
the same program
in the manner of a self-referential dependency is a
category (type) error.
There are several meanings for the word "program" but a
common one is a
string that specifies what shall happen when the program is
executed.
One possible string representation of that string is the
string itself.
A better name is computational unit.
That's a terrible name. But okay, if you think it's better,
who is anyone here to stop you using it? Just don't expect me to.
What other name encompasses
(a) subroutines
(b) programs
(c) integrated systems comprised of many programs
Software
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 148:13:29 |
| Calls: | 10,383 |
| Calls today: | 8 |
| Files: | 14,054 |
| D/L today: |
2 files (1,861K bytes) |
| Messages: | 6,417,740 |