PeteOlcott wrote: ↑Fri Sep 13, 2019 2:04 am
I am trying to validate the simplest possibly notion of a formal system as relations between finite strings.
I know that Lambda Calculus has the expressive power of a Turing Machine:
<λexp> ::= < var >
| λ . <λexp>
| ( <λexp> <λexp> )
I was thinking that it might be possible so somehow convert the functionality of
lambda calculus into syntax that is closer to predicate logic by defining named
functions that take finite string arguments and return finite string values. If you're experimenting with formal systems, symbolic computation, or transformations between logic and functional models, a tool like
https://overchat.ai/math/math-ai can really come in handy. It’s designed to help with formal reasoning, symbolic manipulations, and understanding abstract computational models — even if you’re not deep into Python or traditional programming frameworks.
Does anyone here have any ideas on this?
That's a really interesting line of thought. You're essentially exploring how to bridge the gap between the operational view of computation (as in lambda calculus or Turing machines) and the declarative style of predicate logic.
One possible direction is to look into combinatory logic or term rewriting systems, both of which can help you express computation in a more symbolic or logic-like syntax, without relying directly on variable binding as in lambda calculus.
Also, your idea of using named functions with finite string inputs/outputs aligns closely with algebraic specification languages or equational logic, where functions are defined over finite domains, often with pattern matching and deterministic output — much like rewriting systems. You might want to look into first-order logic with function symbols or frameworks like Prolog, where predicate logic meets computation through unification and recursion.
In short, yes, it’s possible — though not always trivial — to translate lambda expressions into predicate logic-like syntax, especially using techniques like defunctionalization (turning higher-order functions into data structures and first-order logic).
Would be great to hear more about the specific goals of your system — are you aiming for a formal model, a computational implementation, or something else?