Online Store

Geometry.Net - the online learning center
Home  - Mathematical_Logic - Curry-howard Correspondence
Page 1     1-42 of 42    1 

1. Curry–Howard - Wikipedia, The Free Encyclopedia
More recently, extensions of the CurryHoward Correspondence have been formulated which handle classical logic as well, by relating classically valid rules
var wgNotice = ""; var wgNoticeLocal = ""; var wgNoticeLang = "en"; var wgNoticeProject = "wikipedia";
From Wikipedia, the free encyclopedia
(Redirected from Curry-Howard isomorphism Jump to: navigation search The Curry–Howard correspondence is the close relationship between computer programs and mathematical proofs; the correspondence is also known as the Curry–Howard isomorphism , or the formulae-as-types correspondence . A number of different formulations have been used, for a principle now identified as the independent discovery of the American mathematician Haskell Curry and logician William Alvin Howard The correspondence can be seen at two levels: firstly, that of an analogy , which states that the return type of a function (i.e., the type of values returned by a function) is analogous to a logical theorem, subject to hypotheses corresponding to the types of the argument values passed to the function; and that the program to compute that function is analogous to a proof of that theorem. In theoretical computer science , this is an important underlying principle connecting the adjacent areas of lambda calculus and type theory . It is often stated in the form proofs are programs . An alternate formulation is propositions as types . Secondly, and more formally, it specifies a formal isomorphism between two mathematical domains, that of

2. The Curry-Howard Correspondence In Haskell
The CurryHoward Correspondence is a mapping between logic and type systems. On the one hand you have logic systems with propositions and proofs.
The Curry-Howard Correspondence in Haskell
Tim Newsham
The Curry-Howard correspondence is a mapping between logic and type systems. On the one hand you have logic systems with propositions and proofs. On the other hand you have type systems with types and programs (or functions). As it turns out these two very different things have very similar rules. This article will explore the Curry-Howard correspondence by constructing a proof system using the Haskell type system (how appropriate since Haskell is named after Haskell Curry, the "Curry" in "Curry-Howard"). We'll set up the rules of logic using Haskell types and programs. Then we'll use these rules as an abstract interface to perform some logic profs.
Propositions and proofs
Propositions and proofs in logic systems correspond to types and programs (or functions) in programming languages. Each proposition will be represented by a type. Each proof will be represented with a program that has the matching type. The program need not do anything in particular. In fact, there may be many programs with the type we're after (just as there may be many proofs of a proposition). It doesn't matter. We just need to find a program with the given type. The existence of a program for the type will be a proof of the corresponding proposition! (Note: to be correct, the function must be total: it must terminate for all defined arguments. It's easy to cheat by using "undefined" in your proofs. In fact, this is a useful tool when debugging incomplete proofs). [

3. JSTOR Derivation And Computation. Taking The Curry-Howard
Despite the subtitle of the book, it is not clear to me just how we have taken the Curry Howard Correspondence seriously, and what it has gained us.<380:DACTTC>2.0.CO;2-A

4. Powell's Books - Cambridge Tracts In Theoretical Computer Science #51: Derivatio
Cambridge Tracts in Theoretical Computer Science 51 Derivation and Computation Taking the CurryHoward Correspondence Seriously. by Harold Simmons

5. The Curry-Howard Correspondence In Set Theory
The CurryHoward Correspondence between proofs and programs was originally discovered with the system of simple types, which uses the intuitionistic

6. Review Harold Simmons, Derivation And Computation. Taking The
Taking the CurryHoward Correspondence Seriously. Full-text Access via JSTOR (no additional login). Go to this article in JSTOR. Links and Identifiers
Log in RSS Title Author(s) Abstract Subject Keyword All Fields FullText more options

7. The Curry-Howard Correspondence
The CurryHoward Correspondence. Haskell Curry (1900-1982). Started studying medicine at Harvard in 1916; enlisted in the war on 18 October 1918
perl6.does(ML) How Type Theorists Saved the Perl 6 Project
The Curry-Howard correspondence
  • Started studying medicine at Harvard in 1916 enlisted in the war on 18 October 1918 inspired by a 1924 paper by M Schoenfinkel Ph.D in mathematics from Goettingen in 1930 wrote on Combinatory Logic from 1958-1980 taught at Harvard, Princeton, Pennsylvania State University, and the University of Amsterdam
continued... Index

8. - Derivation And Computation: Taking The Curry-Howard Correspondence Ser
Derivation and Computation Taking the CurryHoward Correspondence Seriously Derivation Systems, Substitution Algorithms, Computation Mechanisms Harold
My Account Wishlist Help All Departments ... Warranties Books by Title by Author by ISBN by Publisher
Save $30 Instantly with the Visa Card. Click here. Books Best-sellers New ... Rewards UpdateProductViewHistoryCookie('Derivation and Computation: Taking the Curry-Howard Correspondence Seriously: Derivation Systems, Substitution Algorithms, Computation Mechanisms','30776167');
Derivation and Computation: Taking the Curry-Howard Correspondence Seriously: Derivation Systems, Substitution Algorithms, Computation Mechanisms (Hardcover)
Author: Harold Simmons Product Image
Pricing Additional Info Price: Shipping: Total Price:
Ships from and sold by
What's this?
In Stock: Usually ships in 1 to 2 business days. Format: Hardcover Format: Hardcover ISBN: Publish Date: Publisher: Cambridge University Press Dimensions (in Inches) 9.5H x 6.5L x 1.25T Sku: More about this product Item#: View similar products Product Summary Reviews Introduction to simple type theory; 200 exercises with complete solutions.
ISBN: Publisher: Cambridge University Press
Write a Review
Be the first user to review this item Back to top

Every voice counts, so stand up and be heard! Your opinion is important to us. If you have spotted a typo, discovered an incorrect price, or encountered a technical issue on this page, we want to hear about it. Thanks again for your feedback, and happy shopping!

9. LtU Classic Archives
A gentle introduction to TLG, the CurryHoward Correspondence, and cut-elimination. Barker Chris. A gentle introduction to Type Logical Grammar,
Lambda the Ultimate
A gentle introduction to TLG, the Curry-Howard correspondence, and cut-elimination
started 10/11/2003; 2:58:16 AM - last post 10/16/2003; 5:44:29 PM Ehud Lamm - A gentle introduction to TLG, the Curry-Howard correspondence, and cut-elimination
10/11/2003; 2:58:16 AM (reads: 6300, responses: 6) A gentle introduction to TLG, the Curry-Howard correspondence, and cut-elimination Barker Chris. A gentle introduction to Type Logical Grammar, the Curry-Howard correspondence, and cut elimination This paper aims to give an introduction to Type Logical Grammar (TLG) for the general linguist who may not have a background in logic or proof theory. This paper will briefly describe the logical heritage of TLG, sketch a simple TLG analysis, convey the spirit of the Curry-Howard result, discuss Gentzen’s famous cut-elimination result, and motivate multimodal extensions of Lambek’s logic. A short introduction to some of the same topics discussed in Girard's book plus an introduction to Type Logical Grammar for those who are interested in linguistics.
Posted to theory by Ehud Lamm on 10/11/03; 2:59:14 AM

10. Hindley. Basic Simple Type Theory.
Using the CurryHoward Correspondence, this is seen to be related to Gentzen s We can show a Curry-Howard Correspondence between TA and intuitionist
The Omega Group TPS A higher-order theorem proving system This page was created and is maintained by Chad E Brown
J. Roger Hindley, Basic Simple Type Theory. Cambridge University Press, 1997.
Chapter 1: The type-free lambda calculus. Chapter 2: Assigning types to terms. Chapter 3: The principal-type algorithm. Chapter 4: Type assignment with equality. ... Chapter 9: Technical details. Introduction: This book studies the system TA (for "Type Assignment") which is lambda calculus (with variables but no constants) and types built from type variables and arrows. The main results discussed are the principal-type algorithm, the converse principal-type algorithm, and the inhabitant-counting algorithm. Chapter 1: The type-free lambda calculus. Lambda terms are built from term-variables by application and lambda abstraction. For each lambda term we have notions of length, subterms, occurrences, components, body, scope, covering abstractors (of a subterm [those abstractors which dominate the subterm]), free and bound non-binding variable-occurrences. We also have substitution, alpha-conversion, bound-variable clashes, and closed terms = combinators. The common combinators (including Curry's fixed point combinator Y) are given. Beta-contraction (one step of a beta-reduction), beta-reduction and beta-conversion are defined. The

11. Advogato: Blog For Chalst
Formulaeas-types Correspondence;; Curry-Howard Correspondence;; Curry-Howard isomorphism;. with the latter only under sufferance; also note that the phrase

12. Re: [Haskell-cafe] Tutorial: Curry-Howard Correspondence
Re Haskellcafe Tutorial Curry-Howard Correspondence. Dan Weston Thu, 18 Oct 2007 140343 -0700. The function needs to be total.
Re: [Haskell-cafe] Tutorial: Curry-Howard Correspondence
Dan Weston
Thu, 18 Oct 2007 14:03:43 -0700 Prop is not total, but thm2 is (if I am not mistaken) total. Every My (still hesitant) assertion is that the totality must be transitive to all sub-expressions for the function to be considered a valid proof. The easiest way to get Haskell to do this work for you is to make everything strict and just evaluate the function. Tim Newsham wrote: I'm fairly new to this and struggling to follow along so I might be a little off base here... I assume you mean then that it is a valid proof because it halts for *some* argument? Suppose I have: is the only value in every type), so thm1 is not a valid theorem. Now we reify our propositions (as the tutorial does) in a constructor: data Prop a = Prop a thm2 :: (Prop a -> Prop a) -> Prop a thm2 f = Prop undefined fix :: (p -> p) -> p fix f = let x = f x in x instance Show (Prop a) where show f = "(Prop <something>)" *Prop> :t thm2 thm2 :: (Prop a -> Prop a) -> Prop a *Prop> thm2 (fix id) (Prop <something>) Wow! thm2 halts. Valid proof. We have a "proof" (thm2 (fix id)) of a

13. Re: [Haskell-cafe] Tutorial: Curry-Howard Correspondence
the actual statement of the CurryHoward Correspondence, it s a. Correspondence between intuitionistic propositional logic and the simply search all groups... Home Join Log In Watch this thread FAQ h Re: [Haskell-cafe] Tutorial: Curry-Howard Correspondence
by Derek Elkins Reply to author Reply to group
On Wed, 2007-10-17 at 15:06 -0700, Dan Weston wrote: Yes it does. Yes it does. Terms in Haskell prove the propositions that the types of Haskell correspond to. *The logic that Haskell's type systems corresponds to is inconsistent.* This is what you are missing. Haskell's type systems does not correspond to intuitionistic propositional logic. Indeed, in the actual statement of the Curry-Howard correspondence, it's a correspondence between intuitionistic propositional logic and the simply typed lambda calculus which Haskell quite certainly is not. As is well known, it (CH) can be generalized beyond that, but generally you need a strongly normalizing language (or at least prove strong normalization for your particular term and note normalization means -normal form- not weak head normal form) to actually use the "programs" as proofs. Haskell-Cafe mailing list Haskell-Cafe@hask...

14. Programs From Proofs In Haskell
Programs from Proofs via the CurryHoward Correspondence This time I want to use it to explore the Curry-Howard Correspondence, which is the idea that
Haskell for Maths
Programs from Proofs via the Curry-Howard Correspondence
Last time we wrote a theorem prover for intuitionistic propositional logic. This time I want to use it to explore the Curry-Howard correspondence, which is the idea that propositions in logic are like types in functional programming. The basic correspondence goes like this: Proposition Type Implication
a->b Function
a->b Conjunction
Product type
(a,b) Disjunction
Sum type
Either a b (If this seems strange at first, think about it this way: The product type (a,b) is an a and a b. The sum type Either a b is an a or a b. The function type a->b means that if you give me an a, then I can give you back a b, so an a implies a b.) So far so good. But the Curry-Howard correspondence goes further. First of all, it says that if there is a Haskell function having a particular (polymorphic) type, then the corresponding proposition is provable in intuitionistic logic. For example: (In Hugs and GHCi, :t tells you the type of an expression. We find that the type of "fst" - when translated into a proposition using the Curry-Howard correspondence - is provable in intuitionistic logic.) A function of a given type is called an inhabitant of that type, and a

15. Curry–Howard Correspondence
The CurryHoward Correspondence is the Correspondence between the structure of proofs in logic, and the structure of computer programs.

16. CiteULike: Extended Curry-Howard Correspondence For A Basic Constructive Modal L
Extended CurryHoward Correspondence for a Basic Constructive Modal Logic title = {Extended Curry-Howard Correspondence for a Basic Constructive Modal
Register Log in FAQ
  • Search groups Profile Library Watchlist ... Import
    Extended Curry-Howard Correspondence for a Basic Constructive Modal Logic
    Online Article
    Note: You or your institution must have access rights to this article. CiteULike will not help you view an online article which you aren't authorized to view.
    Copy-and-Pasteable Citation
    Citation format: Plain APA Chicago Elsevier Harvard MLA Nature Oxford Science Turabian Vancouver
    vcvpaiva's tags for this article
    Other users who have posted this article
    Everyone's tags for this article
    Note: You may cite this page as: EndNote BibTeX
    vcvpaiva's tags
    All tags in vcvpaiva's library Filter: algebraic cat categorical combination ... sequent-calculus CiteULike organises scholarly (or academic) papers or literature and provides bibliographic (which means it makes bibliographies) for universities and higher education establishments. It helps undergraduates and postgraduates. People studying for PhDs or in postdoctoral (postdoc) positions. The service is similar in scope to EndNote or RefWorks or any other reference manager like BibTeX, but it is a social bookmarking service for scientists and humanities researchers.

17. The Curry-Howard Correspondence In Haskell - SWiK
Recent Edits for Userjerryk; Recent Edits for bookmarks; Recent Edits for The CurryHoward Correspondence in Haskell. created on 17 Oct 2007, bookmarks/The Curry-Howard Correspondenc
SWiK login / register changes) Return to bookmarks
The Curry-Howard Correspondence in Haskell
Your tags: or Cancel
Tags Applied to this Entry
1 person has tagged this page: haskell logic user:jerryk type-systems ... Recent Edits for The Curry-Howard Correspondence in Haskell created on 17 Oct 2007, by Syndication, About SWiK Random Project Recent Edits All original text is available as Creative Commons Attribution-ShareAlike Privacy Terms Credits Your SWiK user name A new account
Username: Password:
Remember me on this computer Take credit for any changes I made as an anonymous user (or Cancel
Username: Email:
Password: Verify:
Remember me on this computer Take credit for any edits made as an anonymous user (or Cancel

18. [Haskell-cafe] Tutorial: Curry-Howard Correspondence
Indeed, in the actual statement of the CurryHoward Correspondence, it s a Correspondence between intuitionistic propositional logic and the simply typed
[Haskell-cafe] Tutorial: Curry-Howard Correspondence
Derek Elkins derek.a.elkins at
Sun Oct 21 18:04:44 EDT 2007 That is a great tutorial. Thanks! But in the last two sentences of the introduction you say: Maybe you should make explicit that 1) the type is inhabited undefined :: forall p . p does not prove that all propositions are true 2) the function must halt for all defined arguments fix f = let x = f x in x does not prove the (false) theorem Yes it does. Terms in Haskell prove the propositions that the types of Haskell correspond to. *The logic that Haskell's type systems corresponds to is inconsistent.* This is what you are missing. Haskell's type systems does not correspond to intuitionistic propositional logic. Indeed, in the actual statement of the Curry-Howard correspondence, it's a correspondence between intuitionistic propositional logic and the simply typed lambda calculus which Haskell quite certainly is not. As is well known, it (CH) can be generalized beyond that, but generally you need a strongly normalizing language (or at least prove strong normalization for your particular term and note normalization means -normal form- not weak head normal form) to actually use the "programs" as proofs.

19. CSL/KGC'03 - Alexandre Miquel: A Strongly Normalising Curry-Howard Correspondenc
Alexandre Miquel A Strongly Normalising CurryHoward Correspondence for IZF Set Theory. Welcome and News. Host Institutions. Calls and Deadlines. Program

20. Words And Other Things: Making It Explicit: Logical Expressivism
As far as I can tell, getting a CurryHoward Correspondence for classical logic requires getting around to thinking about how to state the Correspondence
skip to main skip to sidebar
Words and Other Things
Trying to generate more light than heat since 2006
Friday, September 14, 2007
Making It Explicit: logical expressivism
There is nothing in Ch. 2, where logical expressivism is introduced, about quantifiers. At this point in the book, nothing has been said about objects, so I'm not sure what the quantifiers express since it is likely to be tied in with theoretical claims about objects. Modal operators aren't addressed in MIE, although they are tackled in the Locke Lectures. I don't remember that terribly well, although I think for the most part Brandom sticks to alethic modalities in S4 and S5. I could be wrong on this. I am almost positive he doesn't get to non-normal modal operators (to use Restall's terminology) such as the Kleene star. I currently have no idea what the Kleene star would express. I'm similarly unsure about intensional connectives as in relevant logic's fusion. It might be an interpretation similar to Restall's of application of data in the form of propositions to other data, although this is really speculative. There might be something in this.
Something that I'm a little more immediately curious about is the status of translations of formulas. There are certain systems of logic that can be translated into others, e.g. S4 into intuitionistic logic. The conditional in S4 is classical, but the translation (in Goedel's translation at least) of the intuitionistic A->B looks like [](A'->B') where A' and B' are the translations of A and B. The classical conditional then will express a weaker acceptance of an inference but it will be modified in some way by the necessity operator in front. If the view of logic is right, one would expect the translation to preserve what is expressed in some form. I will have to track down the relevant part of the Locke Lectures in order to further test this idea.

21. Workshop On Implicit Computational Complexity
Using the CurryHoward Correspondence, we focus on the use of ELL as type system for lambda calculus, and more precisely, on type inference.

22. Bibliography Of Hugo Herbelin
We interpret Gentzen s sequent calculus as a lambdacalculus, hence providing a Curry-Howard Correspondence for sequent calculus.
Research articles
"An approach to call-by-name delimited continuations" ACM for your personal use - not for redistribution) errata bibtex entry
Abstract: It has been shown by Saurin that de Groote's variant of Parigot's lambda-mu-calculus is strictly more expressive in the untyped case than Parigot's original calculus. We show that this additional expressivity exactly corresponds to adding delimited control so that de Groote's calculus can be seen as the exact call-by-name counterpart of Danvy and Filinski's shift-reset calculus. This "duality" is expressed in the lambda-mu-tp-hat-calculus which is lambda-mu-calculus equipped with a single dynamically-bound continuation variable denoting a resettable toplevel. An equational correspondence having already been proved in A type-theoretic foundation of delimited continuations for call-by-value lambda-mu-tp-hat and Danvy and Filinski's calculus, we simply show here the equivalence between call-by-name lambda-mu-tp-hat and de Groote's calculus. We continue with a comparative study of the operational semantics, continuation-passing-style semantics, and simple typing of both call-by-name and call-by-value versions. Finally, we show the existence of two other canonical calculus of delimited continuations. The first one morally forms an equational correspondance with Sabry's shift/lazy-reset calculus while the second one is a "lazy" version of de Groote's calculus.
"Control Reduction Theories: the Benefit of Structural Substitution",

23. Index
The original - calculus of Curien and Herbelin has a system of simple types, based on sequent calculus, embodying a Curry-Howard Correspondence with
Daniel J. Dougherty, Kathi Fisler, and Shriram Krishnamurthi. Obligations and their interaction with programs. In 12th European Symposium On Research In Computer Security (ESORICS) , volume 4734 of Lecture Notes in Computer Science , pages 375-389, September 2007. [ bib .pdf Obligations are pervasive in modern systems, often linked to access control decisions. We present a very general model of obligations as objects with state, and discuss its interaction with a program's execution. We describe several analyses that the model enables, both static (for verification) and dynamic (for monitoring). This includes a systematic approach to approximating obligations for enforcement. We also discuss some extensions that would enable practical policy notations. Finally, we evaluate the robustness of our model against standard definitions from jurisprudence. Daniel J. Dougherty, Claude Kirchner, Helene Kirchner, and Anderson Santana de Oliveira. Modular access control via strategic rewriting. In

24. Search Result
4, EE Alexandre Miquel A Strongly Normalising CurryHoward Correspondence for IZF Set Theory. CSL 2003 441-454 DBLPconf/csl/Miquel03

25. Plume Team
The CurryHoward Correspondence has been described in a precise way around 1980. It relates the lambda-calculus and minimal propositional logic,
Research interests of the Plume team include the semantics of programming languages and systems and formal proof. We are interested in formalisms (logics, operational and denotational semantics, proof techniques, ...) and in the application of formal methods (automated deduction, verification).
Main research topics
Programming languages semantics
Static and Dynamic modularity
We work on modularity features in programming languages, both at the static and dynamic levels, and we also consider the case of distributed systems. We say that a programming language supports static modularity if it allows flexible program construction from modules. It supports dynamic modularity if it maintains a modular structure at runtime, and provides reflexive operators, e.g., for dynamic reconfiguration and update.
Our research on static modularity focuses on mixin modules , which attempt to unify ML-style modules with object-oriented features.
For dynamic modularity, we work with the Sardes project on a calculus designed to model software components. It is a higher-order message-passing calculus with hierarchical, distributed localities, explicit routing of messages, featuring pattern-matching and passivation of components. Our goals including setting up an adequate notion of bisimulation for it, and extending it with a notion of shared component.
This activity is supported by the french ARASSIA initiative (ANR - MoDyFiable project).

26. LIACC --- Report 1996--1998 And Plan 1999--2001 -- D.1.1 NCC: Plan For 1999-2001
In the area of the CurryHoward Correspondence of constrained type systems, and based on the work planned for 1999-2000, the plan is to find out a general
D.1.1 NCC: Plan for 1999-2001
D.1.1 NCC: Plan for 1999-2001
The Computer Science group at LIACC has 10 PhD researchers (including 5 senior researchers), 11 PhD students (holding a MSc) and 2 MSc students, corresponding to a total effort of 16.5 men years. The main objective is the study of declarative programming based on formal systems and their practical implementation in sequential and distributed computer environments. Besides the logic programming framework, where the research group has substantial past work and experience, work is envisaged in other systems such as functional programming, constraint based programming and object oriented systems for distributed environments. In a more narrow field of application, research is also envisaged in the study of formal systems for Natural Language Proccessing. In any case the kind of work ranges from the formal study of these systems to the state of the art practical implementations in an effort to obtain declarative programming systems with strong formal properties, as well as field experiments with the development of real world applications.
D.1.1.1 Declarative Programming and Parallelism

27. Mathematical Proof/Proof And Computer Programs - Wikibooks, Collection Of Open-c
Wikipedia has related information at CurryHoward Correspondence. The Curry-Howard Correspondence establish a close relationship between computer programs
var wgNotice = ""; var wgNoticeLocal = ""; var wgNoticeLang = "en"; var wgNoticeProject = "wikibooks";
Mathematical Proof/Proof and Computer Programs
From Wikibooks, the open-content textbooks collection
Mathematical Proof Jump to: navigation search == The Curry-Howard Correspondance == Wikipedia has related information at Curry-Howard correspondence
The Curry-Howard correspondence establish a close relationship between computer programs and mathematical proofs. Retrieved from " Subject Mathematical Proof Views Personal tools Navigation Community Search Toolbox

28. Light Leaks - Something Nice About Ccg
By the CurryHoward Correspondence, each derivation corresponds to a term in a proof calculus, which is a certain sort of lambda calculus (bi-linear lambda

29. Closed Categories « The Unapologetic Mathematician
This is (one way of viewing) the CurryHoward Correspondence (and why it’s sometimes referred to as the Curry-Howard-Lawvere or Curry-Howard-Lambek
The Unapologetic Mathematician
Mathematics for the interested outsider
Closed Categories
A closed category is a symmetric monoidal category where each functor . By what we said yesterday , this means that there is a unique way to sew all these adjoints parametrized by together into a functor. The canonical example of such a category is the category of sets with the cartesian product as its monoidal structure. For each set we need an adjunction and one from should be in bijection with functions from to . And indeed we have such an adjunction: is the set of all functions from to we have the function , which takes two numbers and gives back a third: if we stick in and we get back . But what if we just stick in the first number of the pair? Then what we get back is a function that will take the second number and give us the sum: if we just feed in we get back the function . That is, we can see addition either as a function taking a pair of numbers to a number, or we can see it as a function , taking a number to a function from numbers to numbers.

30. No Title
Use of CurryHoward correspondance to prove the correctness of imperative an extension of Curry-Howard Correspondence in a real mathematical theory,
Next: Queen Mary and Westfield College, University of London Up: Progress Report Previous: University of Padova
Paris 7 site: scientific report
Paris 7 team studies most of the aspects of the correspondance between proofs and programs. This work can be classified along the following lines: - Computational interpretations of classical logic - Computational content of true mathematical theorems - Use of Curry-Howard correspondance to prove the correctness of imperative programs. - Game semantics for classical linear logic - Type systems for computer languages - Development of the AF2 proof assistant
Computational interpretations of classical logic. M. Parigot introduces in [ ] a computional interpretation of classical logic, called -calculus which has been widely studied. In [ ], he gives two proofs of strong normalisation for second order typed -calculus. The first one is an adaptation of the method of reducibility candidates introduced by J.Y. Girard for second order typed -calculus; the extension to the classical case requires in particular a simplification of the notion of reducibility candidate. The second one is a reduction to the intuitionistic case, using a kind of cps translation. In [ ], V. Danos, J.B. Joinet and H.D Schellinx, packed a comprehensive study of sequent calculi for classical logic, most notably LKT, LKQ and LKTQ, that one could embed in linear logic. In [

31. Joe Wells's Papers
To solve the problem, we use the CurryHoward Correspondence (propositions-as-types, proofs-as-programs) to transform it into a proof enumeration problem
Joe Wells 's Papers
In addition to the list below, you may also want to browse my old FTP archive at Boston University , the technical report archive of the Boston University Computer Science Department , or the papers web page of the Church Project 66 references, last updated Fri Nov 4 15:10:43 2005
J. B. Wells and Christian Haack . Branching types. , 200X. Completely supersedes . Accepted subject to revisions. ( PDF Although systems with intersection types have many unique capabilities, there has never been a fully satisfactory explicitly typed system with intersection types. We introduce and prove the basic properties of lambda B , a typed lambda -calculus with branching types and types with quantification over type selection parameters . The new system lambda B is an explicitly typed system with the same expressiveness as a system with intersection types. Typing derivations in lambda B use branching types to squash together what would be separate parallel derivations in earlier systems with intersection types.
and J. B. Wells

32. Technical Background And Overview
theorem proving systems including Lego, Coq and others - have been designed to exploit the Curry-Howard Correspondence between logic and programming.
Technical background and overview
Simon Thompson, John Shackell and Erik Poll
Axiom and Aldor
Axiom is a computer algebra system; Aldor is the library compiler for Axiom. It will also form a part of the successor to Maple V, which is to be a new-generation PSE jointly supported by Waterloo Maple and the Numerical Algorithms Group
The type system of Axiom/Aldor
Axiom/Aldor is unusual among computer algebra systems in being strongly typed: every item in the system has a type and the type-correctness of Axiom programs can be verified at compile time, an obvious benefit for the user of the system. To accommodate the various types encountered in CA systems, the type system needs to contain a number of powerful primitives; in order for the type system to be usable it is augmented with facilities for overloading, coercions and so forth which together interact to give a complexity to the system. Beyond this, various aspects of the system rely on a non-type-checked macro mechanism, and there are other complicating aspects which we survey briefly now.
  • Axiom/Aldor is intended to support symbolic mathematics, and so in particular to represent algebraic structures, such as monoids, groups and so forth. These appear as `categories' in Axiom/Aldor, where a category is specified by giving a signature of functions over a carrier set `

33. MFPS 22 List Of Accepted Papers
Abstract We derive an abstract machine from the CurryHoward Correspondence with a sequent calculus presentation of Intuitionistic Propositional Linear
MFPS 22 List of Accepted Papers
Philippa Gardner and Uri Zarfaty. Local reasoning about tree updates Abstract: Separation Logic and Context Logic have been used to reason locally about heap update and simple tree update. We study local reasoning based on Context Logic for a more realistic, local tree-update language which combines update commands with queries. This combination results in updates at multiple locations, which significantly affects the complexity of the reasoning. Daniele Varacca and Nobuko Yoshida. Typed Event Structures and the Pi-calculus Abstract: We propose a typing system for the true concurrent model of event structures that guarantees the interesting behavioural properties known as conflict freeness and confusion freeness. Conflict freeness is the true concurrent version of the notion of confluence. A system is confusion free if nondeterministic choices are localised and do not depend on the scheduling of independent components. Ours is the first typing system to control behaviour in a true concurrent model. To demonstrate its applicability, we show that typed event structures give a semantics of linearly typed version of the pi-calculi with internal mobility. The semantics we provide is the first event structure semantics of the pi-calculus and generalises Winskel's original event structure semantics of CCS. Daniela Cancila, Furio Honsell and Marina Lenisa.

34. SIPB Cluedump Series - SIPB Cluedumps
For a broad overview of the CurryHoward Correspondence ( proofs are programs, programs proofs ), see more Phil Wadler, particularly his 2000 writeup.
SIPB Cluedump Series
From SIPB Cluedumps
Jump to: navigation search SIPB Cluedumps are informal technical talks, well supplied with snacks. Interrupt with questions at any time, or quietly get up for food. Cluedumps ordinarily run at 8:30 PM Monday evenings. Feel free to contact the Cluedump Series organizers at cluedumps at obvious dot edu Sign up for weekly announcements by blancheing yourself onto cluedump-announce , or mail us and we'll add you.
We'll resume sometime next term, for at least a couple of sessions. Let us know if you have topics to suggest!
Computational Intractability As A Law of Physics
Date: December 3 , 2007, at 8:30 PM Presenters: Scott Aaronson Location: 56-114 Abstract : In this talk, I'll ask whether the hardness of NP-complete problems would be useful to assume as a physical principle, on par with (say) the Second Law of Thermodynamics or the impossibility of faster-than-light communication. As part of discussing that question, I'll tell you the real story about quantum computing (i.e. not what you've read in the popular press): why this field is tremendously exciting, and why quantum computers could break RSA, Diffie-Hellman, and almost every other public-key cryptosystem used today, but also why we don't believe quantum computers would provide unlimited exponential parallelism.

Page 1     1-42 of 42    1