Welcome to Rocksolid Light

mail files register newsreader groups login

Message-ID:

fortune: not found

Re: H(D,D)==0 is correct when reports on the actual behavior that it sees

Subject	Author
Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior YES/NO	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior YES/NO	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --a	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --a	immibis
H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --a	olcott
When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior it actually sees then it is correct	olcott
Re: When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior it actually sees then it is correct	Mikko
Re: When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior it actually sees then it is correct	Richard Damon
Re: When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior it actually sees then it is correct	olcott
Re: When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior it actually sees then it is correct	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --l	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --a	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Mikko
H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --w	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --O	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --O	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --w	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --w	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --O	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --O	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --O	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Mikko
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Mikko
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Mikko
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Mikko
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Mikko
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Mikko
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Mikko
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --n	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --a	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	Richard Damon
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	immibis
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior	olcott

Pages:1 2 345 6 7 8 9 10 11 12 13

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior

<uslfhj$379j3$2@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55201&group=comp.theory#55201

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior
Date: Sun, 10 Mar 2024 18:25:39 -0500
Organization: A noiseless patient Spider
Lines: 135
Message-ID: <uslfhj$379j3$2@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usksng$33a1p$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 23:25:40 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3384931"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+6cQGixxiyE/n6ixxns6yr"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:kkheRwgo0NVr0ehPnuVrMJ7ovDU=
In-Reply-To: <usksng$33a1p$1@dont-email.me>
Content-Language: en-US

by: olcott - Sun, 10 Mar 2024 23:25 UTC

On 3/10/2024 1:04 PM, immibis wrote:
> On 10/03/24 05:30, olcott wrote:
>> On 3/9/2024 7:40 PM, immibis wrote:
>>> On 10/03/24 02:37, olcott wrote:
>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>>>>>>>> must abort every simulation that cannot possibly otherwise
>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does
>>>>>>>>>>>>>> not
>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>> aborts
>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use
>>>>>>>>>>> the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>
>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Objective criteria cannot vary based on who the subject is.
>>>>>>>>> They are objective. The answer to different people is the same
>>>>>>>>> answer if the criteria are objective.
>>>>>>>>
>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>> out of params.
>>>>>>>>
>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>> out of params.
>>>>>>>>
>>>>>>>
>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey
>>>>>>> could do better. Write the Olcott machine (not x86utm) code for Ĥ
>>>>>>> and I would show you.
>>>>>>
>>>>>> *In other words you are denying these verified facts*
>>>>>> *In other words you are denying these verified facts*
>>>>>> *In other words you are denying these verified facts*
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>
>>>>> That's not a verified fact, that's just something you want to be true.
>>>>>
>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see how
>>>>> stupid it is, to say that an infinite loop halts?
>>>>>
>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>
>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>>>>> IDENTICAL TO STEPS B AND C:
>>>>> > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>> to ⟨Ĥ⟩
>>>>> > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>
>>>>
>>>> *Yes and the key step of copying its input is left out so*
>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of params*
>>>>
>>>
>>> that isn't how any of this works. Do you even know what words mean?
>>
>> (b) and (c) are not the same as (1) and (2)
>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (2) which begins at simulated ⟨Ĥ.q0⟩
>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>>
>
> Because H and Ĥ.H ARE STIPULATED TO HAVE PRECISELY THE SAME BEHAVIOUR
> WITH ABSOLUTELY NO EXCEPTIONS, they see the same number of execution
> traces before they naturally halt.
>

When Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ are directly executed yes.

When H ⟨Ĥ⟩ ⟨Ĥ⟩ is simulating its input it sees one more
execution trace than its simulated Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ sees.

> The fact that H aborts its simulation before the point where simulated
> Ĥ.H would have aborted its simulation does not mean that simulated Ĥ.H
> would not have aborted its simulation.
Yes.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior

<AFrHN.465948$c3Ea.143163@fx10.iad>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55202&group=comp.theory#55202

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!diablo1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx10.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior
Content-Language: en-US
Newsgroups: comp.theory,sci.logic
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usksng$33a1p$1@dont-email.me>
<uslfhj$379j3$2@dont-email.me>
From: Richard@Damon-Family.org (Richard Damon)
In-Reply-To: <uslfhj$379j3$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 154
Message-ID: <AFrHN.465948$c3Ea.143163@fx10.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 10 Mar 2024 16:48:47 -0700
X-Received-Bytes: 8474

by: Richard Damon - Sun, 10 Mar 2024 23:48 UTC

On 3/10/24 4:25 PM, olcott wrote:
> On 3/10/2024 1:04 PM, immibis wrote:
>> On 10/03/24 05:30, olcott wrote:
>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>> On 10/03/24 02:37, olcott wrote:
>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and
>>>>>>>>>>>>>>> does not
>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>> ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation
>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to
>>>>>>>>>>>> use the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>
>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Objective criteria cannot vary based on who the subject is.
>>>>>>>>>> They are objective. The answer to different people is the same
>>>>>>>>>> answer if the criteria are objective.
>>>>>>>>>
>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>> out of params.
>>>>>>>>>
>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>> out of params.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey
>>>>>>>> could do better. Write the Olcott machine (not x86utm) code for
>>>>>>>> Ĥ and I would show you.
>>>>>>>
>>>>>>> *In other words you are denying these verified facts*
>>>>>>> *In other words you are denying these verified facts*
>>>>>>> *In other words you are denying these verified facts*
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>
>>>>>> That's not a verified fact, that's just something you want to be
>>>>>> true.
>>>>>>
>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see how
>>>>>> stupid it is, to say that an infinite loop halts?
>>>>>>
>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to
>>>>>>> ⟨Ĥ⟩
>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>
>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>>>>>> IDENTICAL TO STEPS B AND C:
>>>>>> > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>> to ⟨Ĥ⟩
>>>>>> > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>
>>>>>
>>>>> *Yes and the key step of copying its input is left out so*
>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of
>>>>> params*
>>>>>
>>>>
>>>> that isn't how any of this works. Do you even know what words mean?
>>>
>>> (b) and (c) are not the same as (1) and (2)
>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>
>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>>>
>>
>> Because H and Ĥ.H ARE STIPULATED TO HAVE PRECISELY THE SAME BEHAVIOUR
>> WITH ABSOLUTELY NO EXCEPTIONS, they see the same number of execution
>> traces before they naturally halt.
>>
>
> When Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ are directly executed yes.
>
> When H ⟨Ĥ⟩ ⟨Ĥ⟩ is simulating its input it sees one more
> execution trace than its simulated Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ sees.

But the BEHAVIOR of that simulated H^.H, as far as the answer to the
Halting question continues after H aborts its simulation. H doesn't get
to know what happens after, but its answer (to be correct) needs to
align with that behavior.

Click here to read the complete article

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior --RASP Machines--

<usljen$385ff$1@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55203&group=comp.theory#55203

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_--RASP_Machines--
Date: Sun, 10 Mar 2024 19:32:22 -0500
Organization: A noiseless patient Spider
Lines: 71
Message-ID: <usljen$385ff$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0u7$34bnj$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 00:32:23 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3413487"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19gWKXEtkSm8SkfIjLp680F"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:9xnCqS23GMl/fXmATMI6K+vK15Y=
Content-Language: en-US
In-Reply-To: <usl0u7$34bnj$1@dont-email.me>

by: olcott - Mon, 11 Mar 2024 00:32 UTC

On 3/10/2024 2:16 PM, immibis wrote:
> On 10/03/24 19:32, olcott wrote:
>> On 3/10/2024 1:08 PM, immibis wrote:
>>> On 10/03/24 18:17, olcott wrote:
>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>
>>> So you are saying that some Turing machines are not sound?
>>>
>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>> (a) Their input halts H.qy
>>>>>> (b) Their input fails to halt or has a pathological
>>>>>> relationship to itself H.qn.
>>>>>
>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>
>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>> expressly disallowing the "Pathological Relationship".
>>>
>>> So you are saying that some Turing machines are not real Turing
>>> machines?
>>>
>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>> when their input halts and correctly say NOT YES otherwise.
>>>
>>> well the halting problem requires them to correctly say NO, so you
>>> haven't solved it
>>
>> All decision problem instances of program/input such that both
>> yes and no are the wrong answer toss out the input as invalid.
>
> I noticed that you gave up on Olcott machines and now you are back to
> your old bullshit ways of pretending that the same machine can produce
> two different execution traces on the same input. Why don't you show us
> an execution trace where that happens? Both traces must show the first
> instruction that is different in both traces and I recommend showing 20
> more instructions after that, but you can abort one after that time, if
> it doesn't halt, to prevent the trace getting infinitely long.

Turing Machines and Olcott machines cannot properly implement
H1(D,D) and H(D,D) that know their own machine address.

My C code proves these two have different behavior:
(a) H1(D,D) + H1_machine_address
(b) H(D,D) + H_machine_address

Because they are different computations they are
not required to have the same behavior.

H(D,D) immediately sees the first time it calls itself
with its same inputs.

H1(D,D) never sees it call itself with its same inputs.

Full Execution trace of H1(D,D)
(a) main() invokes H1(D,D)
(b) H1(D,D) simulates D(D)
(c) Simulated D(D) calls simulated H(D,D)
(d) Simulated H(D,D) simulates another D(D)
(e) Simulated H(D,D) aborts this D(D) when it would call itself
(f) Simulated H(D,D) returns 0 to simulated caller D(D)
(g) Simulated caller D(D) returns to H1(D,D)
(h) H1(D,D) returns 1 to main()

They cannot be implemented as Turing Machines or Olcott
Machines. They can be implemented as RASP machines proven
by the fact that they are implemented as C functions.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usljs9$385q4$1@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55204&group=comp.theory#55204

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: news@immibis.com (immibis)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Mon, 11 Mar 2024 01:39:36 +0100
Organization: A noiseless patient Spider
Lines: 32
Message-ID: <usljs9$385q4$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskssi$33a1p$4@dont-email.me>
<usku6m$33lov$2@dont-email.me> <usl0gn$34290$2@dont-email.me>
<usl0tc$347rv$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 00:39:37 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="e447273e1bf9f0711b0b7fc4d6f15609";
logging-data="3413828"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/9DJTWNdAgIKllOTWfGo2C"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:f9O+wKsw/UhZvVyLGXjgV/WzxV8=
In-Reply-To: <usl0tc$347rv$1@dont-email.me>
Content-Language: en-US

by: immibis - Mon, 11 Mar 2024 00:39 UTC

On 10/03/24 20:15, olcott wrote:
> On 3/10/2024 2:09 PM, immibis wrote:
>> On 10/03/24 19:29, olcott wrote:
>>> On 3/10/2024 1:07 PM, immibis wrote:
>>>> On 10/03/24 17:52, olcott wrote:
>>>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>>>>> simulation to prevent their own infinite execution.
>>>>
>>>> Wrong, they incorrectly determine this because they determine this
>>>> even though it is not true.
>>>
>>> *Here is proof that what you said is counterfactual*
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>
>>> *Since I proved that you are wrong about many times you must be a Troll*
>>> *Since I proved that you are wrong about many times you must be a Troll*
>>> *Since I proved that you are wrong about many times you must be a Troll*
>>>
>>
>> where is the proof? I see a bunch of bullshit, but no proof.
>
> The part that you erased Troll!!!
>

I quoted the whole message, troll.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usljui$385q4$2@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55205&group=comp.theory#55205

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: news@immibis.com (immibis)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Mon, 11 Mar 2024 01:40:50 +0100
Organization: A noiseless patient Spider
Lines: 44
Message-ID: <usljui$385q4$2@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0hh$34290$3@dont-email.me>
<usl0v5$347rv$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 00:40:50 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="e447273e1bf9f0711b0b7fc4d6f15609";
logging-data="3413828"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/0pa7oCdbncsn+A41tg9AP"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:89FL3bcTgB6QTIIrwX7SF3/+W6E=
In-Reply-To: <usl0v5$347rv$2@dont-email.me>
Content-Language: en-US

by: immibis - Mon, 11 Mar 2024 00:40 UTC

On 10/03/24 20:16, olcott wrote:
> On 3/10/2024 2:09 PM, immibis wrote:
>> On 10/03/24 19:32, olcott wrote:
>>> On 3/10/2024 1:08 PM, immibis wrote:
>>>> On 10/03/24 18:17, olcott wrote:
>>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>>
>>>> So you are saying that some Turing machines are not sound?
>>>>
>>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>>> (a) Their input halts H.qy
>>>>>>> (b) Their input fails to halt or has a pathological
>>>>>>> relationship to itself H.qn.
>>>>>>
>>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>>
>>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>>> expressly disallowing the "Pathological Relationship".
>>>>
>>>> So you are saying that some Turing machines are not real Turing
>>>> machines?
>>>>
>>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>>> when their input halts and correctly say NOT YES otherwise.
>>>>
>>>> well the halting problem requires them to correctly say NO, so you
>>>> haven't solved it
>>>
>>> All decision problem instances of program/input such that both
>>> yes and no are the wrong answer toss out the input as invalid.
>>>
>>
>> all decision problems are defined so that all instances are valid or
>> else they are not defined properly
>>
>
> Not in the case of Russell's Paradox.

And now we are back to: Every Turing machine and input pair defines an
execution sequence. Every sequence is either finite or infinite.
Therefore it is well-defined and there is no paradox.

Can you show me a Turing machine that specifies a sequence of
configurations that is not finite or infinite?

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior

<uslk4f$385q4$4@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55207&group=comp.theory#55207

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: news@immibis.com (immibis)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior
Date: Mon, 11 Mar 2024 01:43:59 +0100
Organization: A noiseless patient Spider
Lines: 25
Message-ID: <uslk4f$385q4$4@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usksng$33a1p$1@dont-email.me>
<uslfhj$379j3$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 00:44:00 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="e447273e1bf9f0711b0b7fc4d6f15609";
logging-data="3413828"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19gUPHHJjIU+EKRVlqRjucz"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:BuA55eRh/RMNXoBWzT0GA8Y5cNo=
Content-Language: en-US
In-Reply-To: <uslfhj$379j3$2@dont-email.me>

by: immibis - Mon, 11 Mar 2024 00:43 UTC

On 11/03/24 00:25, olcott wrote:
> On 3/10/2024 1:04 PM, immibis wrote:
>>
>> Because H and Ĥ.H ARE STIPULATED TO HAVE PRECISELY THE SAME BEHAVIOUR
>> WITH ABSOLUTELY NO EXCEPTIONS, they see the same number of execution
>> traces before they naturally halt.
>>
>
> When Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ are directly executed yes.
>
> When H ⟨Ĥ⟩ ⟨Ĥ⟩ is simulating its input it sees one more
> execution trace than its simulated Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ sees.

This causes H ⟨Ĥ⟩ ⟨Ĥ⟩ to transition to state qn which is an incorrect
solution to the halting problem because the direct execution of Ĥ ⟨Ĥ⟩
halts. We've been over this. The problem is to tell what the direct
execution does, not what an incorrect simulation does.

>
>> The fact that H aborts its simulation before the point where simulated
>> Ĥ.H would have aborted its simulation does not mean that simulated Ĥ.H
>> would not have aborted its simulation.
> Yes.
>

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior --RASP Machines--

<uslk9j$385q4$5@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55208&group=comp.theory#55208

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: news@immibis.com (immibis)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_--RASP_Machines--
Date: Mon, 11 Mar 2024 01:46:43 +0100
Organization: A noiseless patient Spider
Lines: 41
Message-ID: <uslk9j$385q4$5@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0u7$34bnj$1@dont-email.me>
<usljen$385ff$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Mon, 11 Mar 2024 00:46:44 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="e447273e1bf9f0711b0b7fc4d6f15609";
logging-data="3413828"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18iTgEYnxi1KofKj/pIaQln"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:2opi65uXS6b5hZ2ywv3p//mvfJ4=
Content-Language: en-US
In-Reply-To: <usljen$385ff$1@dont-email.me>

by: immibis - Mon, 11 Mar 2024 00:46 UTC

On 11/03/24 01:32, olcott wrote:
> On 3/10/2024 2:16 PM, immibis wrote:
>>
>> I noticed that you gave up on Olcott machines and now you are back to
>> your old bullshit ways of pretending that the same machine can produce
>> two different execution traces on the same input. Why don't you show
>> us an execution trace where that happens? Both traces must show the
>> first instruction that is different in both traces and I recommend
>> showing 20 more instructions after that, but you can abort one after
>> that time, if it doesn't halt, to prevent the trace getting infinitely
>> long.
>
> Turing Machines and Olcott machines cannot properly implement
> H1(D,D) and H(D,D) that know their own machine address.

"Know their own machine address" isn't an objective specification and it
has nothing to do with the halting problem anyway. Turing machines don't
have machine addresses and Olcott machines don't have machine addresses
either.

> My C code proves these two have different behavior:
> (a) H1(D,D) + H1_machine_address
> (b) H(D,D) + H_machine_address

Of course.

> Because they are different computations they are
> not required to have the same behavior.

Of course. One of them even answers the halting problem correctly in
this case. But that's because this case isn't the Linz counterexample
for H1. If you built the Linz counterexample for H1, which is D1, you'd
find that H1 gets it wrong, so H1 doesn't solve the halting problem.

> They cannot be implemented as Turing Machines or Olcott
> Machines. They can be implemented as RASP machines proven
> by the fact that they are implemented as C functions.

They can be implemented as Turing machines. Each one is different from
the other. They are not the same.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --attribution--

<usll3l$38f21$1@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55209&group=comp.theory#55209

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC_--attribution--
Date: Sun, 10 Mar 2024 20:00:36 -0500
Organization: A noiseless patient Spider
Lines: 271
Message-ID: <usll3l$38f21$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usks70$1enef$1@i2pn2.org>
<usktro$33lov$1@dont-email.me> <usl1c7$1enef$9@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 01:00:37 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3423297"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/8g2Pu7YhToVwGhdVh78DE"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:QbxwYZaBqST/Tj8is8k1f6gTjik=
In-Reply-To: <usl1c7$1enef$9@i2pn2.org>
Content-Language: en-US

by: olcott - Mon, 11 Mar 2024 01:00 UTC

On 3/10/2024 2:23 PM, Richard Damon wrote:
> On 3/10/24 11:23 AM, olcott wrote:
>> On 3/10/2024 12:55 PM, Richard Damon wrote:
>>> On 3/10/24 10:17 AM, olcott wrote:
>>>> On 3/10/2024 12:08 PM, Richard Damon wrote:
>>>>> On 3/10/24 9:52 AM, olcott wrote:
>>>>>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>>>>>> On 3/10/24 7:28 AM, olcott wrote:
>>>>>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
>>>>>>>>>>>>>>>>>>>>>>>>>>> same objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that
>>>>>>>>>>>>>>>>>>>>>>>>>> they themselves
>>>>>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This
>>>>>>>>>>>>>>>>>>>>>>>>>> means that they
>>>>>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>> possibly otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and does not
>>>>>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is
>>>>>>>>>>>>>>>>>>>>>>>> not*
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE
>>>>>>>>>>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The above is true no matter what criteria that is
>>>>>>>>>>>>>>>>>>>>>> used
>>>>>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the
>>>>>>>>>>>>>>>>>>>>> subject is. They are objective. The answer to
>>>>>>>>>>>>>>>>>>>>> different people is the same answer if the criteria
>>>>>>>>>>>>>>>>>>>>> are objective.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in
>>>>>>>>>>>>>>>>>>>> recursive
>>>>>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>>>>>>>>>>> in recursive because H does not copy its input thus
>>>>>>>>>>>>>>>>>>>> runs
>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a
>>>>>>>>>>>>>>>>>>> dead monkey could do better. Write the Olcott machine
>>>>>>>>>>>>>>>>>>> (not x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ halts
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ does not halt
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That's not a verified fact, that's just something you
>>>>>>>>>>>>>>>>> want to be true.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You
>>>>>>>>>>>>>>>>> see how stupid it is, to say that an infinite loop halts?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>>>>>>> the process
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>>>>> > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs
>>>>>>>>>>>>>>>> out of params*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> that isn't how any of this works. Do you even know what
>>>>>>>>>>>>>>> words mean?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>>>>> process
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more
>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>> ⟨Ĥ⟩ can see.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>>>>>
>>>>>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>>>>>> The algorithm of H begins a simulation of its input,
>>>>>>>>>>>>> watching the behaior of H^ (H^)
>>>>>>>>>>>>>
>>>>>>>>>>>>> (c) = (2)
>>>>>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>>>>>
>>>>>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>>>>>
>>>>>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation
>>>>>>>>>>>>> of its input ...
>>>>>>>>>>>>>
>>>>>>>>>>>>> and so on.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, the top level H is farther along at any given time
>>>>>>>>>>>>> then its simulated machine, and that is H's problem, it has
>>>>>>>>>>>>> to act before it sees how its simulation will respond to
>>>>>>>>>>>>> its copy of its actions.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus, if it stops, it needs to make its decision "blind"
>>>>>>>>>>>>> and not with an idea of how the machine it is simulating
>>>>>>>>>>>>> will perform.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it doesn't stop, the level of recursion just keeps
>>>>>>>>>>>>> growing and no answer ever comes out.
>>>>>>>>>>>>
>>>>>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>>>>>>>> its simulation. Right before its cycle repeats the first time.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So?
>>>>>>>>>>>
>>>>>>>>>>> If it DOES abort there, then so will H^.H when it gets to
>>>>>>>>>>> that point in its simulation, which will be AFTER The point
>>>>>>>>>>> that H has stopped simulating it, so H doesn't know what H^
>>>>>>>>>>> will do.
>>>>>>>>>>>
>>>>>>>>>>> Thus, if H DOES abort there, we presume from your previous
>>>>>>>>>>> answer it will think the input will not halt and answer qn.
>>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>>> not halt
>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>> And if it does, as I said below, so will H^.H when it is run.
>>>>>>>>
>>>>>>>> Yes.
>>>>>>>
>>>>>>> And thus, H^.H will give the same answer as H,
>>>>>>> so H^ will act contrary to what H says,
>>>>>>> so H will give the wrong answer.
>>>>>>
>>>>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>>>>>> simulation to prevent their own infinite execution.
>>>>>
>>>>> NOPE.
>>>>
>>>> If no source can be cited then the Olcott thesis
>>>> "that no one did this before" remains unrefuted.
>>>
>>> Since, BY THE DEFINITIONS of what H MUST do to be correct, and what
>>> H^ WILL do by its design, as shown in the Linz Proof.
>>
>> If no source can be cited that shows a simulating halt decider can
>> correctly determine that it must abort its simulation of the Halting
>> Problem's pathological input to prevent its own non-termination, then
>> innovation remains attributable to me.
>>
>> <snip>
>
> Of course it can abort its simulation.
>
> It just needs some way to get the right answer.
>

Click here to read the complete article

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior --RASP Machines--

<usllu9$38jtu$1@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55210&group=comp.theory#55210

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_--RASP_Machines--
Date: Sun, 10 Mar 2024 20:14:48 -0500
Organization: A noiseless patient Spider
Lines: 61
Message-ID: <usllu9$38jtu$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0u7$34bnj$1@dont-email.me>
<usljen$385ff$1@dont-email.me> <uslk9j$385q4$5@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 01:14:49 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3428286"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18yzuF8QAGRZ6LQuYHpGxuW"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:ZTj7xt2OTf6YmtJ9rc5ZQmFTfYA=
In-Reply-To: <uslk9j$385q4$5@dont-email.me>
Content-Language: en-US

by: olcott - Mon, 11 Mar 2024 01:14 UTC

On 3/10/2024 7:46 PM, immibis wrote:
> On 11/03/24 01:32, olcott wrote:
>> On 3/10/2024 2:16 PM, immibis wrote:
>>>
>>> I noticed that you gave up on Olcott machines and now you are back to
>>> your old bullshit ways of pretending that the same machine can
>>> produce two different execution traces on the same input. Why don't
>>> you show us an execution trace where that happens? Both traces must
>>> show the first instruction that is different in both traces and I
>>> recommend showing 20 more instructions after that, but you can abort
>>> one after that time, if it doesn't halt, to prevent the trace getting
>>> infinitely long.
>>
>> Turing Machines and Olcott machines cannot properly implement
>> H1(D,D) and H(D,D) that know their own machine address.
>
> "Know their own machine address" isn't an objective specification and it
> has nothing to do with the halting problem anyway. Turing machines don't
> have machine addresses and Olcott machines don't have machine addresses
> either.
>
>> My C code proves these two have different behavior:
>> (a) H1(D,D) + H1_machine_address
>> (b) H(D,D) + H_machine_address
>
> Of course.
>
>> Because they are different computations they are
>> not required to have the same behavior.
>
> Of course. One of them even answers the halting problem correctly in
> this case. But that's because this case isn't the Linz counterexample
> for H1. If you built the Linz counterexample for H1, which is D1, you'd
> find that H1 gets it wrong, so H1 doesn't solve the halting problem.

I am taking H1(D,D) to be Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ and H(D,D) to be Linz H ⟨Ĥ⟩.
Since we are using machine addresses there is no need for copies.
This simplifies Linz Ĥ down to this.

Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

H/D does contradict itself like simplified Linz Ĥ and
H1(D,D) does not contradict itself like Linz H ⟨Ĥ⟩ ⟨Ĥ⟩.

>> They cannot be implemented as Turing Machines or Olcott
>> Machines. They can be implemented as RASP machines proven
>> by the fact that they are implemented as C functions.
>
> They can be implemented as Turing machines. Each one is different from
> the other. They are not the same.
>

Turing machines and Olcott machines cannot know their own machine
address in a way that cannot be circumvented. X86 virtual machines
and thus (possibly augmented) RASP machines can.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<uslmh7$38jtu$2@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55211&group=comp.theory#55211

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 20:24:55 -0500
Organization: A noiseless patient Spider
Lines: 56
Message-ID: <uslmh7$38jtu$2@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0hh$34290$3@dont-email.me>
<usl0v5$347rv$2@dont-email.me> <usljui$385q4$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 01:24:55 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3428286"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19+SBL2/zAziE9hByDJcvyQ"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:ABDhRGqBsjEReFzMO57Vtc21yGU=
Content-Language: en-US
In-Reply-To: <usljui$385q4$2@dont-email.me>

by: olcott - Mon, 11 Mar 2024 01:24 UTC

On 3/10/2024 7:40 PM, immibis wrote:
> On 10/03/24 20:16, olcott wrote:
>> On 3/10/2024 2:09 PM, immibis wrote:
>>> On 10/03/24 19:32, olcott wrote:
>>>> On 3/10/2024 1:08 PM, immibis wrote:
>>>>> On 10/03/24 18:17, olcott wrote:
>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>>>
>>>>> So you are saying that some Turing machines are not sound?
>>>>>
>>>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>>>> (a) Their input halts H.qy
>>>>>>>> (b) Their input fails to halt or has a pathological
>>>>>>>> relationship to itself H.qn.
>>>>>>>
>>>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>>>
>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>>>> expressly disallowing the "Pathological Relationship".
>>>>>
>>>>> So you are saying that some Turing machines are not real Turing
>>>>> machines?
>>>>>
>>>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>>>> when their input halts and correctly say NOT YES otherwise.
>>>>>
>>>>> well the halting problem requires them to correctly say NO, so you
>>>>> haven't solved it
>>>>
>>>> All decision problem instances of program/input such that both
>>>> yes and no are the wrong answer toss out the input as invalid.
>>>>
>>>
>>> all decision problems are defined so that all instances are valid or
>>> else they are not defined properly
>>>
>>
>> Not in the case of Russell's Paradox.
>
> And now we are back to: Every Turing machine and input pair defines an
> execution sequence. Every sequence is either finite or infinite.
> Therefore it is well-defined and there is no paradox.
>
> Can you show me a Turing machine that specifies a sequence of
> configurations that is not finite or infinite?

When we construe every yes/no question that cannot possibly
have a correct yes/no answer as an incorrect question

then we must correspondingly construe every decider/input
pair that has no correct yes/no answer as invalid input.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --attribution--

<lttHN.366350$q3F7.85039@fx45.iad>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55212&group=comp.theory#55212

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!news.neodome.net!npeer.as286.net!npeer-ng0.as286.net!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC_--attribution--
Content-Language: en-US
Newsgroups: comp.theory,sci.logic
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usks70$1enef$1@i2pn2.org>
<usktro$33lov$1@dont-email.me> <usl1c7$1enef$9@i2pn2.org>
<usll3l$38f21$1@dont-email.me>
From: Richard@Damon-Family.org (Richard Damon)
In-Reply-To: <usll3l$38f21$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 290
Message-ID: <lttHN.366350$q3F7.85039@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 10 Mar 2024 18:52:16 -0700
X-Received-Bytes: 16015

by: Richard Damon - Mon, 11 Mar 2024 01:52 UTC

On 3/10/24 6:00 PM, olcott wrote:
> On 3/10/2024 2:23 PM, Richard Damon wrote:
>> On 3/10/24 11:23 AM, olcott wrote:
>>> On 3/10/2024 12:55 PM, Richard Damon wrote:
>>>> On 3/10/24 10:17 AM, olcott wrote:
>>>>> On 3/10/2024 12:08 PM, Richard Damon wrote:
>>>>>> On 3/10/24 9:52 AM, olcott wrote:
>>>>>>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>>>>>>> On 3/10/24 7:28 AM, olcott wrote:
>>>>>>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>>>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
>>>>>>>>>>>>>>>>>>>>>>>>>>>> same objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that
>>>>>>>>>>>>>>>>>>>>>>>>>>> they themselves
>>>>>>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This
>>>>>>>>>>>>>>>>>>>>>>>>>>> means that they
>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and does not
>>>>>>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
>>>>>>>>>>>>>>>>>>>>>>>>>> same objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is
>>>>>>>>>>>>>>>>>>>>>>>>> not*
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in
>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE
>>>>>>>>>>>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The above is true no matter what criteria that is
>>>>>>>>>>>>>>>>>>>>>>> used
>>>>>>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the
>>>>>>>>>>>>>>>>>>>>>> subject is. They are objective. The answer to
>>>>>>>>>>>>>>>>>>>>>> different people is the same answer if the
>>>>>>>>>>>>>>>>>>>>>> criteria are objective.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in
>>>>>>>>>>>>>>>>>>>>> recursive
>>>>>>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get
>>>>>>>>>>>>>>>>>>>>> stuck
>>>>>>>>>>>>>>>>>>>>> in recursive because H does not copy its input thus
>>>>>>>>>>>>>>>>>>>>> runs
>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a
>>>>>>>>>>>>>>>>>>>> dead monkey could do better. Write the Olcott
>>>>>>>>>>>>>>>>>>>> machine (not x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ halts
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ does not halt
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That's not a verified fact, that's just something you
>>>>>>>>>>>>>>>>>> want to be true.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You
>>>>>>>>>>>>>>>>>> see how stupid it is, to say that an infinite loop halts?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>>>>>> > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>>>>>>>> runs out of params*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> that isn't how any of this works. Do you even know what
>>>>>>>>>>>>>>>> words mean?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>>>> the process
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more
>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>> ⟨Ĥ⟩ can see.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>>>>>>> The algorithm of H begins a simulation of its input,
>>>>>>>>>>>>>> watching the behaior of H^ (H^)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (c) = (2)
>>>>>>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation
>>>>>>>>>>>>>> of its input ...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> and so on.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, the top level H is farther along at any given time
>>>>>>>>>>>>>> then its simulated machine, and that is H's problem, it
>>>>>>>>>>>>>> has to act before it sees how its simulation will respond
>>>>>>>>>>>>>> to its copy of its actions.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus, if it stops, it needs to make its decision "blind"
>>>>>>>>>>>>>> and not with an idea of how the machine it is simulating
>>>>>>>>>>>>>> will perform.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If it doesn't stop, the level of recursion just keeps
>>>>>>>>>>>>>> growing and no answer ever comes out.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>>>>>>>>> its simulation. Right before its cycle repeats the first time.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So?
>>>>>>>>>>>>
>>>>>>>>>>>> If it DOES abort there, then so will H^.H when it gets to
>>>>>>>>>>>> that point in its simulation, which will be AFTER The point
>>>>>>>>>>>> that H has stopped simulating it, so H doesn't know what H^
>>>>>>>>>>>> will do.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus, if H DOES abort there, we presume from your previous
>>>>>>>>>>>> answer it will think the input will not halt and answer qn.
>>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>>>> not halt
>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>> And if it does, as I said below, so will H^.H when it is run.
>>>>>>>>>
>>>>>>>>> Yes.
>>>>>>>>
>>>>>>>> And thus, H^.H will give the same answer as H,
>>>>>>>> so H^ will act contrary to what H says,
>>>>>>>> so H will give the wrong answer.
>>>>>>>
>>>>>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>>>>>>> simulation to prevent their own infinite execution.
>>>>>>
>>>>>> NOPE.
>>>>>
>>>>> If no source can be cited then the Olcott thesis
>>>>> "that no one did this before" remains unrefuted.
>>>>
>>>> Since, BY THE DEFINITIONS of what H MUST do to be correct, and what
>>>> H^ WILL do by its design, as shown in the Linz Proof.
>>>
>>> If no source can be cited that shows a simulating halt decider can
>>> correctly determine that it must abort its simulation of the Halting
>>> Problem's pathological input to prevent its own non-termination, then
>>> innovation remains attributable to me.
>>>
>>> <snip>
>>
>> Of course it can abort its simulation.
>>
>> It just needs some way to get the right answer.
>>
>
> *I have always been using this long before I read about it*
> blind variation and selective retention (BVSR)...
> Two common phenomena characterize BVSR thinking: superfluity and
> backtracking. Superfluity means that the creator generates a variety of
> ideas, one or more of which turn out to be useless.

Click here to read the complete article

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<IEtHN.366351$q3F7.176464@fx45.iad>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55213&group=comp.theory#55213

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!npeer.as286.net!npeer-ng0.as286.net!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Content-Language: en-US
Newsgroups: comp.theory,sci.logic
References: <usia2e$2f2pd$1@dont-email.me> <usikk8$2gnhr$8@dont-email.me>
<usiljd$2hc10$3@dont-email.me> <usineq$2hnpb$3@dont-email.me>
<usiq9n$2ijsm$1@dont-email.me> <usir82$2inqh$2@dont-email.me>
<usit21$2j3c8$1@dont-email.me> <usiufa$2j99n$1@dont-email.me>
<usiukh$2jaj3$1@dont-email.me> <usiuup$2jdc7$2@dont-email.me>
<usj254$2jutc$2@dont-email.me> <usj2e3$2jut2$1@dont-email.me>
<usj2je$2jutc$3@dont-email.me> <usj2rs$2jut2$2@dont-email.me>
<usj32s$2k5id$1@dont-email.me> <usjd20$2plge$1@dont-email.me>
<usjef5$1cf5q$6@i2pn2.org> <usjfj8$2q613$1@dont-email.me>
<usjgs6$1cf5q$7@i2pn2.org> <usjhks$2qhfq$1@dont-email.me>
<usjj7v$1cf5q$8@i2pn2.org> <uskg1p$30hr1$1@dont-email.me>
<KEkHN.386271$vFZa.185803@fx13.iad> <uskog1$32h3c$1@dont-email.me>
<uskpe3$32l00$1@dont-email.me> <uskq04$32h3c$3@dont-email.me>
<usksvk$33a1p$5@dont-email.me> <uskubp$33lov$3@dont-email.me>
<usl0hh$34290$3@dont-email.me> <usl0v5$347rv$2@dont-email.me>
<usljui$385q4$2@dont-email.me> <uslmh7$38jtu$2@dont-email.me>
From: Richard@Damon-Family.org (Richard Damon)
In-Reply-To: <uslmh7$38jtu$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 81
Message-ID: <IEtHN.366351$q3F7.176464@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 10 Mar 2024 19:04:23 -0700
X-Received-Bytes: 5568

by: Richard Damon - Mon, 11 Mar 2024 02:04 UTC

On 3/10/24 6:24 PM, olcott wrote:
> On 3/10/2024 7:40 PM, immibis wrote:
>> On 10/03/24 20:16, olcott wrote:
>>> On 3/10/2024 2:09 PM, immibis wrote:
>>>> On 10/03/24 19:32, olcott wrote:
>>>>> On 3/10/2024 1:08 PM, immibis wrote:
>>>>>> On 10/03/24 18:17, olcott wrote:
>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>>>>
>>>>>> So you are saying that some Turing machines are not sound?
>>>>>>
>>>>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>>>>> (a) Their input halts H.qy
>>>>>>>>> (b) Their input fails to halt or has a pathological
>>>>>>>>> relationship to itself H.qn.
>>>>>>>>
>>>>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>>>>
>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>>>>> expressly disallowing the "Pathological Relationship".
>>>>>>
>>>>>> So you are saying that some Turing machines are not real Turing
>>>>>> machines?
>>>>>>
>>>>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>>>>> when their input halts and correctly say NOT YES otherwise.
>>>>>>
>>>>>> well the halting problem requires them to correctly say NO, so you
>>>>>> haven't solved it
>>>>>
>>>>> All decision problem instances of program/input such that both
>>>>> yes and no are the wrong answer toss out the input as invalid.
>>>>>
>>>>
>>>> all decision problems are defined so that all instances are valid or
>>>> else they are not defined properly
>>>>
>>>
>>> Not in the case of Russell's Paradox.
>>
>> And now we are back to: Every Turing machine and input pair defines an
>> execution sequence. Every sequence is either finite or infinite.
>> Therefore it is well-defined and there is no paradox.
>>
>> Can you show me a Turing machine that specifies a sequence of
>> configurations that is not finite or infinite?
>
> When we construe every yes/no question that cannot possibly
> have a correct yes/no answer as an incorrect question
>
> then we must correspondingly construe every decider/input
> pair that has no correct yes/no answer as invalid input.
>

And when you remember that when we posse that ACTUAL question, the input
is a FIXED machine, (not a template that changes by the decide that it
trying to decide it) then there are a LOT of machines that get the right
answer. The key is we know that there is ONE that doesn't, the one that
particular decider was built to foil. Thus, the problem isn't an invalid
question.

The key is that we know we can make such an input for any (and thus
there is one for all of them) and thus every decider has an achilles
heel, so no decider gets all input correct. Which is not a surprizing case.

By your logic, EVERY decider, even if it gets only one input correct (or
possible even no inputs) is a correct decider, as a given decider can
only give one answer for a given input, the one that its program gives
(to give the other answer, it would be another decider), and thus ALL
inputs that it fails on are just "invalid inputs" since it couldn't gie
the right answer to it.

Remember, for a given instance, the input is fixed, so if you allow
yourself to change the decider, then it can get THIS input correct,
there just will be a different one it gets wrong.

You show this with H/H1, you can change H very slightly, and now it get
this input right, he input right. But now if you give this H1, an input
of H1^, then it will fail, but the origial H will get it right.

You just don't understand what you have been blabbering about.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --attribution--

<uslou1$390q2$1@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55214&group=comp.theory#55214

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC_--attribution--
Date: Sun, 10 Mar 2024 21:05:53 -0500
Organization: A noiseless patient Spider
Lines: 313
Message-ID: <uslou1$390q2$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usks70$1enef$1@i2pn2.org>
<usktro$33lov$1@dont-email.me> <usl1c7$1enef$9@i2pn2.org>
<usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 02:05:54 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3441474"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/zzUcHNRsYZBMX/HDJE9C+"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:Aam2lAk3ZuIS5cAOb9nrcVxB15k=
Content-Language: en-US
In-Reply-To: <lttHN.366350$q3F7.85039@fx45.iad>

by: olcott - Mon, 11 Mar 2024 02:05 UTC

On 3/10/2024 8:52 PM, Richard Damon wrote:
> On 3/10/24 6:00 PM, olcott wrote:
>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>> On 3/10/24 11:23 AM, olcott wrote:
>>>> On 3/10/2024 12:55 PM, Richard Damon wrote:
>>>>> On 3/10/24 10:17 AM, olcott wrote:
>>>>>> On 3/10/2024 12:08 PM, Richard Damon wrote:
>>>>>>> On 3/10/24 9:52 AM, olcott wrote:
>>>>>>>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>>>>>>>> On 3/10/24 7:28 AM, olcott wrote:
>>>>>>>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> they themselves
>>>>>>>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This
>>>>>>>>>>>>>>>>>>>>>>>>>>>> means that they
>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in
>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
>>>>>>>>>>>>>>>>>>>>>>>>>>> same objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H
>>>>>>>>>>>>>>>>>>>>>>>>>> is not*
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE
>>>>>>>>>>>>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The above is true no matter what criteria that
>>>>>>>>>>>>>>>>>>>>>>>> is used
>>>>>>>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the
>>>>>>>>>>>>>>>>>>>>>>> subject is. They are objective. The answer to
>>>>>>>>>>>>>>>>>>>>>>> different people is the same answer if the
>>>>>>>>>>>>>>>>>>>>>>> criteria are objective.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in
>>>>>>>>>>>>>>>>>>>>>> recursive
>>>>>>>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get
>>>>>>>>>>>>>>>>>>>>>> stuck
>>>>>>>>>>>>>>>>>>>>>> in recursive because H does not copy its input
>>>>>>>>>>>>>>>>>>>>>> thus runs
>>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a
>>>>>>>>>>>>>>>>>>>>> dead monkey could do better. Write the Olcott
>>>>>>>>>>>>>>>>>>>>> machine (not x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ halts
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ does not halt
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That's not a verified fact, that's just something you
>>>>>>>>>>>>>>>>>>> want to be true.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt.
>>>>>>>>>>>>>>>>>>> You see how stupid it is, to say that an infinite
>>>>>>>>>>>>>>>>>>> loop halts?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to
>>>>>>>>>>>>>>>>>>>> Ĥ.H
>>>>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>>>>>>> > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Yes and the key step of copying its input is left out
>>>>>>>>>>>>>>>>>> so*
>>>>>>>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>>>>>>>>> runs out of params*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> that isn't how any of this works. Do you even know what
>>>>>>>>>>>>>>>>> words mean?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>>>>> the process
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one
>>>>>>>>>>>>>>>> more execution
>>>>>>>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ can see.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>>>>>>>> The algorithm of H begins a simulation of its input,
>>>>>>>>>>>>>>> watching the behaior of H^ (H^)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (c) = (2)
>>>>>>>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the
>>>>>>>>>>>>>>> simulation of its input ...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> and so on.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, the top level H is farther along at any given time
>>>>>>>>>>>>>>> then its simulated machine, and that is H's problem, it
>>>>>>>>>>>>>>> has to act before it sees how its simulation will respond
>>>>>>>>>>>>>>> to its copy of its actions.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus, if it stops, it needs to make its decision "blind"
>>>>>>>>>>>>>>> and not with an idea of how the machine it is simulating
>>>>>>>>>>>>>>> will perform.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If it doesn't stop, the level of recursion just keeps
>>>>>>>>>>>>>>> growing and no answer ever comes out.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>>>>>>>>>> its simulation. Right before its cycle repeats the first
>>>>>>>>>>>>>> time.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So?
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it DOES abort there, then so will H^.H when it gets to
>>>>>>>>>>>>> that point in its simulation, which will be AFTER The point
>>>>>>>>>>>>> that H has stopped simulating it, so H doesn't know what H^
>>>>>>>>>>>>> will do.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus, if H DOES abort there, we presume from your previous
>>>>>>>>>>>>> answer it will think the input will not halt and answer qn.
>>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>> does not halt
>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>> And if it does, as I said below, so will H^.H when it is run.
>>>>>>>>>>
>>>>>>>>>> Yes.
>>>>>>>>>
>>>>>>>>> And thus, H^.H will give the same answer as H,
>>>>>>>>> so H^ will act contrary to what H says,
>>>>>>>>> so H will give the wrong answer.
>>>>>>>>
>>>>>>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>>>>>>>> simulation to prevent their own infinite execution.
>>>>>>>
>>>>>>> NOPE.
>>>>>>
>>>>>> If no source can be cited then the Olcott thesis
>>>>>> "that no one did this before" remains unrefuted.
>>>>>
>>>>> Since, BY THE DEFINITIONS of what H MUST do to be correct, and what
>>>>> H^ WILL do by its design, as shown in the Linz Proof.
>>>>
>>>> If no source can be cited that shows a simulating halt decider can
>>>> correctly determine that it must abort its simulation of the Halting
>>>> Problem's pathological input to prevent its own non-termination, then
>>>> innovation remains attributable to me.
>>>>
>>>> <snip>
>>>
>>> Of course it can abort its simulation.
>>>
>>> It just needs some way to get the right answer.
>>>
>>
>> *I have always been using this long before I read about it*
>> blind variation and selective retention (BVSR)...
>> Two common phenomena characterize BVSR thinking: superfluity and
>> backtracking. Superfluity means that the creator generates a variety
>> of ideas, one or more of which turn out to be useless.
>
> But if you have mo idea how things actually works, this seems to just
> generate random noise.
>
>>
>> Backtracking signifies that the creator must often return to an
>> earlier approach after blindly going off in the wrong direction.
>> https://www.scientificamerican.com/article/the-science-of-genius/
>>
>> *I am aware of no one else that had the idea to apply a simulating*
>> *termination analyzer to the halting problem counter-example input*
>> Professor Hehner had a seed of this idea before I did.
>
> Nope, I remember talk of that when I was in college, and they showed why
> it can't work.
>
>>
>> From a programmer's point of view, if we apply an interpreter to a
>> program text that includes a call to that same interpreter with that
>> same text as argument, then we have an infinite loop. A halting program
>> has some of the same character as an interpreter: it applies to texts
>> through abstract interpretation. Unsurprisingly, if we apply a halting
>> program to a program text that includes a call to that same halting
>> program with that same text as argument, then we have an infinite
>> loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>
> You THINK so, but if the interpreter is a CONDITIONAL interpreter, that
> doesn't hold.
>
> You seem to miss that fact.
>
>>
>> *Turing Machine and Olcott machine implementations seem to be dead*
>> *This the (possibly augmented) RASP machine equivalent of x86*
>> Every machine must be able to get its own machine address.
>>
>
> And the reason it is a dead end is they make it too hard for you to cheat.
>
> You need to hide that your H is trying to get in some extra information
> to hide that the embedded version of H doesn't give the same answer,
> which just shows that your H^ is built wrong.

Click here to read the complete article

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior --RASP Machines--

<hItHN.366352$q3F7.153154@fx45.iad>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55215&group=comp.theory#55215

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!diablo1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_--RASP_Machines--
Content-Language: en-US
Newsgroups: comp.theory,sci.logic
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0u7$34bnj$1@dont-email.me>
<usljen$385ff$1@dont-email.me>
From: Richard@Damon-Family.org (Richard Damon)
In-Reply-To: <usljen$385ff$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 82
Message-ID: <hItHN.366352$q3F7.153154@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 10 Mar 2024 19:08:12 -0700
X-Received-Bytes: 5206

by: Richard Damon - Mon, 11 Mar 2024 02:08 UTC

On 3/10/24 5:32 PM, olcott wrote:
> On 3/10/2024 2:16 PM, immibis wrote:
>> On 10/03/24 19:32, olcott wrote:
>>> On 3/10/2024 1:08 PM, immibis wrote:
>>>> On 10/03/24 18:17, olcott wrote:
>>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>>
>>>> So you are saying that some Turing machines are not sound?
>>>>
>>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>>> (a) Their input halts H.qy
>>>>>>> (b) Their input fails to halt or has a pathological
>>>>>>> relationship to itself H.qn.
>>>>>>
>>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>>
>>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>>> expressly disallowing the "Pathological Relationship".
>>>>
>>>> So you are saying that some Turing machines are not real Turing
>>>> machines?
>>>>
>>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>>> when their input halts and correctly say NOT YES otherwise.
>>>>
>>>> well the halting problem requires them to correctly say NO, so you
>>>> haven't solved it
>>>
>>> All decision problem instances of program/input such that both
>>> yes and no are the wrong answer toss out the input as invalid.
>>
>> I noticed that you gave up on Olcott machines and now you are back to
>> your old bullshit ways of pretending that the same machine can produce
>> two different execution traces on the same input. Why don't you show
>> us an execution trace where that happens? Both traces must show the
>> first instruction that is different in both traces and I recommend
>> showing 20 more instructions after that, but you can abort one after
>> that time, if it doesn't halt, to prevent the trace getting infinitely
>> long.
>
> Turing Machines and Olcott machines cannot properly implement
> H1(D,D) and H(D,D) that know their own machine address.
>
> My C code proves these two have different behavior:
> (a) H1(D,D) + H1_machine_address
> (b) H(D,D) + H_machine_address
>
> Because they are different computations they are
> not required to have the same behavior.

Right, but it also means that since the dfference is because of a
"Hidden" input none of them qualify as a Halt Decider.

>
> H(D,D) immediately sees the first time it calls itself
> with its same inputs.
>
> H1(D,D) never sees it call itself with its same inputs.
>
> Full Execution trace of H1(D,D)
> (a) main() invokes H1(D,D)
> (b) H1(D,D) simulates D(D)
> (c) Simulated D(D) calls simulated H(D,D)
> (d) Simulated H(D,D) simulates another D(D)
> (e) Simulated H(D,D) aborts this D(D) when it would call itself
> (f) Simulated H(D,D) returns 0 to simulated caller D(D)
> (g) Simulated caller D(D) returns to H1(D,D)
> (h) H1(D,D) returns 1 to main()
>
> They cannot be implemented as Turing Machines or Olcott
> Machines. They can be implemented as RASP machines proven
> by the fact that they are implemented as C functions.
>

Right, which proves your C functions also were never the required
computation, as they has an extra "hidden" input. As has been told to
you many times in the past.

So, you just admitted that you hae just been lying for all these years,
and you are no closer to your fantasy goal then you ever were.

Sorry, you just don't know enough to do this problem.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --attribution--

<uslpbr$1enef$17@i2pn2.org>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55216&group=comp.theory#55216

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC_--attribution--
Date: Sun, 10 Mar 2024 19:13:14 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <uslpbr$1enef$17@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usikk8$2gnhr$8@dont-email.me>
<usiljd$2hc10$3@dont-email.me> <usineq$2hnpb$3@dont-email.me>
<usiq9n$2ijsm$1@dont-email.me> <usir82$2inqh$2@dont-email.me>
<usit21$2j3c8$1@dont-email.me> <usiufa$2j99n$1@dont-email.me>
<usiukh$2jaj3$1@dont-email.me> <usiuup$2jdc7$2@dont-email.me>
<usj254$2jutc$2@dont-email.me> <usj2e3$2jut2$1@dont-email.me>
<usj2je$2jutc$3@dont-email.me> <usj2rs$2jut2$2@dont-email.me>
<usj32s$2k5id$1@dont-email.me> <usjd20$2plge$1@dont-email.me>
<usjef5$1cf5q$6@i2pn2.org> <usjfj8$2q613$1@dont-email.me>
<usjgs6$1cf5q$7@i2pn2.org> <usjhks$2qhfq$1@dont-email.me>
<usjj7v$1cf5q$8@i2pn2.org> <uskg1p$30hr1$1@dont-email.me>
<KEkHN.386271$vFZa.185803@fx13.iad> <uskog1$32h3c$1@dont-email.me>
<uskpe3$32l00$1@dont-email.me> <uskq04$32h3c$3@dont-email.me>
<usks70$1enef$1@i2pn2.org> <usktro$33lov$1@dont-email.me>
<usl1c7$1enef$9@i2pn2.org> <usll3l$38f21$1@dont-email.me>
<lttHN.366350$q3F7.85039@fx45.iad> <uslou1$390q2$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 02:13:16 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1531343"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <uslou1$390q2$1@dont-email.me>
Content-Language: en-US

by: Richard Damon - Mon, 11 Mar 2024 02:13 UTC

On 3/10/24 7:05 PM, olcott wrote:
> On 3/10/2024 8:52 PM, Richard Damon wrote:
>> On 3/10/24 6:00 PM, olcott wrote:
>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>> On 3/10/24 11:23 AM, olcott wrote:
>>>>> On 3/10/2024 12:55 PM, Richard Damon wrote:
>>>>>> On 3/10/24 10:17 AM, olcott wrote:
>>>>>>> On 3/10/2024 12:08 PM, Richard Damon wrote:
>>>>>>>> On 3/10/24 9:52 AM, olcott wrote:
>>>>>>>>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>>>>>>>>> On 3/10/24 7:28 AM, olcott wrote:
>>>>>>>>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>>>>>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that they themselves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This means that they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
>>>>>>>>>>>>>>>>>>>>>>>>>>>> same objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H
>>>>>>>>>>>>>>>>>>>>>>>>>>> is not*
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE
>>>>>>>>>>>>>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The above is true no matter what criteria that
>>>>>>>>>>>>>>>>>>>>>>>>> is used
>>>>>>>>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the
>>>>>>>>>>>>>>>>>>>>>>>> subject is. They are objective. The answer to
>>>>>>>>>>>>>>>>>>>>>>>> different people is the same answer if the
>>>>>>>>>>>>>>>>>>>>>>>> criteria are objective.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in
>>>>>>>>>>>>>>>>>>>>>>> recursive
>>>>>>>>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never
>>>>>>>>>>>>>>>>>>>>>>> runs
>>>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get
>>>>>>>>>>>>>>>>>>>>>>> stuck
>>>>>>>>>>>>>>>>>>>>>>> in recursive because H does not copy its input
>>>>>>>>>>>>>>>>>>>>>>> thus runs
>>>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a
>>>>>>>>>>>>>>>>>>>>>> dead monkey could do better. Write the Olcott
>>>>>>>>>>>>>>>>>>>>>> machine (not x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied
>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ halts
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied
>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ does not halt
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That's not a verified fact, that's just something
>>>>>>>>>>>>>>>>>>>> you want to be true.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt.
>>>>>>>>>>>>>>>>>>>> You see how stupid it is, to say that an infinite
>>>>>>>>>>>>>>>>>>>> loop halts?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions
>>>>>>>>>>>>>>>>>>>>> to Ĥ.H
>>>>>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates
>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT
>>>>>>>>>>>>>>>>>>>> IS PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>>>>>>>> > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *Yes and the key step of copying its input is left
>>>>>>>>>>>>>>>>>>> out so*
>>>>>>>>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>>>>>>>>>> runs out of params*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> that isn't how any of this works. Do you even know
>>>>>>>>>>>>>>>>>> what words mean?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>>>>>> the process
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one
>>>>>>>>>>>>>>>>> more execution
>>>>>>>>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>>>>>>>>> The algorithm of H begins a simulation of its input,
>>>>>>>>>>>>>>>> watching the behaior of H^ (H^)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (c) = (2)
>>>>>>>>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the
>>>>>>>>>>>>>>>> simulation of its input ...
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> and so on.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, the top level H is farther along at any given time
>>>>>>>>>>>>>>>> then its simulated machine, and that is H's problem, it
>>>>>>>>>>>>>>>> has to act before it sees how its simulation will
>>>>>>>>>>>>>>>> respond to its copy of its actions.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus, if it stops, it needs to make its decision "blind"
>>>>>>>>>>>>>>>> and not with an idea of how the machine it is simulating
>>>>>>>>>>>>>>>> will perform.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If it doesn't stop, the level of recursion just keeps
>>>>>>>>>>>>>>>> growing and no answer ever comes out.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>>>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>>>>>>>>>>> its simulation. Right before its cycle repeats the first
>>>>>>>>>>>>>>> time.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If it DOES abort there, then so will H^.H when it gets to
>>>>>>>>>>>>>> that point in its simulation, which will be AFTER The
>>>>>>>>>>>>>> point that H has stopped simulating it, so H doesn't know
>>>>>>>>>>>>>> what H^ will do.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus, if H DOES abort there, we presume from your previous
>>>>>>>>>>>>>> answer it will think the input will not halt and answer qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>
>>>>>>>>>>>> And if it does, as I said below, so will H^.H when it is run.
>>>>>>>>>>>
>>>>>>>>>>> Yes.
>>>>>>>>>>
>>>>>>>>>> And thus, H^.H will give the same answer as H,
>>>>>>>>>> so H^ will act contrary to what H says,
>>>>>>>>>> so H will give the wrong answer.
>>>>>>>>>
>>>>>>>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>>>>>>>>> simulation to prevent their own infinite execution.
>>>>>>>>
>>>>>>>> NOPE.
>>>>>>>
>>>>>>> If no source can be cited then the Olcott thesis
>>>>>>> "that no one did this before" remains unrefuted.
>>>>>>
>>>>>> Since, BY THE DEFINITIONS of what H MUST do to be correct, and
>>>>>> what H^ WILL do by its design, as shown in the Linz Proof.
>>>>>
>>>>> If no source can be cited that shows a simulating halt decider can
>>>>> correctly determine that it must abort its simulation of the Halting
>>>>> Problem's pathological input to prevent its own non-termination, then
>>>>> innovation remains attributable to me.
>>>>>
>>>>> <snip>
>>>>
>>>> Of course it can abort its simulation.
>>>>
>>>> It just needs some way to get the right answer.
>>>>
>>>
>>> *I have always been using this long before I read about it*
>>> blind variation and selective retention (BVSR)...
>>> Two common phenomena characterize BVSR thinking: superfluity and
>>> backtracking. Superfluity means that the creator generates a variety
>>> of ideas, one or more of which turn out to be useless.
>>
>> But if you have mo idea how things actually works, this seems to just
>> generate random noise.
>>
>>>
>>> Backtracking signifies that the creator must often return to an
>>> earlier approach after blindly going off in the wrong direction.
>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>
>>> *I am aware of no one else that had the idea to apply a simulating*
>>> *termination analyzer to the halting problem counter-example input*
>>> Professor Hehner had a seed of this idea before I did.
>>
>> Nope, I remember talk of that when I was in college, and they showed
>> why it can't work.
>>
>>>
>>> From a programmer's point of view, if we apply an interpreter to a
>>> program text that includes a call to that same interpreter with that
>>> same text as argument, then we have an infinite loop. A halting program
>>> has some of the same character as an interpreter: it applies to texts
>>> through abstract interpretation. Unsurprisingly, if we apply a halting
>>> program to a program text that includes a call to that same halting
>>> program with that same text as argument, then we have an infinite
>>> loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>>
>> You THINK so, but if the interpreter is a CONDITIONAL interpreter,
>> that doesn't hold.
>>
>> You seem to miss that fact.
>>
>>>
>>> *Turing Machine and Olcott machine implementations seem to be dead*
>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>> Every machine must be able to get its own machine address.
>>>
>>
>> And the reason it is a dead end is they make it too hard for you to
>> cheat.
>>
>> You need to hide that your H is trying to get in some extra
>> information to hide that the embedded version of H doesn't give the
>> same answer, which just shows that your H^ is built wrong.
>
> My C code proves these two have different behavior:
> (a) H1(D,D) + H1_machine_address
> (b) H(D,D) + H_machine_address
> H1(D,D) does correctly determine the halt status of D(D) because
> H(D,D) does NOT correctly determine the halt status of D(D).
>
> I say:
> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>
> immibis disagrees.
> Correct reasoning will show who is correct.
>

Click here to read the complete article

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior --RASP Machines--

<uslpn9$1enef$18@i2pn2.org>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55217&group=comp.theory#55217

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_--RASP_Machines--
Date: Sun, 10 Mar 2024 19:19:21 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <uslpn9$1enef$18@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usikk8$2gnhr$8@dont-email.me>
<usiljd$2hc10$3@dont-email.me> <usineq$2hnpb$3@dont-email.me>
<usiq9n$2ijsm$1@dont-email.me> <usir82$2inqh$2@dont-email.me>
<usit21$2j3c8$1@dont-email.me> <usiufa$2j99n$1@dont-email.me>
<usiukh$2jaj3$1@dont-email.me> <usiuup$2jdc7$2@dont-email.me>
<usj254$2jutc$2@dont-email.me> <usj2e3$2jut2$1@dont-email.me>
<usj2je$2jutc$3@dont-email.me> <usj2rs$2jut2$2@dont-email.me>
<usj32s$2k5id$1@dont-email.me> <usjd20$2plge$1@dont-email.me>
<usjef5$1cf5q$6@i2pn2.org> <usjfj8$2q613$1@dont-email.me>
<usjgs6$1cf5q$7@i2pn2.org> <usjhks$2qhfq$1@dont-email.me>
<usjj7v$1cf5q$8@i2pn2.org> <uskg1p$30hr1$1@dont-email.me>
<KEkHN.386271$vFZa.185803@fx13.iad> <uskog1$32h3c$1@dont-email.me>
<uskpe3$32l00$1@dont-email.me> <uskq04$32h3c$3@dont-email.me>
<usksvk$33a1p$5@dont-email.me> <uskubp$33lov$3@dont-email.me>
<usl0u7$34bnj$1@dont-email.me> <usljen$385ff$1@dont-email.me>
<uslk9j$385q4$5@dont-email.me> <usllu9$38jtu$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 02:19:22 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1531343"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <usllu9$38jtu$1@dont-email.me>

by: Richard Damon - Mon, 11 Mar 2024 02:19 UTC

On 3/10/24 6:14 PM, olcott wrote:
> On 3/10/2024 7:46 PM, immibis wrote:
>> On 11/03/24 01:32, olcott wrote:
>>> On 3/10/2024 2:16 PM, immibis wrote:
>>>>
>>>> I noticed that you gave up on Olcott machines and now you are back
>>>> to your old bullshit ways of pretending that the same machine can
>>>> produce two different execution traces on the same input. Why don't
>>>> you show us an execution trace where that happens? Both traces must
>>>> show the first instruction that is different in both traces and I
>>>> recommend showing 20 more instructions after that, but you can abort
>>>> one after that time, if it doesn't halt, to prevent the trace
>>>> getting infinitely long.
>>>
>>> Turing Machines and Olcott machines cannot properly implement
>>> H1(D,D) and H(D,D) that know their own machine address.
>>
>> "Know their own machine address" isn't an objective specification and
>> it has nothing to do with the halting problem anyway. Turing machines
>> don't have machine addresses and Olcott machines don't have machine
>> addresses either.
>>
>>> My C code proves these two have different behavior:
>>> (a) H1(D,D) + H1_machine_address
>>> (b) H(D,D) + H_machine_address
>>
>> Of course.
>>
>>> Because they are different computations they are
>>> not required to have the same behavior.
>>
>> Of course. One of them even answers the halting problem correctly in
>> this case. But that's because this case isn't the Linz counterexample
>> for H1. If you built the Linz counterexample for H1, which is D1,
>> you'd find that H1 gets it wrong, so H1 doesn't solve the halting
>> problem.
>
> I am taking H1(D,D) to be Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ and H(D,D) to be Linz H ⟨Ĥ⟩.
> Since we are using machine addresses there is no need for copies.
> This simplifies Linz Ĥ down to this.

Then you are just LYING about following Linz.

Linz H^ needs to use the EXACT computation that it is to foil, and call
it in a way that it give exactly the same answer.

Anything else is just a LIE.

>
> Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> H/D does contradict itself like simplified Linz Ĥ and
> H1(D,D) does not contradict itself like Linz H ⟨Ĥ⟩ ⟨Ĥ⟩.

H^ / D contradicts the H that it was trageted to defeat.

That any other decider get it right is irreleent.

>
>>> They cannot be implemented as Turing Machines or Olcott
>>> Machines. They can be implemented as RASP machines proven
>>> by the fact that they are implemented as C functions.
>>
>> They can be implemented as Turing machines. Each one is different from
>> the other. They are not the same.
>>
>
> Turing machines and Olcott machines cannot know their own machine
> address in a way that cannot be circumvented. X86 virtual machines
> and thus (possibly augmented) RASP machines can.
>

Right, that is how you are CHEATING.

YOu are just now being more blantant about it, which make it easier to
point that you are just lying.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<uslqr6$3d3q7$1@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55218&group=comp.theory#55218

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 21:38:30 -0500
Organization: A noiseless patient Spider
Lines: 95
Message-ID: <uslqr6$3d3q7$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usineq$2hnpb$3@dont-email.me>
<usiq9n$2ijsm$1@dont-email.me> <usir82$2inqh$2@dont-email.me>
<usit21$2j3c8$1@dont-email.me> <usiufa$2j99n$1@dont-email.me>
<usiukh$2jaj3$1@dont-email.me> <usiuup$2jdc7$2@dont-email.me>
<usj254$2jutc$2@dont-email.me> <usj2e3$2jut2$1@dont-email.me>
<usj2je$2jutc$3@dont-email.me> <usj2rs$2jut2$2@dont-email.me>
<usj32s$2k5id$1@dont-email.me> <usjd20$2plge$1@dont-email.me>
<usjef5$1cf5q$6@i2pn2.org> <usjfj8$2q613$1@dont-email.me>
<usjgs6$1cf5q$7@i2pn2.org> <usjhks$2qhfq$1@dont-email.me>
<usjj7v$1cf5q$8@i2pn2.org> <uskg1p$30hr1$1@dont-email.me>
<KEkHN.386271$vFZa.185803@fx13.iad> <uskog1$32h3c$1@dont-email.me>
<uskpe3$32l00$1@dont-email.me> <uskq04$32h3c$3@dont-email.me>
<usksvk$33a1p$5@dont-email.me> <uskubp$33lov$3@dont-email.me>
<usl0hh$34290$3@dont-email.me> <usl0v5$347rv$2@dont-email.me>
<usljui$385q4$2@dont-email.me> <uslmh7$38jtu$2@dont-email.me>
<IEtHN.366351$q3F7.176464@fx45.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 02:38:30 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3575623"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/T15n9sadRSkcyGHj7/2aD"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:PmPzEcr+25wG5BzOdagdwfNxDx4=
In-Reply-To: <IEtHN.366351$q3F7.176464@fx45.iad>
Content-Language: en-US

by: olcott - Mon, 11 Mar 2024 02:38 UTC

On 3/10/2024 9:04 PM, Richard Damon wrote:
> On 3/10/24 6:24 PM, olcott wrote:
>> On 3/10/2024 7:40 PM, immibis wrote:
>>> On 10/03/24 20:16, olcott wrote:
>>>> On 3/10/2024 2:09 PM, immibis wrote:
>>>>> On 10/03/24 19:32, olcott wrote:
>>>>>> On 3/10/2024 1:08 PM, immibis wrote:
>>>>>>> On 10/03/24 18:17, olcott wrote:
>>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>>>>>
>>>>>>> So you are saying that some Turing machines are not sound?
>>>>>>>
>>>>>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>>>>>> (a) Their input halts H.qy
>>>>>>>>>> (b) Their input fails to halt or has a pathological
>>>>>>>>>> relationship to itself H.qn.
>>>>>>>>>
>>>>>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>>>>>
>>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>>>>>> expressly disallowing the "Pathological Relationship".
>>>>>>>
>>>>>>> So you are saying that some Turing machines are not real Turing
>>>>>>> machines?
>>>>>>>
>>>>>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>>>>>> when their input halts and correctly say NOT YES otherwise.
>>>>>>>
>>>>>>> well the halting problem requires them to correctly say NO, so
>>>>>>> you haven't solved it
>>>>>>
>>>>>> All decision problem instances of program/input such that both
>>>>>> yes and no are the wrong answer toss out the input as invalid.
>>>>>>
>>>>>
>>>>> all decision problems are defined so that all instances are valid
>>>>> or else they are not defined properly
>>>>>
>>>>
>>>> Not in the case of Russell's Paradox.
>>>
>>> And now we are back to: Every Turing machine and input pair defines
>>> an execution sequence. Every sequence is either finite or infinite.
>>> Therefore it is well-defined and there is no paradox.
>>>
>>> Can you show me a Turing machine that specifies a sequence of
>>> configurations that is not finite or infinite?
>>
>> When we construe every yes/no question that cannot possibly
>> have a correct yes/no answer as an incorrect question
>>
>> then we must correspondingly construe every decider/input
>> pair that has no correct yes/no answer as invalid input.
>>
>
> And when you remember that when we posse that ACTUAL question, the input
> is a FIXED machine, (not a template that changes by the decide that it
> trying to decide it) then there are a LOT of machines that get the right
> answer. The key is we know that there is ONE that doesn't, the one that
> particular decider was built to foil. Thus, the problem isn't an invalid
> question.

In computability theory and computational complexity theory,
an undecidable problem is a decision problem for which it is
proved to be impossible to construct an algorithm that always
leads to a correct yes-or-no answer.
https://en.wikipedia.org/wiki/Undecidable_problem

If the only reason that a machine does not get a correct yes/no answer
for this machine/input pair is that both yes and no are the wrong answer
for this machine/input pair then this machine/input pair is a yes/no
question that has no correct yes/no answer for this machine/input pair.

The exact same word-for-word question:
Are you a little girl?
Has a different meaning depending on who is asked.

The exact same word-for-word question:
Does your input halt on its input?
Has a different meaning depending on who is asked.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

When every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is asked this question:
Does your input halt on its input?
It is an incorrect question.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior --RASP Machines--

<uslrcc$3d3q0$1@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55219&group=comp.theory#55219

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_--RASP_Machines--
Date: Sun, 10 Mar 2024 21:47:40 -0500
Organization: A noiseless patient Spider
Lines: 104
Message-ID: <uslrcc$3d3q0$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0u7$34bnj$1@dont-email.me>
<usljen$385ff$1@dont-email.me> <hItHN.366352$q3F7.153154@fx45.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 02:47:40 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3575616"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18mxAXMpHpEvtgu2Vo6S0S3"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:/uvR90x1oZy/rvOoRls799VHKV0=
In-Reply-To: <hItHN.366352$q3F7.153154@fx45.iad>
Content-Language: en-US

by: olcott - Mon, 11 Mar 2024 02:47 UTC

On 3/10/2024 9:08 PM, Richard Damon wrote:
> On 3/10/24 5:32 PM, olcott wrote:
>> On 3/10/2024 2:16 PM, immibis wrote:
>>> On 10/03/24 19:32, olcott wrote:
>>>> On 3/10/2024 1:08 PM, immibis wrote:
>>>>> On 10/03/24 18:17, olcott wrote:
>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>>>
>>>>> So you are saying that some Turing machines are not sound?
>>>>>
>>>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>>>> (a) Their input halts H.qy
>>>>>>>> (b) Their input fails to halt or has a pathological
>>>>>>>> relationship to itself H.qn.
>>>>>>>
>>>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>>>
>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>>>> expressly disallowing the "Pathological Relationship".
>>>>>
>>>>> So you are saying that some Turing machines are not real Turing
>>>>> machines?
>>>>>
>>>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>>>> when their input halts and correctly say NOT YES otherwise.
>>>>>
>>>>> well the halting problem requires them to correctly say NO, so you
>>>>> haven't solved it
>>>>
>>>> All decision problem instances of program/input such that both
>>>> yes and no are the wrong answer toss out the input as invalid.
>>>
>>> I noticed that you gave up on Olcott machines and now you are back to
>>> your old bullshit ways of pretending that the same machine can
>>> produce two different execution traces on the same input. Why don't
>>> you show us an execution trace where that happens? Both traces must
>>> show the first instruction that is different in both traces and I
>>> recommend showing 20 more instructions after that, but you can abort
>>> one after that time, if it doesn't halt, to prevent the trace getting
>>> infinitely long.
>>
>> Turing Machines and Olcott machines cannot properly implement
>> H1(D,D) and H(D,D) that know their own machine address.
>>
>> My C code proves these two have different behavior:
>> (a) H1(D,D) + H1_machine_address
>> (b) H(D,D) + H_machine_address
>>
>> Because they are different computations they are
>> not required to have the same behavior.
>
> Right, but it also means that since the dfference is because of a
> "Hidden" input none of them qualify as a Halt Decider.
>

The key input (the machines own address) is not hidden
merely unavailable to Turing machine and Olcott machines.

>>
>> H(D,D) immediately sees the first time it calls itself
>> with its same inputs.
>>
>> H1(D,D) never sees it call itself with its same inputs.
>>
>> Full Execution trace of H1(D,D)
>> (a) main() invokes H1(D,D)
>> (b) H1(D,D) simulates D(D)
>> (c) Simulated D(D) calls simulated H(D,D)
>> (d) Simulated H(D,D) simulates another D(D)
>> (e) Simulated H(D,D) aborts this D(D) when it would call itself
>> (f) Simulated H(D,D) returns 0 to simulated caller D(D)
>> (g) Simulated caller D(D) returns to H1(D,D)
>> (h) H1(D,D) returns 1 to main()
>>
>> They cannot be implemented as Turing Machines or Olcott
>> Machines. They can be implemented as RASP machines proven
>> by the fact that they are implemented as C functions.
>>
>
> Right, which proves your C functions also were never the required
> computation, as they has an extra "hidden" input. As has been told to
> you many times in the past.

When I specify that every machine can know its own machine address
in x86 machines and (possibly augmented) RASP machines then it is
not hidden and an explicitly part of the input to the computation.

>
> So, you just admitted that you hae just been lying for all these years,
> and you are no closer to your fantasy goal then you ever were.
>
> Sorry, you just don't know enough to do this problem.

I just admitted that it took me about two years to translate my
intuitions into words that address your objections.

For these two years you and many other people claimed that H1(D,D)
could not possibly do what it actually did actually do. This has
always been the same thing as disagreeing with arithmetic.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usls1d$1enef$19@i2pn2.org>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55220&group=comp.theory#55220

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 19:58:52 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usls1d$1enef$19@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0hh$34290$3@dont-email.me>
<usl0v5$347rv$2@dont-email.me> <usljui$385q4$2@dont-email.me>
<uslmh7$38jtu$2@dont-email.me> <IEtHN.366351$q3F7.176464@fx45.iad>
<uslqr6$3d3q7$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 02:58:54 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1531343"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <uslqr6$3d3q7$1@dont-email.me>
Content-Language: en-US

by: Richard Damon - Mon, 11 Mar 2024 02:58 UTC

On 3/10/24 7:38 PM, olcott wrote:
> On 3/10/2024 9:04 PM, Richard Damon wrote:
>> On 3/10/24 6:24 PM, olcott wrote:
>>> On 3/10/2024 7:40 PM, immibis wrote:
>>>> On 10/03/24 20:16, olcott wrote:
>>>>> On 3/10/2024 2:09 PM, immibis wrote:
>>>>>> On 10/03/24 19:32, olcott wrote:
>>>>>>> On 3/10/2024 1:08 PM, immibis wrote:
>>>>>>>> On 10/03/24 18:17, olcott wrote:
>>>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>>>>>>
>>>>>>>> So you are saying that some Turing machines are not sound?
>>>>>>>>
>>>>>>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>>>>>>> (a) Their input halts H.qy
>>>>>>>>>>> (b) Their input fails to halt or has a pathological
>>>>>>>>>>> relationship to itself H.qn.
>>>>>>>>>>
>>>>>>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>>>>>>
>>>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>>>>>>> expressly disallowing the "Pathological Relationship".
>>>>>>>>
>>>>>>>> So you are saying that some Turing machines are not real Turing
>>>>>>>> machines?
>>>>>>>>
>>>>>>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>>>>>>> when their input halts and correctly say NOT YES otherwise.
>>>>>>>>
>>>>>>>> well the halting problem requires them to correctly say NO, so
>>>>>>>> you haven't solved it
>>>>>>>
>>>>>>> All decision problem instances of program/input such that both
>>>>>>> yes and no are the wrong answer toss out the input as invalid.
>>>>>>>
>>>>>>
>>>>>> all decision problems are defined so that all instances are valid
>>>>>> or else they are not defined properly
>>>>>>
>>>>>
>>>>> Not in the case of Russell's Paradox.
>>>>
>>>> And now we are back to: Every Turing machine and input pair defines
>>>> an execution sequence. Every sequence is either finite or infinite.
>>>> Therefore it is well-defined and there is no paradox.
>>>>
>>>> Can you show me a Turing machine that specifies a sequence of
>>>> configurations that is not finite or infinite?
>>>
>>> When we construe every yes/no question that cannot possibly
>>> have a correct yes/no answer as an incorrect question
>>>
>>> then we must correspondingly construe every decider/input
>>> pair that has no correct yes/no answer as invalid input.
>>>
>>
>> And when you remember that when we posse that ACTUAL question, the
>> input is a FIXED machine, (not a template that changes by the decide
>> that it trying to decide it) then there are a LOT of machines that get
>> the right answer. The key is we know that there is ONE that doesn't,
>> the one that particular decider was built to foil. Thus, the problem
>> isn't an invalid question.
>
>
> In computability theory and computational complexity theory,
> an undecidable problem is a decision problem for which it is
> proved to be impossible to construct an algorithm that always
> leads to a correct yes-or-no answer.
> https://en.wikipedia.org/wiki/Undecidable_problem

Right.

>
> If the only reason that a machine does not get a correct yes/no answer
> for this machine/input pair is that both yes and no are the wrong answer
> for this machine/input pair then this machine/input pair is a yes/no
> question that has no correct yes/no answer for this machine/input pair.
>
> The exact same word-for-word question:
> Are you a little girl?
> Has a different meaning depending on who is asked.

Right, but "Does this input describd a computation that Halts when Run?"
ALWAYS has a correct answer, when that input IS a computation, a
SPECIFIC algorithm applied to a SPECIFIC input.

Nothing in that question refers to who it is being ask of.

Note, Converting the input to a template that looks at the decider
deciding on it, that IS an invalid input, and can't actually be build
with a Turing Machine description as an input.

Part of your problem is you have changed the problem because you don't
understand it.

H^ uses a SPECIFIC DEFINED H, the ONE machine this H^ is designed to
foil. It doesn't change when you change the H looking at it.

There ALWAYS is a correct answer for that H^ (H^), it is just a fact the
particular H it was built for will get it wrong.

When you combine that with the fact that you can make a similar input
for ANY machine that wants to try to claim to be a Halt Decider, and we
end up not being able to have Halt Deciders.

>
> The exact same word-for-word question:
> Does your input halt on its input?
> Has a different meaning depending on who is asked.

NOPE.

Because H^ (H^) Will always do the same thing no matter who you ask
about it, because a given H^ (which is what the question is about) will
ALWAYS use its one specific H and always do the same thing.

>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> When every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is asked this question:
> Does your input halt on its input?
> It is an incorrect question.
>

What do you mean by "Every"?

For any specific question, there is just one specific H^ with a specific
operation and that H^ will always end up in qy or qn depending on
exactly what the specific H it was built on does.

You have the wrong question.

The question is NOT about the TEMPLATE, but a specific instance of that
template built on a specific decider, that makes that one decider wrong.

You just seem too dumb to understand that.

H^ is NOT a "Template", ^ is a template that has been applied to a
SPECIFIC machine H (not a set of them, but just a specific one).

You have just been lying to yourself too long, and have forgottent the
actual problem.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior --RASP Machines--

<uslsgn$1enef$20@i2pn2.org>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55221&group=comp.theory#55221

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_--RASP_Machines--
Date: Sun, 10 Mar 2024 20:07:02 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <uslsgn$1enef$20@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0u7$34bnj$1@dont-email.me>
<usljen$385ff$1@dont-email.me> <hItHN.366352$q3F7.153154@fx45.iad>
<uslrcc$3d3q0$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 03:07:04 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1531343"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <uslrcc$3d3q0$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0

by: Richard Damon - Mon, 11 Mar 2024 03:07 UTC

On 3/10/24 7:47 PM, olcott wrote:
> On 3/10/2024 9:08 PM, Richard Damon wrote:
>> On 3/10/24 5:32 PM, olcott wrote:
>>> On 3/10/2024 2:16 PM, immibis wrote:
>>>> On 10/03/24 19:32, olcott wrote:
>>>>> On 3/10/2024 1:08 PM, immibis wrote:
>>>>>> On 10/03/24 18:17, olcott wrote:
>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>>>>
>>>>>> So you are saying that some Turing machines are not sound?
>>>>>>
>>>>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>>>>> (a) Their input halts H.qy
>>>>>>>>> (b) Their input fails to halt or has a pathological
>>>>>>>>> relationship to itself H.qn.
>>>>>>>>
>>>>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>>>>
>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>>>>> expressly disallowing the "Pathological Relationship".
>>>>>>
>>>>>> So you are saying that some Turing machines are not real Turing
>>>>>> machines?
>>>>>>
>>>>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>>>>> when their input halts and correctly say NOT YES otherwise.
>>>>>>
>>>>>> well the halting problem requires them to correctly say NO, so you
>>>>>> haven't solved it
>>>>>
>>>>> All decision problem instances of program/input such that both
>>>>> yes and no are the wrong answer toss out the input as invalid.
>>>>
>>>> I noticed that you gave up on Olcott machines and now you are back
>>>> to your old bullshit ways of pretending that the same machine can
>>>> produce two different execution traces on the same input. Why don't
>>>> you show us an execution trace where that happens? Both traces must
>>>> show the first instruction that is different in both traces and I
>>>> recommend showing 20 more instructions after that, but you can abort
>>>> one after that time, if it doesn't halt, to prevent the trace
>>>> getting infinitely long.
>>>
>>> Turing Machines and Olcott machines cannot properly implement
>>> H1(D,D) and H(D,D) that know their own machine address.
>>>
>>> My C code proves these two have different behavior:
>>> (a) H1(D,D) + H1_machine_address
>>> (b) H(D,D) + H_machine_address
>>>
>>> Because they are different computations they are
>>> not required to have the same behavior.
>>
>> Right, but it also means that since the dfference is because of a
>> "Hidden" input none of them qualify as a Halt Decider.
>>
>
> The key input (the machines own address) is not hidden
> merely unavailable to Turing machine and Olcott machines.

And if it isn't hidden, then the other copies that take use a different
address become different computations and can't claim to fill in for THE H.

You then prove each copy wrong by giving it the version of H^/D that is
built on it, which it will get wrong.

All the other ones might get it right, showing that there IS a correct
answer.

>
>>>
>>> H(D,D) immediately sees the first time it calls itself
>>> with its same inputs.
>>>
>>> H1(D,D) never sees it call itself with its same inputs.
>>>
>>> Full Execution trace of H1(D,D)
>>> (a) main() invokes H1(D,D)
>>> (b) H1(D,D) simulates D(D)
>>> (c) Simulated D(D) calls simulated H(D,D)
>>> (d) Simulated H(D,D) simulates another D(D)
>>> (e) Simulated H(D,D) aborts this D(D) when it would call itself
>>> (f) Simulated H(D,D) returns 0 to simulated caller D(D)
>>> (g) Simulated caller D(D) returns to H1(D,D)
>>> (h) H1(D,D) returns 1 to main()
>>>
>>> They cannot be implemented as Turing Machines or Olcott
>>> Machines. They can be implemented as RASP machines proven
>>> by the fact that they are implemented as C functions.
>>>
>>
>> Right, which proves your C functions also were never the required
>> computation, as they has an extra "hidden" input. As has been told to
>> you many times in the past.
>
> When I specify that every machine can know its own machine address
> in x86 machines and (possibly augmented) RASP machines then it is
> not hidden and an explicitly part of the input to the computation.

And if it isn't hidden, then the other copies that take use a different
address become different computations and can't claim to fill in for THE H.

You then prove each copy wrong by giving it the version of H^/D that is
built on it, which it will get wrong.

All the other ones might get it right, showing that there IS a correct
answer.

>
>>
>> So, you just admitted that you hae just been lying for all these
>> years, and you are no closer to your fantasy goal then you ever were.
>>
>> Sorry, you just don't know enough to do this problem.
>
> I just admitted that it took me about two years to translate my
> intuitions into words that address your objections.
>
> For these two years you and many other people claimed that H1(D,D)
> could not possibly do what it actually did actually do. This has
> always been the same thing as disagreeing with arithmetic.
>

It can't do it and be the SAME COMPUTATION as H, which is what you were
claiming.

You are now admitting you were lying all that time, and really owe an
appology to everyone yYOU said were lying when they were telling you
they weren't the same computation.

Of course, since you now admit they are different, that means that H1
can get H out of the jam. D will call the one instance of H, that one
particular computation, that it is designed to make wrong, and since the
other copies are different computations, they don't rescue that one, or
even show that the question is subjective.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --new focus--

<uslu1i$3do6h$1@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55222&group=comp.theory#55222

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC_--new_focus--
Date: Sun, 10 Mar 2024 22:33:05 -0500
Organization: A noiseless patient Spider
Lines: 376
Message-ID: <uslu1i$3do6h$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usks70$1enef$1@i2pn2.org>
<usktro$33lov$1@dont-email.me> <usl1c7$1enef$9@i2pn2.org>
<usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad>
<uslou1$390q2$1@dont-email.me> <uslpbr$1enef$17@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 03:33:06 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3596497"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18+jM91zWvJ/mVrh610QHWy"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:UaoD2RLizNG3KC1LceGfpKqGWv4=
Content-Language: en-US
In-Reply-To: <uslpbr$1enef$17@i2pn2.org>

by: olcott - Mon, 11 Mar 2024 03:33 UTC

On 3/10/2024 9:13 PM, Richard Damon wrote:
> On 3/10/24 7:05 PM, olcott wrote:
>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>> On 3/10/24 6:00 PM, olcott wrote:
>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>> On 3/10/24 11:23 AM, olcott wrote:
>>>>>> On 3/10/2024 12:55 PM, Richard Damon wrote:
>>>>>>> On 3/10/24 10:17 AM, olcott wrote:
>>>>>>>> On 3/10/2024 12:08 PM, Richard Damon wrote:
>>>>>>>>> On 3/10/24 9:52 AM, olcott wrote:
>>>>>>>>>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/10/24 7:28 AM, olcott wrote:
>>>>>>>>>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exact same objective criteria that H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that they themselves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This means that they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE
>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The above is true no matter what criteria that
>>>>>>>>>>>>>>>>>>>>>>>>>> is used
>>>>>>>>>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the
>>>>>>>>>>>>>>>>>>>>>>>>> subject is. They are objective. The answer to
>>>>>>>>>>>>>>>>>>>>>>>>> different people is the same answer if the
>>>>>>>>>>>>>>>>>>>>>>>>> criteria are objective.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in
>>>>>>>>>>>>>>>>>>>>>>>> recursive
>>>>>>>>>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never
>>>>>>>>>>>>>>>>>>>>>>>> runs
>>>>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>> get stuck
>>>>>>>>>>>>>>>>>>>>>>>> in recursive because H does not copy its input
>>>>>>>>>>>>>>>>>>>>>>>> thus runs
>>>>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that
>>>>>>>>>>>>>>>>>>>>>>> a dead monkey could do better. Write the Olcott
>>>>>>>>>>>>>>>>>>>>>>> machine (not x86utm) code for Ĥ and I would show
>>>>>>>>>>>>>>>>>>>>>>> you.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied
>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ halts
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied
>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ does not halt
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That's not a verified fact, that's just something
>>>>>>>>>>>>>>>>>>>>> you want to be true.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt.
>>>>>>>>>>>>>>>>>>>>> You see how stupid it is, to say that an infinite
>>>>>>>>>>>>>>>>>>>>> loop halts?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions
>>>>>>>>>>>>>>>>>>>>>> to Ĥ.H
>>>>>>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT
>>>>>>>>>>>>>>>>>>>>> IS PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>>>>>>>>> > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *Yes and the key step of copying its input is left
>>>>>>>>>>>>>>>>>>>> out so*
>>>>>>>>>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>>>>>>>>>>> runs out of params*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> that isn't how any of this works. Do you even know
>>>>>>>>>>>>>>>>>>> what words mean?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>>>>>>> the process
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one
>>>>>>>>>>>>>>>>>> more execution
>>>>>>>>>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>>>>>>>>>> The algorithm of H begins a simulation of its input,
>>>>>>>>>>>>>>>>> watching the behaior of H^ (H^)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (c) = (2)
>>>>>>>>>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the
>>>>>>>>>>>>>>>>> simulation of its input ...
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> and so on.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes, the top level H is farther along at any given time
>>>>>>>>>>>>>>>>> then its simulated machine, and that is H's problem, it
>>>>>>>>>>>>>>>>> has to act before it sees how its simulation will
>>>>>>>>>>>>>>>>> respond to its copy of its actions.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus, if it stops, it needs to make its decision
>>>>>>>>>>>>>>>>> "blind" and not with an idea of how the machine it is
>>>>>>>>>>>>>>>>> simulating will perform.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If it doesn't stop, the level of recursion just keeps
>>>>>>>>>>>>>>>>> growing and no answer ever comes out.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>>>>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>> begin
>>>>>>>>>>>>>>>> its simulation. Right before its cycle repeats the first
>>>>>>>>>>>>>>>> time.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If it DOES abort there, then so will H^.H when it gets to
>>>>>>>>>>>>>>> that point in its simulation, which will be AFTER The
>>>>>>>>>>>>>>> point that H has stopped simulating it, so H doesn't know
>>>>>>>>>>>>>>> what H^ will do.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus, if H DOES abort there, we presume from your
>>>>>>>>>>>>>>> previous answer it will think the input will not halt and
>>>>>>>>>>>>>>> answer qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩
>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And if it does, as I said below, so will H^.H when it is run.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes.
>>>>>>>>>>>
>>>>>>>>>>> And thus, H^.H will give the same answer as H,
>>>>>>>>>>> so H^ will act contrary to what H says,
>>>>>>>>>>> so H will give the wrong answer.
>>>>>>>>>>
>>>>>>>>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩
>>>>>>>>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their
>>>>>>>>>> own
>>>>>>>>>> simulation to prevent their own infinite execution.
>>>>>>>>>
>>>>>>>>> NOPE.
>>>>>>>>
>>>>>>>> If no source can be cited then the Olcott thesis
>>>>>>>> "that no one did this before" remains unrefuted.
>>>>>>>
>>>>>>> Since, BY THE DEFINITIONS of what H MUST do to be correct, and
>>>>>>> what H^ WILL do by its design, as shown in the Linz Proof.
>>>>>>
>>>>>> If no source can be cited that shows a simulating halt decider can
>>>>>> correctly determine that it must abort its simulation of the Halting
>>>>>> Problem's pathological input to prevent its own non-termination, then
>>>>>> innovation remains attributable to me.
>>>>>>
>>>>>> <snip>
>>>>>
>>>>> Of course it can abort its simulation.
>>>>>
>>>>> It just needs some way to get the right answer.
>>>>>
>>>>
>>>> *I have always been using this long before I read about it*
>>>> blind variation and selective retention (BVSR)...
>>>> Two common phenomena characterize BVSR thinking: superfluity and
>>>> backtracking. Superfluity means that the creator generates a variety
>>>> of ideas, one or more of which turn out to be useless.
>>>
>>> But if you have mo idea how things actually works, this seems to just
>>> generate random noise.
>>>
>>>>
>>>> Backtracking signifies that the creator must often return to an
>>>> earlier approach after blindly going off in the wrong direction.
>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>
>>>> *I am aware of no one else that had the idea to apply a simulating*
>>>> *termination analyzer to the halting problem counter-example input*
>>>> Professor Hehner had a seed of this idea before I did.
>>>
>>> Nope, I remember talk of that when I was in college, and they showed
>>> why it can't work.
>>>
>>>>
>>>> From a programmer's point of view, if we apply an interpreter to a
>>>> program text that includes a call to that same interpreter with that
>>>> same text as argument, then we have an infinite loop. A halting program
>>>> has some of the same character as an interpreter: it applies to texts
>>>> through abstract interpretation. Unsurprisingly, if we apply a halting
>>>> program to a program text that includes a call to that same halting
>>>> program with that same text as argument, then we have an infinite
>>>> loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>
>>> You THINK so, but if the interpreter is a CONDITIONAL interpreter,
>>> that doesn't hold.
>>>
>>> You seem to miss that fact.
>>>
>>>>
>>>> *Turing Machine and Olcott machine implementations seem to be dead*
>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>> Every machine must be able to get its own machine address.
>>>>
>>>
>>> And the reason it is a dead end is they make it too hard for you to
>>> cheat.
>>>
>>> You need to hide that your H is trying to get in some extra
>>> information to hide that the embedded version of H doesn't give the
>>> same answer, which just shows that your H^ is built wrong.
>>
>> My C code proves these two have different behavior:
>> (a) H1(D,D) + H1_machine_address
>> (b) H(D,D) + H_machine_address
>> H1(D,D) does correctly determine the halt status of D(D) because
>> H(D,D) does NOT correctly determine the halt status of D(D).
>>
>> I say:
>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>
>> immibis disagrees.
>> Correct reasoning will show who is correct.
>>
>
> Yes, and since H1 is a different computation than H, it getting the
> right answer doesn't keep H from being broken.
>
> We can then make a D1 to break H1.
>

Click here to read the complete article

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --new focus--

<usm07p$1enef$21@i2pn2.org>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55223&group=comp.theory#55223

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC_--new_focus--
Date: Sun, 10 Mar 2024 21:10:31 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usm07p$1enef$21@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usineq$2hnpb$3@dont-email.me>
<usiq9n$2ijsm$1@dont-email.me> <usir82$2inqh$2@dont-email.me>
<usit21$2j3c8$1@dont-email.me> <usiufa$2j99n$1@dont-email.me>
<usiukh$2jaj3$1@dont-email.me> <usiuup$2jdc7$2@dont-email.me>
<usj254$2jutc$2@dont-email.me> <usj2e3$2jut2$1@dont-email.me>
<usj2je$2jutc$3@dont-email.me> <usj2rs$2jut2$2@dont-email.me>
<usj32s$2k5id$1@dont-email.me> <usjd20$2plge$1@dont-email.me>
<usjef5$1cf5q$6@i2pn2.org> <usjfj8$2q613$1@dont-email.me>
<usjgs6$1cf5q$7@i2pn2.org> <usjhks$2qhfq$1@dont-email.me>
<usjj7v$1cf5q$8@i2pn2.org> <uskg1p$30hr1$1@dont-email.me>
<KEkHN.386271$vFZa.185803@fx13.iad> <uskog1$32h3c$1@dont-email.me>
<uskpe3$32l00$1@dont-email.me> <uskq04$32h3c$3@dont-email.me>
<usks70$1enef$1@i2pn2.org> <usktro$33lov$1@dont-email.me>
<usl1c7$1enef$9@i2pn2.org> <usll3l$38f21$1@dont-email.me>
<lttHN.366350$q3F7.85039@fx45.iad> <uslou1$390q2$1@dont-email.me>
<uslpbr$1enef$17@i2pn2.org> <uslu1i$3do6h$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 04:10:34 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1531343"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <uslu1i$3do6h$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0

by: Richard Damon - Mon, 11 Mar 2024 04:10 UTC

On 3/10/24 8:33 PM, olcott wrote:
> On 3/10/2024 9:13 PM, Richard Damon wrote:
>> On 3/10/24 7:05 PM, olcott wrote:
>>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>>> On 3/10/24 6:00 PM, olcott wrote:
>>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>>> On 3/10/24 11:23 AM, olcott wrote:
>>>>>>> On 3/10/2024 12:55 PM, Richard Damon wrote:
>>>>>>>> On 3/10/24 10:17 AM, olcott wrote:
>>>>>>>>> On 3/10/2024 12:08 PM, Richard Damon wrote:
>>>>>>>>>> On 3/10/24 9:52 AM, olcott wrote:
>>>>>>>>>>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>>>>>>>>>>> On 3/10/24 7:28 AM, olcott wrote:
>>>>>>>>>>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exact same objective criteria that H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that they themselves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This means that they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is not*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The above is true no matter what criteria
>>>>>>>>>>>>>>>>>>>>>>>>>>> that is used
>>>>>>>>>>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who
>>>>>>>>>>>>>>>>>>>>>>>>>> the subject is. They are objective. The answer
>>>>>>>>>>>>>>>>>>>>>>>>>> to different people is the same answer if the
>>>>>>>>>>>>>>>>>>>>>>>>>> criteria are objective.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck
>>>>>>>>>>>>>>>>>>>>>>>>> in recursive
>>>>>>>>>>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus
>>>>>>>>>>>>>>>>>>>>>>>>> never runs
>>>>>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>> get stuck
>>>>>>>>>>>>>>>>>>>>>>>>> in recursive because H does not copy its input
>>>>>>>>>>>>>>>>>>>>>>>>> thus runs
>>>>>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that
>>>>>>>>>>>>>>>>>>>>>>>> a dead monkey could do better. Write the Olcott
>>>>>>>>>>>>>>>>>>>>>>>> machine (not x86utm) code for Ĥ and I would show
>>>>>>>>>>>>>>>>>>>>>>>> you.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified
>>>>>>>>>>>>>>>>>>>>>>> facts*
>>>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified
>>>>>>>>>>>>>>>>>>>>>>> facts*
>>>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified
>>>>>>>>>>>>>>>>>>>>>>> facts*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied
>>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ halts
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied
>>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ does not halt
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> That's not a verified fact, that's just something
>>>>>>>>>>>>>>>>>>>>>> you want to be true.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt.
>>>>>>>>>>>>>>>>>>>>>> You see how stupid it is, to say that an infinite
>>>>>>>>>>>>>>>>>>>>>> loop halts?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions
>>>>>>>>>>>>>>>>>>>>>>> to Ĥ.H
>>>>>>>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT
>>>>>>>>>>>>>>>>>>>>>> IS PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>>>>>>>>>> > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *Yes and the key step of copying its input is left
>>>>>>>>>>>>>>>>>>>>> out so*
>>>>>>>>>>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>>>>>>>>>>>> runs out of params*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> that isn't how any of this works. Do you even know
>>>>>>>>>>>>>>>>>>>> what words mean?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one
>>>>>>>>>>>>>>>>>>> more execution
>>>>>>>>>>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>>>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>>>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>>>>>>>>>>> The algorithm of H begins a simulation of its input,
>>>>>>>>>>>>>>>>>> watching the behaior of H^ (H^)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (c) = (2)
>>>>>>>>>>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>>>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>>>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the
>>>>>>>>>>>>>>>>>> simulation of its input ...
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> and so on.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes, the top level H is farther along at any given
>>>>>>>>>>>>>>>>>> time then its simulated machine, and that is H's
>>>>>>>>>>>>>>>>>> problem, it has to act before it sees how its
>>>>>>>>>>>>>>>>>> simulation will respond to its copy of its actions.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus, if it stops, it needs to make its decision
>>>>>>>>>>>>>>>>>> "blind" and not with an idea of how the machine it is
>>>>>>>>>>>>>>>>>> simulating will perform.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If it doesn't stop, the level of recursion just keeps
>>>>>>>>>>>>>>>>>> growing and no answer ever comes out.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to
>>>>>>>>>>>>>>>>> abort
>>>>>>>>>>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>>> begin
>>>>>>>>>>>>>>>>> its simulation. Right before its cycle repeats the
>>>>>>>>>>>>>>>>> first time.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If it DOES abort there, then so will H^.H when it gets
>>>>>>>>>>>>>>>> to that point in its simulation, which will be AFTER The
>>>>>>>>>>>>>>>> point that H has stopped simulating it, so H doesn't
>>>>>>>>>>>>>>>> know what H^ will do.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus, if H DOES abort there, we presume from your
>>>>>>>>>>>>>>>> previous answer it will think the input will not halt
>>>>>>>>>>>>>>>> and answer qn.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And if it does, as I said below, so will H^.H when it is run.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes.
>>>>>>>>>>>>
>>>>>>>>>>>> And thus, H^.H will give the same answer as H,
>>>>>>>>>>>> so H^ will act contrary to what H says,
>>>>>>>>>>>> so H will give the wrong answer.
>>>>>>>>>>>
>>>>>>>>>>> Unlike anything else that anyone else has ever done both H
>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort
>>>>>>>>>>> their own
>>>>>>>>>>> simulation to prevent their own infinite execution.
>>>>>>>>>>
>>>>>>>>>> NOPE.
>>>>>>>>>
>>>>>>>>> If no source can be cited then the Olcott thesis
>>>>>>>>> "that no one did this before" remains unrefuted.
>>>>>>>>
>>>>>>>> Since, BY THE DEFINITIONS of what H MUST do to be correct, and
>>>>>>>> what H^ WILL do by its design, as shown in the Linz Proof.
>>>>>>>
>>>>>>> If no source can be cited that shows a simulating halt decider can
>>>>>>> correctly determine that it must abort its simulation of the Halting
>>>>>>> Problem's pathological input to prevent its own non-termination,
>>>>>>> then
>>>>>>> innovation remains attributable to me.
>>>>>>>
>>>>>>> <snip>
>>>>>>
>>>>>> Of course it can abort its simulation.
>>>>>>
>>>>>> It just needs some way to get the right answer.
>>>>>>
>>>>>
>>>>> *I have always been using this long before I read about it*
>>>>> blind variation and selective retention (BVSR)...
>>>>> Two common phenomena characterize BVSR thinking: superfluity and
>>>>> backtracking. Superfluity means that the creator generates a
>>>>> variety of ideas, one or more of which turn out to be useless.
>>>>
>>>> But if you have mo idea how things actually works, this seems to
>>>> just generate random noise.
>>>>
>>>>>
>>>>> Backtracking signifies that the creator must often return to an
>>>>> earlier approach after blindly going off in the wrong direction.
>>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>>
>>>>> *I am aware of no one else that had the idea to apply a simulating*
>>>>> *termination analyzer to the halting problem counter-example input*
>>>>> Professor Hehner had a seed of this idea before I did.
>>>>
>>>> Nope, I remember talk of that when I was in college, and they showed
>>>> why it can't work.
>>>>
>>>>>
>>>>> From a programmer's point of view, if we apply an interpreter to a
>>>>> program text that includes a call to that same interpreter with that
>>>>> same text as argument, then we have an infinite loop. A halting
>>>>> program
>>>>> has some of the same character as an interpreter: it applies to texts
>>>>> through abstract interpretation. Unsurprisingly, if we apply a halting
>>>>> program to a program text that includes a call to that same halting
>>>>> program with that same text as argument, then we have an infinite
>>>>> loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>
>>>> You THINK so, but if the interpreter is a CONDITIONAL interpreter,
>>>> that doesn't hold.
>>>>
>>>> You seem to miss that fact.
>>>>
>>>>>
>>>>> *Turing Machine and Olcott machine implementations seem to be dead*
>>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>>> Every machine must be able to get its own machine address.
>>>>>
>>>>
>>>> And the reason it is a dead end is they make it too hard for you to
>>>> cheat.
>>>>
>>>> You need to hide that your H is trying to get in some extra
>>>> information to hide that the embedded version of H doesn't give the
>>>> same answer, which just shows that your H^ is built wrong.
>>>
>>> My C code proves these two have different behavior:
>>> (a) H1(D,D) + H1_machine_address
>>> (b) H(D,D) + H_machine_address
>>> H1(D,D) does correctly determine the halt status of D(D) because
>>> H(D,D) does NOT correctly determine the halt status of D(D).
>>>
>>> I say:
>>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>
>>> immibis disagrees.
>>> Correct reasoning will show who is correct.
>>>
>>
>> Yes, and since H1 is a different computation than H, it getting the
>> right answer doesn't keep H from being broken.
>>
>> We can then make a D1 to break H1.
>>
>
> I think that immibis already said that and I did not notice
> the significance of it at the time.
>

Click here to read the complete article

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usm0jf$3e69n$1@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55224&group=comp.theory#55224

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 23:16:45 -0500
Organization: A noiseless patient Spider
Lines: 227
Message-ID: <usm0jf$3e69n$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0hh$34290$3@dont-email.me>
<usl0v5$347rv$2@dont-email.me> <usljui$385q4$2@dont-email.me>
<uslmh7$38jtu$2@dont-email.me> <IEtHN.366351$q3F7.176464@fx45.iad>
<uslqr6$3d3q7$1@dont-email.me> <usls1d$1enef$19@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 04:16:47 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3610935"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+m6+3cdASx88cSL7eeUAqS"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:XQoOORnyX1QBF7FySEA8ShaqdiY=
Content-Language: en-US
In-Reply-To: <usls1d$1enef$19@i2pn2.org>

by: olcott - Mon, 11 Mar 2024 04:16 UTC

On 3/10/2024 9:58 PM, Richard Damon wrote:
> On 3/10/24 7:38 PM, olcott wrote:
>> On 3/10/2024 9:04 PM, Richard Damon wrote:
>>> On 3/10/24 6:24 PM, olcott wrote:
>>>> On 3/10/2024 7:40 PM, immibis wrote:
>>>>> On 10/03/24 20:16, olcott wrote:
>>>>>> On 3/10/2024 2:09 PM, immibis wrote:
>>>>>>> On 10/03/24 19:32, olcott wrote:
>>>>>>>> On 3/10/2024 1:08 PM, immibis wrote:
>>>>>>>>> On 10/03/24 18:17, olcott wrote:
>>>>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>>>>>>>
>>>>>>>>> So you are saying that some Turing machines are not sound?
>>>>>>>>>
>>>>>>>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>>>>>>>> (a) Their input halts H.qy
>>>>>>>>>>>> (b) Their input fails to halt or has a pathological
>>>>>>>>>>>> relationship to itself H.qn.
>>>>>>>>>>>
>>>>>>>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>>>>>>>
>>>>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>>>>>>>> expressly disallowing the "Pathological Relationship".
>>>>>>>>>
>>>>>>>>> So you are saying that some Turing machines are not real Turing
>>>>>>>>> machines?
>>>>>>>>>
>>>>>>>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>>>>>>>> when their input halts and correctly say NOT YES otherwise.
>>>>>>>>>
>>>>>>>>> well the halting problem requires them to correctly say NO, so
>>>>>>>>> you haven't solved it
>>>>>>>>
>>>>>>>> All decision problem instances of program/input such that both
>>>>>>>> yes and no are the wrong answer toss out the input as invalid.
>>>>>>>>
>>>>>>>
>>>>>>> all decision problems are defined so that all instances are valid
>>>>>>> or else they are not defined properly
>>>>>>>
>>>>>>
>>>>>> Not in the case of Russell's Paradox.
>>>>>
>>>>> And now we are back to: Every Turing machine and input pair defines
>>>>> an execution sequence. Every sequence is either finite or infinite.
>>>>> Therefore it is well-defined and there is no paradox.
>>>>>
>>>>> Can you show me a Turing machine that specifies a sequence of
>>>>> configurations that is not finite or infinite?
>>>>
>>>> When we construe every yes/no question that cannot possibly
>>>> have a correct yes/no answer as an incorrect question
>>>>
>>>> then we must correspondingly construe every decider/input
>>>> pair that has no correct yes/no answer as invalid input.
>>>>
>>>
>>> And when you remember that when we posse that ACTUAL question, the
>>> input is a FIXED machine, (not a template that changes by the decide
>>> that it trying to decide it) then there are a LOT of machines that
>>> get the right answer. The key is we know that there is ONE that
>>> doesn't, the one that particular decider was built to foil. Thus, the
>>> problem isn't an invalid question.
>>
>>
>> In computability theory and computational complexity theory,
>> an undecidable problem is a decision problem for which it is
>> proved to be impossible to construct an algorithm that always
>> leads to a correct yes-or-no answer.
>> https://en.wikipedia.org/wiki/Undecidable_problem
>
> Right.
>
>>
>> If the only reason that a machine does not get a correct yes/no answer
>> for this machine/input pair is that both yes and no are the wrong answer
>> for this machine/input pair then this machine/input pair is a yes/no
>> question that has no correct yes/no answer for this machine/input pair.
>>
>> The exact same word-for-word question:
>> Are you a little girl?
>> Has a different meaning depending on who is asked.
>
> Right, but "Does this input describd a computation that Halts when Run?"
> ALWAYS has a correct answer,

*Only when we ignore who is being asked*

> when that input IS a computation, a
> SPECIFIC algorithm applied to a SPECIFIC input.
>

When every implementation of an algorithm gets the wrong answer
on some inputs then there is something wrong with the question.

> Nothing in that question refers to who it is being ask of.
>
Sure it does. It is asking everybody and no one always gets
the right answer.

> Note, Converting the input to a template that looks at the decider
> deciding on it, that IS an invalid input, and can't actually be build
> with a Turing Machine description as an input.
>

I don't know what you mean here.
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
The ⊢* specifies the infinite set of every implementation.

When none of them are correct on all inputs then there
is something wrong with the problem.

> Part of your problem is you have changed the problem because you don't
> understand it.
>
I am analyzing the problem from the point of view of its philosophical
foundation. Other people take the notion of undecidability as a "given"
truth never looking for any incoherence.

> H^ uses a SPECIFIC DEFINED H, the ONE machine this H^ is designed to
> foil. It doesn't change when you change the H looking at it.
>
When we toss out the whole notion of undecidability as incoherent
in the same way that ZFC tossed out the whole notion of self-referential
sets then the Halting Problem would be redefined to become decidable.

> There ALWAYS is a correct answer for that H^ (H^), it is just a fact the
> particular H it was built for will get it wrong.
>
There is never a correct answer for any Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩, thus the
question is an incorrect question for Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩.

> When you combine that with the fact that you can make a similar input
> for ANY machine that wants to try to claim to be a Halt Decider, and we
> end up not being able to have Halt Deciders.
>
Until we redefine its foundational framework the way that ZFC
did for Russell's Paradox.

>>
>> The exact same word-for-word question:
>> Does your input halt on its input?
>> Has a different meaning depending on who is asked.
>
> NOPE.
I already proved that both answers the H(D,D) provides
do not correspond to the behavior of D(D).

Thus for H(D,D) the question: Does your input halt?
has no correct YES or NO answer that corresponds to
the behavior of D(D), thus is an incorrect question
(by definition) for H(D,D).

When we ask any termination analyzer:
Will you halt if you never abort your simulation?
This different question always has a correct answer.
(at least for the pathological inputs).

>
> Because H^ (H^) Will always do the same thing no matter who you ask
> about it, because a given H^ (which is what the question is about) will
> ALWAYS use its one specific H and always do the same thing.
>

When we make an H that waits for three cycles then it correctly
decides this ⟨Ĥ⟩ ⟨Ĥ⟩ that knows to abort its simulation sooner.

>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> When every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is asked this question:
>> Does your input halt on its input?
>> It is an incorrect question.
>>
>
> What do you mean by "Every"?
>
Every element of the infinite set of all possible H that
is specified by the second ⊢*

> For any specific question, there is just one specific H^ with a specific
> operation and that H^ will always end up in qy or qn depending on
> exactly what the specific H it was built on does.
>
When none of them can possibly report on the actual behavior
of Ĥ ⟨Ĥ⟩ then there is something wrong with the question.

Click here to read the complete article

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior --RASP Machines--

<usm1ib$3ebq5$1@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55225&group=comp.theory#55225

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_--RASP_Machines--
Date: Sun, 10 Mar 2024 23:33:14 -0500
Organization: A noiseless patient Spider
Lines: 182
Message-ID: <usm1ib$3ebq5$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0u7$34bnj$1@dont-email.me>
<usljen$385ff$1@dont-email.me> <hItHN.366352$q3F7.153154@fx45.iad>
<uslrcc$3d3q0$1@dont-email.me> <uslsgn$1enef$20@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 04:33:15 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3616581"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18Tofp3cBabqGuYvPXCxiGW"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:BvgwLDz9vGVw7jHJQjnSS/ZW3VY=
Content-Language: en-US
In-Reply-To: <uslsgn$1enef$20@i2pn2.org>

by: olcott - Mon, 11 Mar 2024 04:33 UTC

On 3/10/2024 10:07 PM, Richard Damon wrote:
> On 3/10/24 7:47 PM, olcott wrote:
>> On 3/10/2024 9:08 PM, Richard Damon wrote:
>>> On 3/10/24 5:32 PM, olcott wrote:
>>>> On 3/10/2024 2:16 PM, immibis wrote:
>>>>> On 10/03/24 19:32, olcott wrote:
>>>>>> On 3/10/2024 1:08 PM, immibis wrote:
>>>>>>> On 10/03/24 18:17, olcott wrote:
>>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>>>>>
>>>>>>> So you are saying that some Turing machines are not sound?
>>>>>>>
>>>>>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>>>>>> (a) Their input halts H.qy
>>>>>>>>>> (b) Their input fails to halt or has a pathological
>>>>>>>>>> relationship to itself H.qn.
>>>>>>>>>
>>>>>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>>>>>
>>>>>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>>>>>> expressly disallowing the "Pathological Relationship".
>>>>>>>
>>>>>>> So you are saying that some Turing machines are not real Turing
>>>>>>> machines?
>>>>>>>
>>>>>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>>>>>> when their input halts and correctly say NOT YES otherwise.
>>>>>>>
>>>>>>> well the halting problem requires them to correctly say NO, so
>>>>>>> you haven't solved it
>>>>>>
>>>>>> All decision problem instances of program/input such that both
>>>>>> yes and no are the wrong answer toss out the input as invalid.
>>>>>
>>>>> I noticed that you gave up on Olcott machines and now you are back
>>>>> to your old bullshit ways of pretending that the same machine can
>>>>> produce two different execution traces on the same input. Why don't
>>>>> you show us an execution trace where that happens? Both traces must
>>>>> show the first instruction that is different in both traces and I
>>>>> recommend showing 20 more instructions after that, but you can
>>>>> abort one after that time, if it doesn't halt, to prevent the trace
>>>>> getting infinitely long.
>>>>
>>>> Turing Machines and Olcott machines cannot properly implement
>>>> H1(D,D) and H(D,D) that know their own machine address.
>>>>
>>>> My C code proves these two have different behavior:
>>>> (a) H1(D,D) + H1_machine_address
>>>> (b) H(D,D) + H_machine_address
>>>>
>>>> Because they are different computations they are
>>>> not required to have the same behavior.
>>>
>>> Right, but it also means that since the dfference is because of a
>>> "Hidden" input none of them qualify as a Halt Decider.
>>>
>>
>> The key input (the machines own address) is not hidden
>> merely unavailable to Turing machine and Olcott machines.
>
> And if it isn't hidden, then the other copies that take use a different
> address become different computations and can't claim to fill in for THE H.
>
> You then prove each copy wrong by giving it the version of H^/D that is
> built on it, which it will get wrong.
>
> All the other ones might get it right, showing that there IS a correct
> answer.
>
>>
>>>>
>>>> H(D,D) immediately sees the first time it calls itself
>>>> with its same inputs.
>>>>
>>>> H1(D,D) never sees it call itself with its same inputs.
>>>>
>>>> Full Execution trace of H1(D,D)
>>>> (a) main() invokes H1(D,D)
>>>> (b) H1(D,D) simulates D(D)
>>>> (c) Simulated D(D) calls simulated H(D,D)
>>>> (d) Simulated H(D,D) simulates another D(D)
>>>> (e) Simulated H(D,D) aborts this D(D) when it would call itself
>>>> (f) Simulated H(D,D) returns 0 to simulated caller D(D)
>>>> (g) Simulated caller D(D) returns to H1(D,D)
>>>> (h) H1(D,D) returns 1 to main()
>>>>
>>>> They cannot be implemented as Turing Machines or Olcott
>>>> Machines. They can be implemented as RASP machines proven
>>>> by the fact that they are implemented as C functions.
>>>>
>>>
>>> Right, which proves your C functions also were never the required
>>> computation, as they has an extra "hidden" input. As has been told to
>>> you many times in the past.
>>
>> When I specify that every machine can know its own machine address
>> in x86 machines and (possibly augmented) RASP machines then it is
>> not hidden and an explicitly part of the input to the computation.
>
> And if it isn't hidden, then the other copies that take use a different
> address become different computations and can't claim to fill in for THE H.
>
> You then prove each copy wrong by giving it the version of H^/D that is
> built on it, which it will get wrong.
>
> All the other ones might get it right, showing that there IS a correct
> answer.
>
>>
>>>
>>> So, you just admitted that you hae just been lying for all these
>>> years, and you are no closer to your fantasy goal then you ever were.
>>>
>>> Sorry, you just don't know enough to do this problem.
>>
>> I just admitted that it took me about two years to translate my
>> intuitions into words that address your objections.
>>
>> For these two years you and many other people claimed that H1(D,D)
>> could not possibly do what it actually did actually do. This has
>> always been the same thing as disagreeing with arithmetic.
>>
>
> It can't do it and be the SAME COMPUTATION as H, which is what you were
> claiming.
>

It did actually do exactly what I claimed and everyone wanted
to stick to their opinion and deny the actual facts that it
did actually do what I said.

> You are now admitting you were lying all that time, and really owe an
> appology to everyone yYOU said were lying when they were telling you
> they weren't the same computation.
>
I never ever lied about any of these things.
It took me a long time to get to closure because

I tolerated the [change the subject] form of
rebuttal that wasted 15 years with Ben Bacarisse.

Once I stopped tolerating this closure was achieved
on several points.

> Of course, since you now admit they are different, that means that H1
> can get H out of the jam. D will call the one instance of H, that one
> particular computation, that it is designed to make wrong, and since the
> other copies are different computations, they don't rescue that one, or
> even show that the question is subjective.

That they used their own machine address as part of their computation
was explicitly provided for years. Don't blame me for lying when the
real issue is that you didn't bother to pay attention.

H1: Begin Simulation Execution Trace Stored at:113095
*Address_of_H1:1442*
[00001d12][00113081][00113085] 55 push ebp ; begin D
[00001d13][00113081][00113085] 8bec mov ebp,esp
[00001d15][0011307d][00103051] 51 push ecx
[00001d16][0011307d][00103051] 8b4508 mov eax,[ebp+08]
[00001d19][00113079][00001d12] 50 push eax ; push D
[00001d1a][00113079][00001d12] 8b4d08 mov ecx,[ebp+08]
[00001d1d][00113075][00001d12] 51 push ecx ; push D
[00001d1e][00113071][00001d23] e81ff8ffff *call 00001542* ; call H(D,D)

H: Begin Simulation Execution Trace Stored at:15dabd
*Address_of_H:1542*
[00001d12][0015daa9][0015daad] 55 push ebp ; begin D
[00001d13][0015daa9][0015daad] 8bec mov ebp,esp
[00001d15][0015daa5][0014da79] 51 push ecx
[00001d16][0015daa5][0014da79] 8b4508 mov eax,[ebp+08]
[00001d19][0015daa1][00001d12] 50 push eax ; push D
[00001d1a][0015daa1][00001d12] 8b4d08 mov ecx,[ebp+08]
[00001d1d][0015da9d][00001d12] 51 push ecx ; push D
[00001d1e][0015da99][00001d23] e81ff8ffff *call 00001542* ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped (return 0 to caller)

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Click here to read the complete article

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --new focus--

<usm1sg$3ebq5$2@dont-email.me>

copy mid

https://news.novabbs.org/devel/article-flat.php?id=55226&group=comp.theory#55226

copy link Newsgroups: comp.theory sci.logic

Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC_--new_focus--
Date: Sun, 10 Mar 2024 23:38:40 -0500
Organization: A noiseless patient Spider
Lines: 444
Message-ID: <usm1sg$3ebq5$2@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usks70$1enef$1@i2pn2.org>
<usktro$33lov$1@dont-email.me> <usl1c7$1enef$9@i2pn2.org>
<usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad>
<uslou1$390q2$1@dont-email.me> <uslpbr$1enef$17@i2pn2.org>
<uslu1i$3do6h$1@dont-email.me> <usm07p$1enef$21@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 04:38:40 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3616581"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19UnLSDCsdjzYCT47fUUvuH"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:iou0hs8+AP7u0Nwx5PT2pjGwlNI=
In-Reply-To: <usm07p$1enef$21@i2pn2.org>
Content-Language: en-US

by: olcott - Mon, 11 Mar 2024 04:38 UTC

On 3/10/2024 11:10 PM, Richard Damon wrote:
> On 3/10/24 8:33 PM, olcott wrote:
>> On 3/10/2024 9:13 PM, Richard Damon wrote:
>>> On 3/10/24 7:05 PM, olcott wrote:
>>>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>>>> On 3/10/24 6:00 PM, olcott wrote:
>>>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>>>> On 3/10/24 11:23 AM, olcott wrote:
>>>>>>>> On 3/10/2024 12:55 PM, Richard Damon wrote:
>>>>>>>>> On 3/10/24 10:17 AM, olcott wrote:
>>>>>>>>>> On 3/10/2024 12:08 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/10/24 9:52 AM, olcott wrote:
>>>>>>>>>>>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/10/24 7:28 AM, olcott wrote:
>>>>>>>>>>>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exact same objective criteria that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that they themselves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This means that they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exact same objective criteria that H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is not*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above is true no matter what criteria
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is used
>>>>>>>>>>>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who
>>>>>>>>>>>>>>>>>>>>>>>>>>> the subject is. They are objective. The
>>>>>>>>>>>>>>>>>>>>>>>>>>> answer to different people is the same answer
>>>>>>>>>>>>>>>>>>>>>>>>>>> if the criteria are objective.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck
>>>>>>>>>>>>>>>>>>>>>>>>>> in recursive
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus
>>>>>>>>>>>>>>>>>>>>>>>>>> never runs
>>>>>>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>> get stuck
>>>>>>>>>>>>>>>>>>>>>>>>>> in recursive because H does not copy its input
>>>>>>>>>>>>>>>>>>>>>>>>>> thus runs
>>>>>>>>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong
>>>>>>>>>>>>>>>>>>>>>>>>> that a dead monkey could do better. Write the
>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machine (not x86utm) code for Ĥ and I
>>>>>>>>>>>>>>>>>>>>>>>>> would show you.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified
>>>>>>>>>>>>>>>>>>>>>>>> facts*
>>>>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified
>>>>>>>>>>>>>>>>>>>>>>>> facts*
>>>>>>>>>>>>>>>>>>>>>>>> *In other words you are denying these verified
>>>>>>>>>>>>>>>>>>>>>>>> facts*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ
>>>>>>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ
>>>>>>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ does not halt
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> That's not a verified fact, that's just something
>>>>>>>>>>>>>>>>>>>>>>> you want to be true.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't
>>>>>>>>>>>>>>>>>>>>>>> halt. You see how stupid it is, to say that an
>>>>>>>>>>>>>>>>>>>>>>> infinite loop halts?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then
>>>>>>>>>>>>>>>>>>>>>>>> transitions to Ĥ.H
>>>>>>>>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE
>>>>>>>>>>>>>>>>>>>>>>> IT IS PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>>>>>>>>>>> > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩
>>>>>>>>>>>>>>>>>>>>>>> to repeat the process
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *Yes and the key step of copying its input is left
>>>>>>>>>>>>>>>>>>>>>> out so*
>>>>>>>>>>>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> never runs out of params*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> that isn't how any of this works. Do you even know
>>>>>>>>>>>>>>>>>>>>> what words mean?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to
>>>>>>>>>>>>>>>>>>>> Ĥ.H
>>>>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one
>>>>>>>>>>>>>>>>>>>> more execution
>>>>>>>>>>>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>>>>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>>>>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>>>>>>>>>>>> The algorithm of H begins a simulation of its input,
>>>>>>>>>>>>>>>>>>> watching the behaior of H^ (H^)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (c) = (2)
>>>>>>>>>>>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>>>>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>>>>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the
>>>>>>>>>>>>>>>>>>> simulation of its input ...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> and so on.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes, the top level H is farther along at any given
>>>>>>>>>>>>>>>>>>> time then its simulated machine, and that is H's
>>>>>>>>>>>>>>>>>>> problem, it has to act before it sees how its
>>>>>>>>>>>>>>>>>>> simulation will respond to its copy of its actions.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus, if it stops, it needs to make its decision
>>>>>>>>>>>>>>>>>>> "blind" and not with an idea of how the machine it is
>>>>>>>>>>>>>>>>>>> simulating will perform.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If it doesn't stop, the level of recursion just keeps
>>>>>>>>>>>>>>>>>>> growing and no answer ever comes out.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to
>>>>>>>>>>>>>>>>>> abort
>>>>>>>>>>>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>>>> begin
>>>>>>>>>>>>>>>>>> its simulation. Right before its cycle repeats the
>>>>>>>>>>>>>>>>>> first time.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If it DOES abort there, then so will H^.H when it gets
>>>>>>>>>>>>>>>>> to that point in its simulation, which will be AFTER
>>>>>>>>>>>>>>>>> The point that H has stopped simulating it, so H
>>>>>>>>>>>>>>>>> doesn't know what H^ will do.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus, if H DOES abort there, we presume from your
>>>>>>>>>>>>>>>>> previous answer it will think the input will not halt
>>>>>>>>>>>>>>>>> and answer qn.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And if it does, as I said below, so will H^.H when it is
>>>>>>>>>>>>>>> run.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And thus, H^.H will give the same answer as H,
>>>>>>>>>>>>> so H^ will act contrary to what H says,
>>>>>>>>>>>>> so H will give the wrong answer.
>>>>>>>>>>>>
>>>>>>>>>>>> Unlike anything else that anyone else has ever done both H
>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort
>>>>>>>>>>>> their own
>>>>>>>>>>>> simulation to prevent their own infinite execution.
>>>>>>>>>>>
>>>>>>>>>>> NOPE.
>>>>>>>>>>
>>>>>>>>>> If no source can be cited then the Olcott thesis
>>>>>>>>>> "that no one did this before" remains unrefuted.
>>>>>>>>>
>>>>>>>>> Since, BY THE DEFINITIONS of what H MUST do to be correct, and
>>>>>>>>> what H^ WILL do by its design, as shown in the Linz Proof.
>>>>>>>>
>>>>>>>> If no source can be cited that shows a simulating halt decider can
>>>>>>>> correctly determine that it must abort its simulation of the
>>>>>>>> Halting
>>>>>>>> Problem's pathological input to prevent its own non-termination,
>>>>>>>> then
>>>>>>>> innovation remains attributable to me.
>>>>>>>>
>>>>>>>> <snip>
>>>>>>>
>>>>>>> Of course it can abort its simulation.
>>>>>>>
>>>>>>> It just needs some way to get the right answer.
>>>>>>>
>>>>>>
>>>>>> *I have always been using this long before I read about it*
>>>>>> blind variation and selective retention (BVSR)...
>>>>>> Two common phenomena characterize BVSR thinking: superfluity and
>>>>>> backtracking. Superfluity means that the creator generates a
>>>>>> variety of ideas, one or more of which turn out to be useless.
>>>>>
>>>>> But if you have mo idea how things actually works, this seems to
>>>>> just generate random noise.
>>>>>
>>>>>>
>>>>>> Backtracking signifies that the creator must often return to an
>>>>>> earlier approach after blindly going off in the wrong direction.
>>>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>>>
>>>>>> *I am aware of no one else that had the idea to apply a
>>>>>> simulating* *termination analyzer to the halting problem
>>>>>> counter-example input*
>>>>>> Professor Hehner had a seed of this idea before I did.
>>>>>
>>>>> Nope, I remember talk of that when I was in college, and they
>>>>> showed why it can't work.
>>>>>
>>>>>>
>>>>>> From a programmer's point of view, if we apply an interpreter to a
>>>>>> program text that includes a call to that same interpreter with that
>>>>>> same text as argument, then we have an infinite loop. A halting
>>>>>> program
>>>>>> has some of the same character as an interpreter: it applies to texts
>>>>>> through abstract interpretation. Unsurprisingly, if we apply a
>>>>>> halting
>>>>>> program to a program text that includes a call to that same halting
>>>>>> program with that same text as argument, then we have an infinite
>>>>>> loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>>
>>>>> You THINK so, but if the interpreter is a CONDITIONAL interpreter,
>>>>> that doesn't hold.
>>>>>
>>>>> You seem to miss that fact.
>>>>>
>>>>>>
>>>>>> *Turing Machine and Olcott machine implementations seem to be dead*
>>>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>>>> Every machine must be able to get its own machine address.
>>>>>>
>>>>>
>>>>> And the reason it is a dead end is they make it too hard for you to
>>>>> cheat.
>>>>>
>>>>> You need to hide that your H is trying to get in some extra
>>>>> information to hide that the embedded version of H doesn't give the
>>>>> same answer, which just shows that your H^ is built wrong.
>>>>
>>>> My C code proves these two have different behavior:
>>>> (a) H1(D,D) + H1_machine_address
>>>> (b) H(D,D) + H_machine_address
>>>> H1(D,D) does correctly determine the halt status of D(D) because
>>>> H(D,D) does NOT correctly determine the halt status of D(D).
>>>>
>>>> I say:
>>>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>
>>>> immibis disagrees.
>>>> Correct reasoning will show who is correct.
>>>>
>>>
>>> Yes, and since H1 is a different computation than H, it getting the
>>> right answer doesn't keep H from being broken.
>>>
>>> We can then make a D1 to break H1.
>>>
>>
>> I think that immibis already said that and I did not notice
>> the significance of it at the time.
>>
>
> Of course.
>
>> Then we are back to undecidability being incorrectly construed
>> as an actual limit to computation.
>
> Strange definition of not an actual limit if not being able to do
> something isn't a limit.
>
>>
>> Professor's Hehner and Stoddart have only construed this as
>> applying to the Halting Problem's pathological input.
>>
>> We three perfectly agree on this as it pertains to the
>> Halting Problem.
>>
>> That two full PhD professors of computer science and I all
>> agree on this shows that I am not a crackpot/crank on this.
>> I think that all of the other options may now be exhausted.
>>
>> I am very happy that I quit tolerating the [change the subject]
>> form of rebuttal that wasted 15 years with Ben Bacarisse.
>>
>> *The focus now must be on finding the best words that prove*
>> *this original position of mine (thus the concurring positions*
>> *of professors Hehner and Stoddart) is correct*
>
> Go knock yourself out on that.
>
>>
>> Alan Turing's Halting Problem is incorrectly formed (PART-TWO) sci.logic
>> On 6/20/2004 11:31 AM, Peter Olcott wrote:
>> > PREMISES:
>> > (1) The Halting Problem was specified in such a way that a solution
>> > was defined to be impossible.
>
> Nope.
>
> The PROBLEM is the question if a machine can compute the Halting Function.
>
> The answer to that, has turned out to be NO.
>
> When the problem was first being posed, it was hoped the answer woudl be
> yes, so it couldn't have bee made specifically to make it impossible.
>
>
> The Halting QUESTION, has an answer for every input that it the
> description of an actual algorithm applied to an actual data input.
>
> Note, Not a "Template" that gets appled to the decider, that IS an
> invalid question, and impossible to build a description of a Turing
> Machine to ask that.
>
> Thus, when you admitted that your input wasn't actually a description of
> a program, but just a template, you were admitting that you were lying
> about working on the Halting Problem, as your input isn't of the right
> type.
>
> Yes, asking about a template IS an invalid question.
>
>> >
>> > (2) The set of questions that are defined to not have any possible
>> > correct answer(s) forms a proper subset of all possible questions.
>> > …
>
> And, when you are asking the actual Halting Question, about a specific
> machine and input, like a SPECIFIC H^, built to foil a SPECIIFIC H, then
> that input has a specific and definate behavior and there is a specific
> and definate answer (That depends on the H that you chose to build it
> on, but not the decider you are asking the question to).
>
>> > CONCLUSION:
>> > Therefore the Halting Problem is an ill-formed question.
>> >
>
> Nope, as explained above. You are just showing that you never understood
> the actual question or what any of the theory actually means, and have
> just wasted the last decades of your life on a stupid misconception of
> your own.
>
>> USENET Message-ID:
>> <kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>
>>
>> *Direct Link to original message*
>> http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+

Click here to read the complete article

devel / comp.theory / Re: H(D,D)==0 is correct when reports on the actual behavior that it sees

Pages:1 2 345 6 7 8 9 10 11 12 13

server_pubkey.txt

rocksolid light 0.9.81
clearnet tor