ct.category theory – Is there an abstract proof of Kleene's Recursion Theorem in a written lambda calculation?

I have written a proof using the lambda functions that formalize the exposition of the statement and the proof of Kleene's recursion theorem in Michael Sipser's book "Introduction to Computing Theory". But my configuration is quite naive, so I wonder if there is a rigorous test published in a typed lambda calculus (in the sense of Lambek-Scott's book on categorical logic). If so, there would be a statement and proof of the Kleene recursion theorem in the corresponding Cartesian closed category.

amazon s3 – Lambda function to write in S3 – IAM policy to access S3

I want to write / read in a s3 cube using my lambda function written in python.

Here is my policy that grants read / write access that I still can not write to the S3 container


"Version": "2012-10-17",
"Declaration": [
            "Sid": "ConsoleAccess",
            "Effect": "Allow",
            "Action": [
"Resource": "*"
"Sid": "ListObjectsInBucket",
"Effect": "Allow",
"Action": "s3: ListBucket",
"Resource": [
"Sid": "AllObjectActions",
"Effect": "Allow",
"Action": "s3: * Object",
"Resource": [

Please, let me know what I'm missing in my policy

aws – Replace Gateway API headers with Lambda

Friends, the scenario is this: I need set dynamically the name of a file csv at Content-Disposition through Gateway API.
Currently I have a function that returns the corresponding body, but at the time of exporting it may not be able to replace the name of the csv.
It was inquired about the configuration of the integration.
There would be some way to replace with lambda the headers from to request | answer Configured in the Gateway API?

The code of my function in case I need it

const AWS = require (& # 39; aws-sdk & # 39;)

const docClient = new AWS.DynamoDB.DocumentClient ({region: & # 39; us-east-1 & # 39;})

exports.handler = async (event, context, callback) => {
if (typeof event.query.conversation_id === & # 39; undefined & # 39;) throws a new error (& # 39; Parameter: undefined [conversation_id]& # 39;)
if (typeof event.query.target === & # 39; undefined & # 39;) throws a new error (& # 39; Parameter: undefined [target]& # 39;)

var params = {
Name of the table: & # 39;& # 39 ;,
ExpressionAttributeValues: {
& # 39 ;: conversation_id & # 39 ;: event.query.conversation_id,
& # 39 ;: target & # 39 ;: event.query.target
KeyConditionExpression: & # 39; conversation_id =: conversation_id & # 39 ;,
FilterExpression: & # 39; conversation_id =: conversation_id and target =: target & # 39;

leave data = wait for new Promise ((solve, reject) => {
docClient.scan (params, function (err, data) {
yes (err) {
console.error (& # 39; Unable to query. Error: & # 39 ;, JSON.stringify (err, null, 2))
to refuse
} else {
console.log (& # 39; Query done correctly & # 39;)
solve (data)

let logs = data.Items
leave conversation = []
  let arrMessages = logs[0].messages
leave conv

for (be i = 0; i <logs.length; i ++) {
leave n = 0
let arrFound = arrMessages.find (function (element) {
n ++
return (element.from.type == & # 39; Agent & # 39;)

yes (arrFound) {
leave client = false
for (be j = n; j < arrMessages.length; j++) {
        if (arrMessages[j].from.type === 'Client') {
          cliente = true

      if (cliente) {
        conv = logs[i]

  const response = {}

  conv.mensajes.forEach(message => {
if (message.from && message.text && message.type == "Message" && message.from.type == "Agent") {

let clock = conv.timestamp
clock = new date (clock)
clock.setHours (clock.getHours () - 4)
leave date = watch
let hour = clock.getHours ()
leave min = clock.getMinutes ()
leave sec = clock.getSeconds ()
clock = time + & # 39;: & # 39; + min + & # 39;: & # 39; + sec
conversation.push['Agente', message.text.replace(/n/g, ''), clock, fecha])

if (message.from && message.text && message.type == "Message" && message.from.type == "Client") {

let clock = conv.timestamp
clock = new date (clock)
clock.setHours (clock.getHours () - 4)
leave date = watch
let hour = clock.getHours ()
leave min = clock.getMinutes ()
leave sec = clock.getSeconds ()
clock = time + & # 39;: & # 39; + min + & # 39;: & # 39; + sec
conversation.push['Cliente', message.text.replace(/n/g, ''), clock, fecha])

const body = conversation.map (interaction => interaction.juntar (& # 39 ;; & # 39;))
response.body = body
response.conversation_id = event.query.conversation_id
var res = {
StateCode: 200,
headers: {
& # 39; Type of content & # 39 ;: & # 39; text / csv & # 39 ;,
& # 39; Content-Disposition & # 39 ;: `attached; filename = $ {event.query.conversation_id} .csv`
body: response.body,
isBase64Encoded: true
callback (null, res)

Why $ v in C ^ 2 (D) cap C ( overline {D}) $ and $ Delta v = – lambda v $ in $ D $ implies $ v in C ^ 2 ( overline {D}) $

The real problem is to show that the problem pde, where $ v = 0 $ in $ partial D $ plus the previous hypothesis, it has a non-trivial solution only if $ lambda geq 0 $. Which is pretty trivial if you use one of Green's identities. But for that it is necessary that $ v in C ^ 2 ( overline {D}) $, and I do not see why that is true.

Amazon web services: call Kinesis Firehose vs Kinesis Stream directly from Lambda

I have a need where I wanted to send some data to S3 from lambda. The data that comes to Lambda comes from a Dynamodb transmission. Since, to push S3, the use of Firehose is considered better, since it groups and stores the data before pressing S3 and provides the retry strategy. Therefore, I am using Firehose instead of pushing directly to S3.

But I note that many people send data from Lambda to Kinesis Stream from where the data is sent to Kinesis Firehose instead of directly pushing Firehose from AWS Lambda. Is there any reason to do it this way? Any benefit? What are the drawbacks of pushing Kinesis Firehose directly?

functional analysis: the range of $ I – lambda A = C (E) $ if you do it for all positive $ lambda $ small enough, $ A $ is a Markov pre-generator.

Leave $ A $ be a Markov pre-generator, $ E $ A compact and complete space. That is to say, $ A $ It is a linear operator that satisfies:

$ D (A) $ It is dense in $ C (E) $

$ A1 = 0 $

For all $ f in D (A) $, $ underset {x in E} {min} (f (x) – lambda Af (x)) leq underset {x in E} {min} f (x) $

I want to show that if the range of $ I – lambda A $ is $ C (E) $ for sufficiently small positive $ lambda $, then this is true for everything positive $ lambda $. I know this is true and I tried to try it for the last half hour without luck. Thanks in advance.

Advantages of the Lambda calculation on the Turing machine and vice versa.

What kind of advantages does the Lambda calculation have on the Turing machine and vice versa?

Functional programming – It is Lambda Calculation purely syntactic.

I have been reading for a few weeks about the Lambda Calculus, but I have not yet seen anything that is materially different from the existing mathematical functions, and I want to know if it is just a question of notation or if there are any properties or rules created by the calculation axioms lambda that does not apply to all mathematical functions. So, for example, I read that:

"There may be anonymous functions" -> Lambda functions are not anonymous, they are only called lambda. It is allowed in mathematical notation to use the same variable for different functions if the name is not important. For example, the two functions in a Galois connection are often called both *

"Functions can accept functions as inputs" -> It is not new, you can do it with common functions.

"Functions are black boxes" -> Fair inputs and outputs are also valid descriptions of mathematical functions …

This may seem like a discussion or an opinion question, but I think there should be a "correct" answer to this question. I want to know if the lambda calculation is just a notational or syntactic convention for working with mathematical functions, or if there are substantial or semantic differences between common functions and lambdas.

Thank you!

Amazon web services: alternative to AWS Lambda + NAT gateway

Quick introduction to my scenario: I have a VPC that contains an API gateway that redirects its calls to my Lambda functions and then accesses an RDS instance and external API calls (Internet access).

How is structured

Due to the fact that the functions need to access the RDS, I put both RDS and Lambdas in the same VPC, properly securing the RDS without public access. Now, because the Lambdas are in a VPC, they need a NAT gateway to access the Internet (almost all those functions need to call third-party APIs), and this is where I face a huge problem.

The problem

I have a small project to serve a few users (from 10 to 200 users) and with the serverless configuration that I have created, I expect the costs to be from $ 3.00 to $ 10.00 each month. That is the cost without a single NAT gateway. Now, and if we add the price of a Gateway, which is $ 0.045 per hour – and I'm not even considering the $ 0.045 per GB of data transferred – that's > $ 30 per month. It would be foolish of me not to create another to be Multi-AZ and mitigate possible failures in the availability zone, so that > $ 60.00 for 2 NAT gateways.

This is not only impractical for me, but would it not also invalidate the point of the entire serverless structure that normally follows an on-demand approach?

How to solve this?

One of my alternatives is to remove the Lambda from the VPC (that is, not the VPC) and access the RDS through some mechanism without making it public, and this is where I am also failing, how could one access it safely? to the RDS in the Scenario where Lambda functions are outside the RDS VPC?

In the worst case, I know it's bad to expose my RDS to the public, but how big is the vulnerability that is exposing it?

Keep in mind that I am not blaming AWS prices, this only focuses on finding alternatives to the NAT Gateway. I appreciate the suggestions to solve this case. Also, I'm sorry that I made a totally wrong assumption, I'm new to the AWS ecosystem.

Do verifiers of dependent types need to store the type of lambda parameter in their primary language?

"Main language" refers to well-written terms that can be evaluated (or reduced).

In the central language of MiniAgda, a language of dependent type, the parameter type of a lambda is not stored anywhere. The same happens in Mini-TT and Agda.

However, Idris stores the type of lambda parameter in its central language.

I wonder if we need / do not need to store the type of parameter (or, under what condition do we need / do not need to store it)?

Proxy Sites Proxy Tunnels Proxy List Working Proxy Sites Hotproxysite Proxy Sites Proxy Sites Anonymous Proxy Anonymous Proxies Top-Proxies.co.uk http://www.proxysitesnow.com Proxy Servers Free Proxies Free Proxy List Proxy List Zoxy Proxy List PR liste all proxy sites More Proxies netgofree netgofree Hide-MyIp - The Best Proxy List American Proxy List www.proxylisty.com/proxylist Web Proxy Submit Proxies Updated Proxy List Updated Proxy List aproxy.org Bypass Proxy Sites Free Proxies List Evolving Critic Business Web Directory Free Proxy List iShortIt MyProxyList Online Proxies Go Proxies Need Proxies PrivateProxies Proxies4MySchool Proxies4Work Free Proxy List Free Proxy Sites ProxyInside Wiksa Proxy ProxyLister.org Free Proxy List ProxyNoid Proxy List Free Proxy List Proxy Sites Proxy TopList ProxyVille UK Proxy WebProxy List RatedProxy.com - Listing the best Web Proxies Free Proxy List SchoolProxiesList Stay Anonymous Proxy List The Power Of Ninja Proxy List UNubstruct Free proxy sites Free proxy sites