From Newsgroup: comp.theory

consider:

hw = () -> output "hello world" // not depends on 𝓱p(m)

und_𝓱p = () -> 𝓱p(und_𝓱p) ? loop : halt // depends on 𝓱p(m)->false

S2 = () -> {
und_𝓱p()
hw()
}

and expand it:

S2 = () -> {
und_𝓱p = 𝓱p(und_𝓱p) ? loop : halt
und_𝓱p()
hw()
}

so we can run 𝓱p(und_𝓱p) to get false, but does that mean we're stuck
on figuring out what und_𝓱p does *within the context of S2*? no, we can inject the false value in for 𝓱p(und_𝓱p) to get a functionally equivalent machine:

S2' = () -> {
und_𝓱p' = false ? loop : halt
und_𝓱p'()
hw()
}

now when we run 𝓱p(und_𝓱p') we get true, and when we run 𝓱p(hw) we also get true, so therefore 𝓱p(S2')->true` and therefore 𝓱p(S2)->true.

i'm starting to think this line was maybe an error:

> if this were not true then wrapping unrecognizable machines by a
trivially decidable wrapper (like what S2 does) would allow for
recognizing machines with 𝓱p, that are not recognizable to 𝓱p, and
that would surely lead to a contradiction.

maybe trivially wrapping unrecognizable machines does allow for
*effective* halting recognition? like for every halting machine where 𝓱p(m)->false there exists a wrap(m) where

// returns technically a different machine because
// of the excess state transition at the end
wrap = (m) ->
() -> { m(); noop }

such that 𝓱p(wrap(m))->true

i mean technically wrap(m) and m are different machines with different
values, so why can't they have different outputs from 𝓱p? and while
this paradigm may *effectively* solve the halting problem, it cannot
produce a true total halting decider as 𝓱p(m)->false still for some
halting machines where it cannot return true because of direct
paradoxical dependencies.

in my previous comment i had just assumed this would lead a
contradiction ... so my question to you is can we actually produce a contradiction with wrap(m) paradigm? or maybe can we prove it immune to contradiction?

https://www.reddit.com/r/logic/comments/1wzkua3/on_an_attempt_to_limit_undecidability_within/pfeim8r/?context=10000

https://archive.ph/jgCPq
--
arising us out of the computing dark ages,
please excuse my pseudo-pyscript,
~ the lil crank that could

--- Synchronet 3.22a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/12/2026 1:38 AM, dart200 wrote:

consider:

Is this a wrap?

You cross-posted to alt.buddha.short.fat.guy! For God's sake what were
you thinking?

Mainstream Jewish organizations and Reform do not consider Messianic
Judaism to be a legitimate form of Judaism!

They view the belief in Jesus as incompatible with Judaism and
frequently describe the movement as a form of Christianity cult that
uses Jewish symbols to convert Jews.

Jesus! Are you nuts? There are no Buddhas on this list!

  hw     = () -> output "hello world"      // not depends on 𝓱p(m)

  und_𝓱p = () -> 𝓱p(und_𝓱p) ? loop : halt // depends on 𝓱p(m)->false

  S2 = () -> {
    und_𝓱p()
    hw()
  }

and expand it:

  S2 = () -> {
    und_𝓱p = 𝓱p(und_𝓱p) ? loop : halt
    und_𝓱p()
    hw()
  }

so we can run 𝓱p(und_𝓱p) to get false, but does that mean we're stuck on
figuring out what und_𝓱p does *within the context of S2*? no, we can inject the false value in for 𝓱p(und_𝓱p) to get a functionally equivalent machine:

  S2' = () -> {
    und_𝓱p' = false ? loop : halt
    und_𝓱p'()
    hw()
  }

now when we run 𝓱p(und_𝓱p') we get true, and when we run 𝓱p(hw) we also
get true, so therefore 𝓱p(S2')->true` and therefore 𝓱p(S2)->true.

i'm starting to think this line was maybe an error:

; if this were not true then wrapping unrecognizable machines by a

trivially decidable wrapper (like what S2 does) would allow for
recognizing machines with 𝓱p, that are not recognizable to 𝓱p, and that
would surely lead to a contradiction.

maybe trivially wrapping unrecognizable machines does allow for
*effective* halting recognition? like for every halting machine where 𝓱p(m)->false there exists a wrap(m) where

  // returns technically a different machine because
  // of the excess state transition at the end
  wrap = (m) ->
    () -> { m(); noop }

such that 𝓱p(wrap(m))->true

i mean technically wrap(m) and m are different machines with different values, so why can't they have different outputs from 𝓱p? and while this paradigm may *effectively* solve the halting problem, it cannot produce
a true total halting decider as 𝓱p(m)->false still for some halting machines where it cannot return true because of direct paradoxical dependencies.

in my previous comment i had just assumed this would lead a
contradiction ... so my question to you is can we actually produce a contradiction with wrap(m) paradigm? or maybe can we prove it immune to contradiction?

https://www.reddit.com/r/logic/comments/1wzkua3/ on_an_attempt_to_limit_undecidability_within/pfeim8r/?context=10000

https://archive.ph/jgCPq

--- Synchronet 3.22a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/12/26 10:23 AM, Dude wrote:

On 10/12/2026 1:38 AM, dart200 wrote:

consider:

Is this a wrap?

i can only keep 🙏 u might be stop being such a damn dud dude

You cross-posted to alt.buddha.short.fat.guy! For God's sake what were
you thinking?

Mainstream Jewish organizations and Reform do not consider Messianic
Judaism to be a legitimate form of Judaism!

They view the belief in Jesus as incompatible with Judaism and
frequently describe the movement as a form of Christianity cult that
uses Jewish symbols to convert Jews.

Jesus! Are you nuts? There are no Buddhas on this list!

   hw     = () -> output "hello world"      // not depends on 𝓱p(m)

   und_𝓱p = () -> 𝓱p(und_𝓱p) ? loop : halt // depends on 𝓱p(m)->false

   S2 = () -> {
     und_𝓱p()
     hw()
   }

and expand it:

   S2 = () -> {
     und_𝓱p = 𝓱p(und_𝓱p) ? loop : halt
     und_𝓱p()
     hw()
   }

so we can run 𝓱p(und_𝓱p) to get false, but does that mean we're stuck >> on figuring out what und_𝓱p does *within the context of S2*? no, we
can inject the false value in for 𝓱p(und_𝓱p) to get a functionally
equivalent machine:

   S2' = () -> {
     und_𝓱p' = false ? loop : halt
     und_𝓱p'()
     hw()
   }

now when we run 𝓱p(und_𝓱p') we get true, and when we run 𝓱p(hw) we >> also get true, so therefore 𝓱p(S2')->true` and therefore 𝓱p(S2)->true. >>
i'm starting to think this line was maybe an error:

  > if this were not true then wrapping unrecognizable machines by a
trivially decidable wrapper (like what S2 does) would allow for
recognizing machines with 𝓱p, that are not recognizable to 𝓱p, and
that would surely lead to a contradiction.

maybe trivially wrapping unrecognizable machines does allow for
*effective* halting recognition? like for every halting machine where
𝓱p(m)->false there exists a wrap(m) where

   // returns technically a different machine because
   // of the excess state transition at the end
   wrap = (m) ->
     () -> { m(); noop }

such that 𝓱p(wrap(m))->true

i mean technically wrap(m) and m are different machines with different
values, so why can't they have different outputs from 𝓱p? and while
this paradigm may *effectively* solve the halting problem, it cannot
produce a true total halting decider as 𝓱p(m)->false still for some
halting machines where it cannot return true because of direct
paradoxical dependencies.

in my previous comment i had just assumed this would lead a
contradiction ... so my question to you is can we actually produce a
contradiction with wrap(m) paradigm? or maybe can we prove it immune
to contradiction?

https://www.reddit.com/r/logic/comments/1wzkua3/
on_an_attempt_to_limit_undecidability_within/pfeim8r/?context=10000

https://archive.ph/jgCPq

--
why are we god?
let's end war 🙃

--- Synchronet 3.22a-Linux NewsLink 1.2