1,385 research outputs found

    Capturing Hiproofs in HOL Light

    Full text link
    Hierarchical proof trees (hiproofs for short) add structure to ordinary proof trees, by allowing portions of trees to be hierarchically nested. The additional structure can be used to abstract away from details, or to label particular portions to explain their purpose. In this paper we present two complementary methods for capturing hiproofs in HOL Light, along with a tool to produce web-based visualisations. The first method uses tactic recording, by modifying tactics to record their arguments and construct a hierarchical tree; this allows a tactic proof script to be modified. The second method uses proof recording, which extends the HOL Light kernel to record hierachical proof trees alongside theorems. This method is less invasive, but requires care to manage the size of the recorded objects. We have implemented both methods, resulting in two systems: Tactician and HipCam

    Mobile Resource Guarantees for Smart Devices

    Get PDF
    Abstract. We present the Mobile Resource Guarantees framework: a system for ensuring that downloaded programs are free from run-time violations of resource bounds. Certificates are attached to code in the form of efficiently checkable proofs of resource bounds; in contrast to cryptographic certificates of code origin, these are independent of trust networks. A novel programming language with resource constraints encoded in function types is used to streamline the generation of proofs of resource usage.

    Formalising Σ -Protocols and Commitment Schemes Using CryptHOL

    Get PDF

    Interactive Simplifier Tracing and Debugging in Isabelle

    Full text link
    The Isabelle proof assistant comes equipped with a very powerful tactic for term simplification. While tremendously useful, the results of simplifying a term do not always match the user's expectation: sometimes, the resulting term is not in the form the user expected, or the simplifier fails to apply a rule. We describe a new, interactive tracing facility which offers insight into the hierarchical structure of the simplification with user-defined filtering, memoization and search. The new simplifier trace is integrated into the Isabelle/jEdit Prover IDE.Comment: Conferences on Intelligent Computer Mathematics, 201

    Retrofitting Security and Privacy Measures to Smart Home Devices

    Get PDF

    Antibody-based detection of protein phosphorylation status to track the efficacy of novel therapies using nanogram protein quantities from stem cells and cell lines

    Get PDF
    This protocol describes a highly reproducible antibody-based method that provides protein level and phosphorylation status information from nanogram quantities of protein cell lysate. Nanocapillary isoelectric focusing (cIEF) combines with UV-activated linking chemistry to detect changes in phosphorylation status. As an example application, we describe how to detect changes in response to tyrosine kinase inhibitors (TKIs) in the phosphorylation status of the adaptor protein ​CrkL, a major substrate of the oncogenic tyrosine kinase ​BCR-​ABL in chronic myeloid leukemia (CML), using highly enriched CML stem cells and mature cell populations in vitro. This protocol provides a 2.5 pg/nl limit of protein detection (<0.2% of a stem cell sample containing <104 cells). Additional assays are described for phosphorylated tyrosine 207 (pTyr207)-​CrkL and the protein tyrosine phosphatase ​PTPRC/​CD45; these assays were developed using this protocol and applied to CML patient samples. This method is of high throughput, and it can act as a screen for in vitro cancer stem cell response to drugs and novel agents

    Elaborator reflection : extending Idris in Idris

    Get PDF
    Many programming languages and proof assistants are defined by elaboration from a high-level language with a great deal of implicit information to a highly explicit core language. In many advanced languages, these elaboration facilities contain powerful tools for program construction, but these tools are rarely designed to be repurposed by users. We describe elaborator reflection, a paradigm for metaprogramming in which the elaboration machinery is made directly available to metaprograms, as well as a concrete realization of elaborator reflection in Idris, a functional language with full dependent types. We demonstrate the applicability of Idris’s reflected elaboration framework to a number of realistic problems, we discuss the motivation for the specific features of its design, and we explore the broader meaning of elaborator reflection as it can relate to other languages.Postprin

    Amortised resource analysis with separation logic

    Get PDF
    Type-based amortised resource analysis following Hofmann and Jost—where resources are associated with individual elements of data structures and doled out to the programmer under a linear typing discipline—have been successful in providing concrete resource bounds for functional programs, with good support for inference. In this work we translate the idea of amortised resource analysis to imperative languages by embedding a logic of resources, based on Bunched Implications, within Separation Logic. The Separation Logic component allows us to assert the presence and shape of mutable data structures on the heap, while the resource component allows us to state the resources associated with each member of the structure. We present the logic on a small imperative language with procedures and mutable heap, based on Java bytecode. We have formalised the logic within the Coq proof assistant and extracted a certified verification condition generator. We demonstrate the logic on some examples, including proving termination of in-place list reversal on lists with cyclic tails

    Memory usage verification using Hip/Sleek.

    Get PDF
    Embedded systems often come with constrained memory footprints. It is therefore essential to ensure that software running on such platforms fulfils memory usage specifications at compile-time, to prevent memory-related software failure after deployment. Previous proposals on memory usage verification are not satisfactory as they usually can only handle restricted subsets of programs, especially when shared mutable data structures are involved. In this paper, we propose a simple but novel solution. We instrument programs with explicit memory operations so that memory usage verification can be done along with the verification of other properties, using an automated verification system Hip/Sleek developed recently by Chin et al.[10,19]. The instrumentation can be done automatically and is proven sound with respect to an underlying semantics. One immediate benefit is that we do not need to develop from scratch a specific system for memory usage verification. Another benefit is that we can verify more programs, especially those involving shared mutable data structures, which previous systems failed to handle, as evidenced by our experimental results
    corecore