A temporal logic approach to binding-time analysis

Rowan Davies

    Research output: Contribution to journalArticle

    3 Citations (Scopus)

    Abstract

    This article demonstrates that there is a fundamental relationship between temporal logic and languages that involve multiple stages, such as those used to analyze binding times in the context of partial evaluation. This relationship is based on an extension of the Curry-Howard isomorphism, which identifies proofs with programs, and propositions with types. Our extension involves the "next time" (○) operator from linear-time temporal logic and yields a λ-calculus λ° with types of the form ○A for expressions in the subsequent stage, with appropriate introduction and elimination forms. We demonstrate that λ° is equivalent to the core of a previously studied multilevel binding-time analysis. This is similar to work by Davies and Pfenning on staged computation based on the necessity (□) operator of modal logic, but □ only allows closed code, and naturally supports a code evaluation construct, whereas ○ captures open code, thus is more flexible, but is incompatible with such a construct. Instead, code evaluation is an external global operation that is validated by the proof theory regarding closed proofs of ○ formulas. We demonstrate the relevance of λ° to staged computation directly by showing that that normalization can be done in an order strictly following the times of the logic. We also extend λ° to small functional language and show that it would serve as a suitable basis for directly programming with multiple stages by presenting some example programs. © 2017 ACM

    Original languageEnglish
    Article number1
    Number of pages45
    JournalJournal of the ACM
    Volume64
    Issue number1
    DOIs
    Publication statusPublished - 1 Mar 2017

    Fingerprint

    Temporal logic
    Mathematical operators

    Cite this

    Davies, Rowan. / A temporal logic approach to binding-time analysis. In: Journal of the ACM. 2017 ; Vol. 64, No. 1.
    @article{d02f55b63c0f4373ac7307f797e81401,
    title = "A temporal logic approach to binding-time analysis",
    abstract = "This article demonstrates that there is a fundamental relationship between temporal logic and languages that involve multiple stages, such as those used to analyze binding times in the context of partial evaluation. This relationship is based on an extension of the Curry-Howard isomorphism, which identifies proofs with programs, and propositions with types. Our extension involves the {"}next time{"} (○) operator from linear-time temporal logic and yields a λ-calculus λ° with types of the form ○A for expressions in the subsequent stage, with appropriate introduction and elimination forms. We demonstrate that λ° is equivalent to the core of a previously studied multilevel binding-time analysis. This is similar to work by Davies and Pfenning on staged computation based on the necessity (□) operator of modal logic, but □ only allows closed code, and naturally supports a code evaluation construct, whereas ○ captures open code, thus is more flexible, but is incompatible with such a construct. Instead, code evaluation is an external global operation that is validated by the proof theory regarding closed proofs of ○ formulas. We demonstrate the relevance of λ° to staged computation directly by showing that that normalization can be done in an order strictly following the times of the logic. We also extend λ° to small functional language and show that it would serve as a suitable basis for directly programming with multiple stages by presenting some example programs. {\circledC} 2017 ACM",
    keywords = "Partial evaluation, Propositions as types, Staged computation",
    author = "Rowan Davies",
    year = "2017",
    month = "3",
    day = "1",
    doi = "10.1145/3011069",
    language = "English",
    volume = "64",
    journal = "Journal of the ACM",
    issn = "0004-5411",
    publisher = "Association for Computing Machinery (ACM)",
    number = "1",

    }

    A temporal logic approach to binding-time analysis. / Davies, Rowan.

    In: Journal of the ACM, Vol. 64, No. 1, 1, 01.03.2017.

    Research output: Contribution to journalArticle

    TY - JOUR

    T1 - A temporal logic approach to binding-time analysis

    AU - Davies, Rowan

    PY - 2017/3/1

    Y1 - 2017/3/1

    N2 - This article demonstrates that there is a fundamental relationship between temporal logic and languages that involve multiple stages, such as those used to analyze binding times in the context of partial evaluation. This relationship is based on an extension of the Curry-Howard isomorphism, which identifies proofs with programs, and propositions with types. Our extension involves the "next time" (○) operator from linear-time temporal logic and yields a λ-calculus λ° with types of the form ○A for expressions in the subsequent stage, with appropriate introduction and elimination forms. We demonstrate that λ° is equivalent to the core of a previously studied multilevel binding-time analysis. This is similar to work by Davies and Pfenning on staged computation based on the necessity (□) operator of modal logic, but □ only allows closed code, and naturally supports a code evaluation construct, whereas ○ captures open code, thus is more flexible, but is incompatible with such a construct. Instead, code evaluation is an external global operation that is validated by the proof theory regarding closed proofs of ○ formulas. We demonstrate the relevance of λ° to staged computation directly by showing that that normalization can be done in an order strictly following the times of the logic. We also extend λ° to small functional language and show that it would serve as a suitable basis for directly programming with multiple stages by presenting some example programs. © 2017 ACM

    AB - This article demonstrates that there is a fundamental relationship between temporal logic and languages that involve multiple stages, such as those used to analyze binding times in the context of partial evaluation. This relationship is based on an extension of the Curry-Howard isomorphism, which identifies proofs with programs, and propositions with types. Our extension involves the "next time" (○) operator from linear-time temporal logic and yields a λ-calculus λ° with types of the form ○A for expressions in the subsequent stage, with appropriate introduction and elimination forms. We demonstrate that λ° is equivalent to the core of a previously studied multilevel binding-time analysis. This is similar to work by Davies and Pfenning on staged computation based on the necessity (□) operator of modal logic, but □ only allows closed code, and naturally supports a code evaluation construct, whereas ○ captures open code, thus is more flexible, but is incompatible with such a construct. Instead, code evaluation is an external global operation that is validated by the proof theory regarding closed proofs of ○ formulas. We demonstrate the relevance of λ° to staged computation directly by showing that that normalization can be done in an order strictly following the times of the logic. We also extend λ° to small functional language and show that it would serve as a suitable basis for directly programming with multiple stages by presenting some example programs. © 2017 ACM

    KW - Partial evaluation

    KW - Propositions as types

    KW - Staged computation

    UR - http://www.scopus.com/inward/record.url?scp=85017163726&partnerID=8YFLogxK

    U2 - 10.1145/3011069

    DO - 10.1145/3011069

    M3 - Article

    VL - 64

    JO - Journal of the ACM

    JF - Journal of the ACM

    SN - 0004-5411

    IS - 1

    M1 - 1

    ER -