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" is at all, as a "Computable Function" is just a Function (which is just a specific, but arbitrary, mapping of an input space to an output space) that can have a computation built that computes that mapping based on representations of items in the input space to representations of items in the output space.
The operations of formal systems can thus be directly
performed by a TM. to make things more interesting the
tape alphabet is UTM-32 of a TM equivalent RASP machine.
On 10/27/2024 6:38 AM, Richard Damon wrote:
On 10/26/24 9:22 PM, olcott wrote:
On 10/26/2024 8:04 PM, Richard Damon wrote:
On 10/26/24 5:57 PM, olcott wrote:
On 10/26/2024 10:48 AM, Richard Damon wrote:
On 10/26/24 8:59 AM, olcott wrote:
On 10/26/2024 2:52 AM, Mikko wrote:
On 2024-10-25 14:37:19 +0000, olcott said:
>
On 10/25/2024 3:14 AM, Mikko wrote:
On 2024-10-24 16:07:03 +0000, olcott said:
>
On 10/24/2024 9:06 AM, Mikko wrote:
On 2024-10-22 15:04:37 +0000, olcott said:
>
On 10/22/2024 2:39 AM, Mikko wrote:
On 2024-10-22 02:04:14 +0000, olcott said:
>
On 10/16/2024 11:37 AM, Mikko wrote:
On 2024-10-16 14:27:09 +0000, olcott said:
>
The whole notion of undecidability is anchored in ignoring the fact that
some expressions of language are simply not truth bearers.
>
A formal theory is undecidable if there is no Turing machine that
determines whether a formula of that theory is a theorem of that
theory or not. Whether an expression is a truth bearer is not
relevant. Either there is a valid proof of that formula or there
is not. No third possibility.
>
>
After being continually interrupted by emergencies
interrupting other emergencies...
>
If the answer to the question: Is X a formula of theory Y
cannot be determined to be yes or no then the question
itself is somehow incorrect.
>
There are several possibilities.
>
A theory may be intentionally incomplete. For example, group theory
leaves several important question unanswered. There are infinitely
may different groups and group axioms must be true in every group.
>
Another possibility is that a theory is poorly constructed: the
author just failed to include an important postulate.
>
Then there is the possibility that the purpose of the theory is
incompatible with decidability, for example arithmetic.
>
An incorrect question is an expression of language that
is not a truth bearer translated into question form.
>
When "X a formula of theory Y" is neither true nor false
then "X a formula of theory Y" is not a truth bearer.
>
Whether AB = BA is not answered by group theory but is alwasy
true or false about specific A and B and universally true in
some groups but not all.
>
See my most recent reply to Richard it sums up
my position most succinctly.
>
We already know that your position is uninteresting.
>
>
Don't want to bother to look at it (AKA uninteresting) is not at
all the same thing as the corrected foundation to computability
does not eliminate undecidability.
>
No, but we already know that you don't offer anything interesting
about foundations to computability or undecidabilty.
>
In the same way that ZFC eliminated RP True_Olcott(L,x)
eliminates undecidability. Not bothering to pay attention
is less than no rebuttal what-so-ever.
>
No, not in the same way.
>
Pathological self reference causes an issue in both cases.
This issue is resolved by disallowing it in both cases.
>
Nope, because is set theory, the "self-reference"
>
does exist and is problematic in its several other instances.
Abolishing it in each case DOES ELIMINATE THE FREAKING PROBLEM.
>
>
Yes, IN SET THEORY, the "self-reference" can be banned, by the nature of the contstruction.
>
>
That seems to be the best way.
>
It works for sets, but not for Computations, due to the way things are defined.
>
>
In Computation Theory it can not, without making the system less than Turing Complete, as the structure of the Computations fundamentally allow for it,
>
Sure.
>
So, you ADMIT that your computation system you are trying to advocate is less than Turing Complete?
>
I never said that.
Sure you do.
You have said that D isn't allowed to make its own copy of H.
YOu have said that some inputs are just not allowed to be given.
In a Turing Complete system, ANY program can have a copy of it made and be encorporated within the code of another totally independent program.
And a Turing Complete decider can take *ANY* input and decide on it.
That means that the Halting Problem isn't a problem.
>
>
and in a way that is potentially undetectable.
>
>
I really don't think so it only seems that way.
>
Of course it is.
>
The method of assigning meaning to the symbols can be done is a meta- system that the system doesn't know about, and thus its meaning is unknowable to the logic system.
>
When the only way that you learn is to memorize things from books
you make huge mistakes. It is the typical convention to assign
meaning in a way that the systems is unaware of. This is not the
only possible way. It is a ridiculously stupid way that causes
all kinds of undetectable semantic errors.
And when it is clear that you NEVER LEARNED anything you talk about, but only rotely quote things out of ignroance, you prove yourself to be just an ignorant pathological liar.
The "system" knows the mathematics of the numbers, and that might be all.
The "meta-system" can know properties of the numbers, and properties that partucular operations preserve.
There is no "semantic" error, as the numbers have always meant what they meant.
Note, the fact that it *IS* possible to assign this meaning in a way that the system is unaware of, is what keeps the system from having any ability to have a rule to reject things based on that meaning.
If there is a semantic error in the operation, then you should be able to show where said error came about by a semantic error in the meta-system.
Remember, you can not get a semantic error by starting with just semantically correct axioms, and applying only sematnically correct operations to them.
If you can, then your system just started out broken.
>
You don't seem to understand that fact, but the fundamental nature of being able to encode your processing in the same sort of strings you process makes this a possibility.
>
>
Not at all. Tarski made this mistake of saying this and
everyone believed him.
Nope, he PROVED that the statement was constructable with only the assumption that True(L, x) existed as a predicate.
It does not make these things undetectable, it merely
allows failing to detect.
>
No, it makes things undetectable, unless you allow the system to just reject ALL statements, even if they are not actually "self- referential" to be considered "bad".
>
When we encode natural langugae as formal language
"This sentence is not true"
becomes:
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
A detected error.
And, you need to show how you got to that first encoding from a semantically correct statement.
Yes, starting with an error, you can prove that there is an error.
>
Dues to the nature of its relationship to Mathematics and Logic, it turns out that and logic with certain minimal requirements can get into a similar situation.
>
>
I think that I can see deeper than the Curry/Howard Isomorphism.
Computations and formal systems are in their most basic foundational essence finite string transformation rules.
>
You don't undertstand what you see.
>
Part of the problem is that while Compuation Theory and Formal Logic System do have large parts that are just finite string transformation rules, they have other parts that are not.
>
You won't be able to show this. Try to define any computation
that cannot be expressed as a tape input and a tape output.
Because I wasn't talking about a "Computation" but about the definition of a FUNCTION, as defined in Computation Theory.
There is no requirement that Functions be expressable as a finite finite string transformation.
It is just a mapping of a possible infinite set of input strings to output strings by some rule, that is deterministic but may not necessarily be finite.
For instance, Halt(M, d) maps to 1 if the Turing Machine M, when given the input tape d, will halt is some finite number of steps (but no upper bound to the number of steps it can take) while it maps to 0 if that Machine given that data will keep on processing even when allowed to run for an unbounded number of step (aka infinity). That definition is NOT a "computation" as it does not always give an answer in a finite number of steps, but is a mapping.
A TM takes its tape as input and has a set of final states and
or a tape output. The final states could be written to the tape.
You memorize from textbooks and I see deeper than textbooks say.
But you seem to have missed what the theory was all about, and its focus wasn't the behavior of the Turing Machine, that was just a tool to use to define what IS computable, and to try to decide what is and what is not computable.
>
Your only way to remove it from these fields is to remove that source of "power" in the systems, and the cost of that is just too high for most people, thus you plan just fails.
>
>
Detection then rejection.
>
But since detection is impossible, you can not get to rejection.
>
Detection is "impossible" only because of foundational misconceptions.
No, it is impossible because it is impossible in the actual field.
Since you got the field backwards, and think it is asking about behavior of Turing Machines, you just don't undetstand what you are doing.
Once you allow the creation of the statement, you can't reject it later and still have the claim of handling "All".
>
Sure you can. As long as the error is detected before final
output all is well.
And if that can't be done in a finite number of steps, it can't be done.
The problem is that *ALL* is a big number.
>
Of course, you understanding is too crude to see this issue, so it just goes over your head, and your claims just reveal your ignorance of the fields.
>
Sorry, that is just the facts, that you seem to be too stupid to understand.
>
In other words you can correctly explain every single detail
conclusively proving how finite string transformation rules
are totally unrelated to either computation and formal systems.
>
>
That isn't what I said, and just proves your stupidity.
>
You mind is just too small to handle these discussions.
You can't even form sound rebuttals. The main rebuttal that
you have is essentially anchored in ad hominem. Your rebuttals
never have anything in the ballpark of sound reasoning.
And you don't understand even what an ad hominem is. Ad hominem means I say you are wrong because of something that you are, but that isn't what I do. I point out your errors, by quoting the established FACTS of the system. THAT is what makes you wrong, that you don't follow the REQUIRED rules of the system you claim to be working in.
You ignore them, proving you are too stupid to know what you are doing, thus PROVING my observations about you.
You aren't wrong because you are stupid, you are stupid because you keep on insisting on things that have been proven wrong. That just follows the meaning of the words.
*The form of your best rebuttals*
I memorized X from a book and you are not doing it that way
therefore you are stupid and ignorant.
Nope, I can quote the RULE that defines the system, and which violating puts you out of the system. You just admit you are out of the system because you won't follow the rules, and then LIE that you are in the system by trying to say the rules don't matter (when they are the definition of what does matter).
The philosophy of computation begins with existing ideas and
sees what happens when these ideas are reformulated.
Maybe the "Philospophy" of Computation, but not the SCIENCE of Computation Theory.
SCIENCE follows the rules, something you don't seem to understand, because you are just ignorant of the basics.
Sorry, you are just proving your utter ignorance of what you talk about and your stupidity in reasoning about things that you claim you know.
The philosophy of computation reformulates existing ideas on a new basis ---
Re: The philosophy of computation reformulates existing ideas on a new basis ---