Philosophy Now Forum

PeteOlcott wrote: ↑Sun May 08, 2022 8:58 pm Eventually, the whole process may terminate, which we achieve in a Turing machine by putting it into a halt state. A Turing machine is said to halt whenever it reaches a configuration for which δ is not defined; this is possible because δ is a partial function. In fact, we will assume that no transitions are defined for any final state, so the Turing machine will halt whenever it enters a final state. (Linz-1990:234)

PeteOlcott wrote: ↑Sun May 08, 2022 8:58 pm Eventually, the whole process may terminate, which we achieve in a Turing machine by putting it into a halt state. A Turing machine is said to halt whenever it reaches a configuration for which δ is not defined; this is possible because δ is a partial function. In fact, we will assume that no transitions are defined for any final state, so the Turing machine will halt whenever it enters a final state. (Linz-1990:234)

Skepdick wrote: ↑Sun May 08, 2022 9:00 pm

PeteOlcott wrote: ↑Sun May 08, 2022 8:58 pm Eventually, the whole process may terminate, which we achieve in a Turing machine by putting it into a halt state. A Turing machine is said to halt whenever it reaches a configuration for which δ is not defined; this is possible because δ is a partial function. In fact, we will assume that no transitions are defined for any final state, so the Turing machine will halt whenever it enters a final state. (Linz-1990:234)

Do you understand that you, as the observer of the Turing machine cannot determine whether it halted because it reached a final state; or whether it halted because it reached an undefined state.

PeteOlcott wrote: ↑Sun May 08, 2022 9:18 pm Since I am creating a Turing machine interpreter from scratch on the basis of this system I know that your statement is ridiculously ignorant:
http://www.lns.mit.edu/~dsw/turing/turing.html

It easy for one TM to see that its simulated slave TM reaches a point where there are no transitions out of its current state.

while True:
    pass

Skepdick wrote: ↑Sun May 08, 2022 9:24 pm

PeteOlcott wrote: ↑Sun May 08, 2022 9:18 pm Since I am creating a Turing machine interpreter from scratch on the basis of this system I know that your statement is ridiculously ignorant:
http://www.lns.mit.edu/~dsw/turing/turing.html

It easy for one TM to see that its simulated slave TM reaches a point where there are no transitions out of its current state.

Sigh. Idiot.

There is no way for you to prove the liveness property of a process you are executing because you have the wait() operator.

So you can trivially implement a system of two processes (A and B) such that A waits until B terminates and B waits until A terminates.

https://en.wikipedia.org/wiki/Wait_(system_call)

If your interpreter solves this problem then you have solved the Dining philosophers problem.

PeteOlcott wrote: ↑Sun May 08, 2022 9:31 pm It is a very common practice in operating system design to make context switches between processes even when there is only one actual physical processor. I implemented this in the x86utm operating system. I had to write all of the operating system calls myself from scratch. x86utm directly executes the COFF object file output from the Microsoft C compiler.

Skepdick wrote: ↑Sun May 08, 2022 9:33 pm

PeteOlcott wrote: ↑Sun May 08, 2022 9:31 pm It is a very common practice in operating system design to make context switches between processes even when there is only one actual physical processor. I implemented this in the x86utm operating system. I had to write all of the operating system calls myself from scratch. x86utm directly executes the COFF object file output from the Microsoft C compiler.

Yeah.... it's a very common practice. Context switches are handled by your operating system. Without getting bogged down into the various multi-tasking strategies (cooperative vs pre-emptive etc.)

The operating system is a process which DOES NOT HALT. It loops indefinitely by design. and until instructed to terminate.

Literally every daemon/background process has an infinite control loop.

PeteOlcott wrote: ↑Sun May 08, 2022 9:41 pm x86utm executes H which invokes an excellent open source x86 emulator to emulate the input to H(P,P) in debug step mode.
https://www.researchgate.net/publicatio ... ulation_V5
Shows exactly how H(P,P) correctly determines that its input does not halt.

PeteOlcott wrote: ↑Sun May 08, 2022 9:54 pm H simulates its input one x86 instruction at a time until it correctly matches a non-halting behavior pattern, as H(P,P) correctly does. Then it aborts this simulation and rejects this input as H(P,P) correctly does.

int main() {
	for(;;){
	};
}

loop{} 

while True:
    pass

main = do main

Skepdick wrote: ↑Sun May 08, 2022 9:56 pm

PeteOlcott wrote: ↑Sun May 08, 2022 9:54 pm H simulates its input one x86 instruction at a time until it correctly matches a non-halting behavior pattern, as H(P,P) correctly does. Then it aborts this simulation and rejects this input as H(P,P) correctly does.

This non-halting C program doesn't exhibit non-halting behavior!
It doesn't exhibit ANY behavior!

It just does nothing. Forever.

Code: Select all

int main() {
	for(;;){
	};
}

_main()
[000013a2](01)  55              push ebp
[000013a3](02)  8bec            mov ebp,esp
[000013a5](02)  ebfe            jmp 000013a5
[000013a7](01)  5d              pop ebp
[000013a8](01)  c3              ret
Size in bytes:(0007) [000013a8]

PeteOlcott wrote: ↑Sun May 08, 2022 10:06 pm

Skepdick wrote: ↑Sun May 08, 2022 9:56 pm

PeteOlcott wrote: ↑Sun May 08, 2022 9:54 pm H simulates its input one x86 instruction at a time until it correctly matches a non-halting behavior pattern, as H(P,P) correctly does. Then it aborts this simulation and rejects this input as H(P,P) correctly does.

This non-halting C program doesn't exhibit non-halting behavior!
It doesn't exhibit ANY behavior!

It just does nothing. Forever.

Code: Select all

int main() {
	for(;;){
	};
}

Code: Select all

_main()
[000013a2](01)  55              push ebp
[000013a3](02)  8bec            mov ebp,esp
[000013a5](02)  ebfe            jmp 000013a5
[000013a7](01)  5d              pop ebp
[000013a8](01)  c3              ret
Size in bytes:(0007) [000013a8]

Wrong !

PeteOlcott wrote: ↑Sun May 08, 2022 10:06 pm

Skepdick wrote: ↑Sun May 08, 2022 9:56 pm

PeteOlcott wrote: ↑Sun May 08, 2022 9:54 pm H simulates its input one x86 instruction at a time until it correctly matches a non-halting behavior pattern, as H(P,P) correctly does. Then it aborts this simulation and rejects this input as H(P,P) correctly does.

This non-halting C program doesn't exhibit non-halting behavior!
It doesn't exhibit ANY behavior!

It just does nothing. Forever.

Code: Select all

int main() {
	for(;;){
	};
}

Code: Select all

_main()
[000013a2](01)  55              push ebp
[000013a3](02)  8bec            mov ebp,esp
[000013a5](02)  ebfe            jmp 000013a5
[000013a7](01)  5d              pop ebp
[000013a8](01)  c3              ret
Size in bytes:(0007) [000013a8]

Wrong !

#include <stdio.h>
#include <stdlib.h>

int main() {
	for(;;){
		if (rand() == 1) {
			break;
		};
	};
}

PeteOlcott wrote: ↑Sun May 08, 2022 10:31 pm Number of Instructions Executed(680)

#include <stdio.h>
#include <stdlib.h>

int main() {
	for(;;){
		if (rand() < 0) {
			break;
		};
	};
}