Re: The philosophy of computation reformulates existing ideas on a new basis ---

On 10/28/2024 6:16 AM, Richard Damon wrote:

On 10/27/24 10:55 PM, olcott wrote:

On 10/27/2024 9:26 PM, Richard Damon wrote:

On 10/27/24 6:01 PM, olcott wrote:

On 10/27/2024 12:48 PM, Richard Damon wrote:

On 10/27/24 10:17 AM, olcott wrote:

I am keeping this post in both sci.logic and comp.theory
because it focuses on a similar idea to the Curry/Howard
correspondence between formal systems and computation.
>
Computation and all of the mathematical and logical operations
of mathematical logic can be construed as finite string
transformation rules applied to finite strings.
>
The semantics associated with finite string tokens can
be directly accessible to expression in the formal language.
It is basically an enriched type hierarchy called a knowledge
ontology.
>
A computation can be construed as the tape input to a
Turing machine and its tape output. All of the cases
where the output was construed as a set of final machine
states can be written to the tape.
>
I am not sure but I think that this may broaden the scope
of a computable function, or not.

>
Except that nothing you described related to what a "computabe function"

>
I intend to reply to other aspects of your reply later
on as long as your reply to this reply is not lame.
>
When a Turing machine transforms the contents of its
input tape into the contents of its output tape this
seems to necessarily always be a computable function
no matter what the TM does in-between.
>

>
Yes, a Turing Machine will always be computing the mapping from some computable function.
>
It is NOT the "Computable Function" itself, as that is a thing of a different ty[pe.
>
It just computed the mapping definied by that function.
>
Note, the mapping of the function might not be defined in terms of "finite-strings", but will be something that can be described by a finite string if we want to talk about it being computable.
>

>
Yes. We are getting somewhere now.
>

For instance, the Halting Function, that the Halting problem is about, is defined with Turing Machines as its input (not finite strings).
>

>
Not in the least little bit.
It seems totally crazy that you would say this.

 

>
It has always been finite string Turing Machine descriptions.

 The machine being used to compute the Halting Function has taken a finite string description, the Halting Function itself always took a Turing Machine,
 

That is incorrect. It has always been the finite string Turing Machine
description of a Turing machine is the input to the halt decider.
There are always been a distinction between the abstraction and the
encoding.

These finite strings do have a specific semantics associated
with them and that is the semantics of Turing Machines.

 No, the method of representing the Turing Machine is defined by the decider.
 The "Semantics of Turing Machines" does have a finite string representation.

It may seem that way because there is no currently universal standard
like there is for the x86 language. For these thing to be properly
investigated we must begin with a standard language. The machine
merely conforms to that standard.

 It defines a Turing Machine as having a "Set of States" (and "States" don't have a defined string representation
 

  A turing machine program consists of a list of 'quintuples', each one of which is a five-symbol turing machine instruction.  For example, the quintuple 'SCcsm' is executed by the machine if it is in state 'S' and is reading the symbol 'C' on the tape.  In that case, the instruction causes the machine to make a transition to state 's' and to overwrite the symbol 'C' on the tape with the symbol 'c'.  The last operation it performs under this instruction is to move the tape reading head one symbol to the left or right according to whether 'm' is 'l' or 'r'.
http://www.lns.mit.edu/~dsw/turing/doc/tm_manual.txt
SCcsm
current state number,
current symbol,
overwrite current symbol
next state number,
move tape head left or right

>

The key point here is that different implementation of a attempted Turing Machines to try to compute this might use different ways of representing the machines, so the function can't just be thought of as taking the string.
>

>
A string that maps to the semantics of Turing Machines.
The bytes of x86 machine code have the precisely defined
semantics of the x86 language.

 Right, so in the context of a decider defined to take an input encoded as an x86 binary, that is how you defined the form of the representation.
 

Yes.

That didn't come from the rules of Turing Machines,
 

Already specified above: SCcsm easy to implement in existing hardware.

>

We can look at the equivalent mapping based on the encoding of the given decider, if the encoding has the required property that a given finite string can only represent one Turing Machine by the rules of that decider.
>

>
We simply hypothesize some arbitrary specific standard.
No need to actually do this WHEN WE UNDERSTAND THAT X86
EXAMPLE <IS> ISOMORPHIC TO LINZ.

 But it isn't, and CAN'T be because you don't even have two seperate programs, but one which intertines its own code with its data.
 You just don't know what "Isomorphic" means.
 

Isomorphic like analogous does not mean identical in every way.
In both cases the input is defined to do the opposite of whatever
value the termination analyzer returns. The key essence remains
the same.

In the Linz statement, H^ contained its own copy of H, and was built to run as its own independent machine. In your system, you have claimed that it can't be done.

Without many thousands of more development hours on my part.
AProVE: Non-Termination Witnesses for C Programs, may be able
to already do this.

Therefore, you have limited your system to something less than Turing Complete.
 

>

Note, This is one spot your HHH/DDD pairing fails, as what you want to claim as the input reprenting DDD does NOT have that property, as the finite string does not represent a specific computation, as it depends on what HHH it is being pair with.

>
You really can't simply get away with simply ignoring
the self-reference by pretending that it does not exist
without looking foolish.

 Ane you can't ignore the definition of the system, like what a PROGRAM is. What you want to call "DDD" isn't a program, and thus isn't a proper input for a program behavior analysizer like a Halt Decider or a Termination Analyzer.
 

It <is> sufficiently isomorphic. The Linz H runs into the
exact same key element of the halting problem proofs where
an input is defined to do the opposite of whatever value
that it returns.
x86utm simply cannot evaluate the effects of arbitrary
conditional branch instructions. AProVE: Non-Termination
Witnesses for C Programs can already do this.

>
*MAYBE YOU NEED TO REREAD THIS 10,000 TIMES*
When HHH emulates itself emulating DDD this is different than HHH1 emulating itself emulating DDD because the first case really happens
and the second case cannot possibly happen.
>

 Only in your NON-TURING EQUIVALENT system.
 

In the x86 language that is Turing equivalent in every way
except unlimited memory. To the best of my knowledge all of
my code can be encoded in a Rasp machine.

Sorry, you are just proving that you are a stupid idiot that doesn't know what you are talking about.
 

That totally over-the-top statement makes you look quite foolish
and greatly reduces your credibility as you have been warned by
several others.
I consistently prove that I do know what I am talking about and
you consistently fail to point out any specific errors.
Philosophy of computation examines different ways of doing
things besides the ways carefully memorized from textbooks.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer