## Want help with proving a calculus theory

Let $$f(x)$$ have a second derivative on the closed interval $$[-2,2]$$. If $$\left| f(x) \right| \le 1$$ and $$\frac{1}{2} (f^{\prime}(0))^2+f(0)^3>\frac{3}{2}$$ when $$-2\le x\le2$$, now I need to prove that there must be a point $$x_{0}$$ on the interval $$(-2,2)$$ such that $$f^{\prime \prime}\left(x_{0}\right)+3\left[f\left(x_{0}\right)\right]=0$$.

(Series[1/2 (f'[x])^2 + f[x]^3, {x, 0, 1}]) // FullSimplify  1/2 (Series[f'[x], {x, 0, 1}] // Normal)^2 + (Series[      f[x], {x, 0, 1}] // Normal)^3 // Expand  (Series[f''[x], {x, 0, 1}] // Normal)^2 + (3*Series[f[x], {x, 0, 1}] //      Normal)^2 // Expand 

The above code does not reveal the nature of the problem and solve it cleverly. What can I do to solve this problem?

## Lambda Calculus Conversion

How can I take a data type or function (eg fold, list, String, zip) and convert it to a lambda calculus expression (or how can it be expressed as a lambda expression)?
If sum computes a sum of all elements in a list and :t sum -> Num a => [a] -> a. How do I take this information to translate it to a lambda calculus expression? I have tried to find guides online but they just give me the answers. I want to know how to actually make the conversion/translation from a function to a lambda calculus expression.

​​

## How to simulate natural number in Pi Calculus

I have some questions about Pi Calculus:

How to simulate the natural numbers only with its primitives?

It’s possible simulate the if else clauses without the sum (+)?

A minimal and standart example would be interesting.

## Applied Pi calculus: Evaluation context that distinguishes replication with different restrictions

For an exercise, I need to find an evaluation context $$C[\_]$$ s.t. the transition systems of $$C[X]$$ and $$C[Y]$$ are different (=they are not bisimulation equivalent), where $$X$$ and $$Y$$ are the following processes:

$$X = ( \nu z) (!\overline{c}\langle z \rangle.0)$$ and $$Y= !((\nu z) \overline{c}\langle z \rangle.0)$$

Intuitively, the difference seems to be that in process $$X$$, all replications of the process output the same $$z$$ on channel $$c$$, while in process $$Y$$, all processes output a different $$z$$. Is this correct? And how could this be used to construct an evaluation context such that $$C[X] \neq C[Y]$$?

## Situation calculus: how to find pre-conditions in 15-puzzle game?

I have been working on finding the preconditions for a situation calculus example for some time now. This example is called the game "15-puzzle" where you can find a discription here https://en.wikipedia.org/wiki/15_puzzle.

The following fluents are given for this game:

at(x,y,z,s) // which means: there is a tile z at position x,y. free(x,y,s) // which means: position x,y is free. 

And now I have to find the preconditions for the following actions (movements):

move_up() move_down() move_left() move_right() 

I have tried really cumbersome solutions where I am sure that they are not correct. I would be very grateful if someone has the right approach for me!

## Lambda calculus without free variables is as strong as lambda calculus?

First question: How would one prove that by removing free (unbound) variables from lambda calculus, and allowing only bound variables, its power is not reduced (it is still Turing-complete) ?

Second question: Is the proposition given above really true? Is lambda calculus sans free variables really Turing-complete?

## What does Lambda Calculus teach us about data?

1. Can we generalize that data is just a suspended computation?
2. Is this true for other models of computation?
3. What books, or papers, one should read to better understand the nature of data and its relation to computation?

Some context: as a software developer, I got used to the concept of data so much that I never considered its true nature. I’d very much appreciate any references that could help me better understand the general connection between data and computation.

## Where is typed lambda calculus on the Chomsky hiererchy?

The functions definable in typed lambda calculus are the computable functions, for which idt is in turn possible to efine equivalences to the concepts of Turing machines, recursive enumerability and Type-0 grammars.

But what about typed lambda calculus — where on the Chomskian computability hierarchy are the functions definable by expressions of simply-typed lambda calculus?

Assuming that there is a natural way of transferring the idea of lambda-definability of a recursive function from untyped to simply-typed lambda calculus, along the lines of:

A $$k$$-ary number-theoretic function $$f$$ is simply-typed-lambda definable iff there is a simply typable $$\lambda$$-term $$P$$ such that for all $$x_1, \ldots x_k$$, where $$\underline{x}$$ is the encoding of $$x$$, $$P \underline{\vec{x}} =_\beta \underline{y} \text{ iff } f(\vec{x}) = y$$, if $$f(\vec{x})$$ is defined, and $$P$$ has no $$\beta$$-normal form othewise.

To make the bridge from functions to formal languages and the Chomsky hierarchy, I guess my question is:

Between which levels of the Chomsky hierarchy is the class of languages located such that $$L$$ is in the class iff there is a simply-typed-lambda-definable function $$f$$ such that $$f(w)$$ is defined if and only if $$w \in L$$?

Alternatively, are there other ways of building an correspondence between typed lambda calculus and formal languages or automata that makes it possible to locate it on the known computability scale in a meaningful way?

All I could find so far was about modifications of lambda calculus corresponding to certain types of grammars, or auotmata to recognize strings certain kinds of lambda expressions, but, surpisingly, nothing specifically about (Curry-style) typed lambda calculus.

## lambda calculus reduction: (((lambda f (lambda x (f x))) (lambda y (* y y))) 12)

given the input

(((lambda f (lambda x (f x))) (lambda y (* y y))) 12)

what does this step evaluate to: lambda x (f x)

I am trying to evaluate this and I have the following tree so far:

how do I evaluate this ? looking for guidance on what I might be doing wrong or how to proceed with this.

## Does the underlying computational calculus in type theories affect decidability?

I’m looking for a high-level explanation although if that isn’t possible or difficult, I’d prefer references to books/papers.

I understand that modern type theory is inspired by Curry-Howard correspondence. From the Wikipedia article on Curry-Howard correspondence:

The correspondence has been the starting point of a large spectrum of new research after its discovery, leading in particular to a new class of formal systems designed to act both as a proof system and as a typed functional programming language. … This field of research is usually referred to as modern type theory.

Looking at the various type theories proposed and under development, I have a few basic questions:

1. Most modern type theories marry a type system with lambda calculus. Are there examples where a type theory uses a computational calculus other than lambda calculus?

2. At a very high level, if every modern type theory is a bundle of a type system and a computational calculus and the computational calculus is turing-complete (like lambda calculus), does the computational calculus in any way affect the decidability of decision problems like type checking, type inference, etc.? (AFAIK modern type theories tweak the type system while keeping the associated turing-complete computational calculus intact and just tweaking the type system affects decidability of type checking, type inference, etc.)