in the lambda calculus with products and sums is $f : [n] \to [n]$ $\beta\eta$ equivalent to $f^{n!}$?

$ \eta$ -reduction is often described as arising from the desire for functions which are point-wise equal to be syntactically equal. In a simply typed calculus with products it is sufficient, but when sums are involved I fail to see how to reduce point-wise equal functions to a common term.

For example, it is easy to verify that any function $ f: (1+1) \to (1+1)$ is point-wise equal to $ \lambda x.f(fx)$ , or more generally $ f$ is point-wise equal to $ f^{n!}$ when $ f: A \to A$ and $ A$ has exactly $ n$ inhabitants. Is it possible to reduce $ f^{n!}$ to $ f$ ? If not, is there an extension of the simply typed calculus which allows this reduction?

What’s the difference between phi and lambda in regular expression?

I’ve been learning on Formal Languages and Automata of Peter Linz(6th edition).

in the chapter 3 of this book, it explains the primitive regular expression.

but I don’t know what is the difference between $ \phi$ and $ \lambda$ .

of course, I know $ \lambda$ means the empty string, so that $ \lambda s=s\lambda$ .

and the textbook explains the meaning of $ \phi$ is the empty set.

and more, the textbook explains that $ \phi$ can be accepted by a deterministic finite automata $ \left< Q, \Sigma, \delta, q_0 , F \right>$ in which $ Q=\{ q_0, q_1 \}$ , $ \forall a \in \Sigma:\delta(q_0,a)\text{ is not defined}$ , and $ F=\{q_1\}$ .

so, I guess the meaning of the $ \phi$ is the rejected string.

but How can the expression $ (\phi *)*$ mean $ \lambda$ ?

and what’s the meaning of the expression $ a\phi$ ?

Is $\Gamma \vdash x x : T$ possible in the simply typed lambda calculus?

Is $ \Gamma \vdash x x : T$ possible?

This problem appears on page 104 of Benjamin Pierce’s “Types and Programming Languages”.

My conclusion is that it is was the case then we would get $ x: T_1 \to T_2$ and $ x: T_1$ and by some axiom, these types are not equal.

The problem is identifying this axiom but I fear it might be possible to have this equality…

Any hints?

Is it possible to deduce type from the lambda form?

I was continuing the exploration of lambda world this summer. When I take a look at the simply typed lambda calculus, it looks like there is no use for usual chuch numerals and boolean forms anymore. If types are declared in the environment, how would you actually implement it without referring to the internal types of the implementing language?

Other way of asking it is that if the application ((L x:int x) 1) is replaced with a chuch numeral instead of 1, how would it be possible to determine, if the chuch number is int indeed?

Converting Lambda Calculus functionality to predicate logic syntax

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.

Does anyone here have any ideas on this?

Does type-1 lambda calculus exist?

I’m interested in the intersection of linguistics and computer science, I’ve been reading on Chomsky hierarchy, and would like to know if there exist lambda calculus types that are equivalent to the Chomsky types, especially the type-1 that’s context-sensitive and has the linear-bounded non-deterministic Turing machine as an automation equivalent on the wiki.

MN Lambda student here

Good morning, all! I'm a stay-at-home dad from the balmy state of Minnesota. I'm currently attending Lambda School's Frontend WebDev program, and loving it. I'm an avid reader, movie buff, video game lover, and comic fanatic. I worked as a website support specialist for an ISP some 20+ years ago. Now that my kiddo is school age, I figured I'd delve officially back into my burgeoning love for coding. I'm excited to be a part of this community and can't wait to interact with you all!