0
$\begingroup$

The simplest example of a non-terminating reducible expression is ((λx. x x) (λx. x x)), which $\beta$-reduces to itself in one step and is therefore non-terminating.

This also highlights a class of non-terminating redexes: those that $\beta$-reduce to themselves in one step obviously do not terminate.

But I am interested in the determining whether this process ever ends for any arbitrary redex ((λx.y) z).

Do all non-terminating redexes eventually reach a point where they $\beta$-reduce to themselves in one step, or are there other classes of non-terminating redexes as well?

Specifically, I am looking for general properties that all non-terminating redexes have in common, even if the property is not exclusive to non-terminating redexes; e.g., is the argument, z, always an abstraction for non-terminating redexes?

1 Answers 1

1

Computational capabilities of lambda calculus are the same to capabilities of Turing machines, i.e. we can perform beta reduction using Turing machine and also we can simulate Turing machine with some lambda expression. Therefore if it is possible to determine if beta reduction terminates, we can translate an arbitrary Turing machine to lambda expression and check if beta reduction terminates which is equivalent to halting problem. So if by words “determining if beta reduction terminates” you mean building an algorithm for Turing machine to determine in finite amount of time if beta reduction terminates, the answer would be it is impossible.

  • 0
    Artem, thanks for the answer. I've edited my question to clarify: I'm not trying to determine, *precisely*, whether or not a beta reduction terminates. Rather, I am looking for *general properties that all non-terminating redexes have in common*, even if those properties are *not exclusive* to non-terminating redexes. My motivation here being to mark as illegal all expressions that are *possibly* non-terminating for a project I'm working on. But I'd like to limit the number of false positives to as few as possible. – 2018-10-17
  • 0
    Well, no matter what you do, there will be countably infinitely many false positives, because otherwise it would be possible to solve halting problem. – 2018-10-18
  • 0
    I'm aware that there will be infinitely many false positives, but that doesn't change the nature of my question: I'd still like to narrow the scope of false positives as much as possible. E.g., "redexes whose arguments are abstractions" is a much narrower scope than "all redexes". – 2018-10-18
  • 0
    The problem is that no matter how much you improve your criterion, there is always a way to make it a little better and make a little less false positives, but there will be still infinitely many of them. Also the problem is, how do you compare two criterions which have different false positives, and false positives of one of them are not a subset of false positives of another one? They both have the same cardinality of false positives and there is no obvious way to tell which false positives are "more negligible". – 2018-10-18
  • 0
    *Any* criterion is better than none. At the moment, I'm really just looking for anything narrower than "all redexes". – 2018-10-18
  • 0
    "All redexes that don't become irreducible after 1337 steps of normal order reduction", or $n$ steps for some $n \in \mathbb{N}$ what about this criterion? – 2018-10-18
  • 0
    that is indeed an idea, but I'd be more interested a simpler properties that I can derive from the structure of the redex itself, rather than actually spending time brute-forcing the evaluation before giving up after a certain number of steps. In other words, I am more interested in properties that aren't computationally expensive to calculate. – 2018-10-18
  • 0
    In other words, I'm looking for a property along the lines of: "if the redex does not match such and such *grammar*, then it could be non-terminating" – 2018-10-18