Proof Transformation Research Articles

SIV: a structural integrity verification approach of cloud components with enhanced privacy

Private data leakage is a threat to current integrity verification schemes of cloud components. To address this issue, this work proposes a privacy-enhancing Structural Integrity Verification (SIV) approach. It is made up of three processes: proof organization, proof transformation, and integrity judgement. By introducing a Merkle tree technique, the integrity of a constituent part of a cloud component on a node is represented by a root value. The value is then masked to cipher texts in proof transformation. With the masked proofs, a structural feature is extracted and validated in an integrity judgement by a third-party verification provider. The integrity of the cloud component is visually displayed in the output result matrix. If there are abnormities, the corrupted constituent parts can be located. Integrity is verified through the encrypted masked proofs. All raw proofs containing sensitive information stay on their original nodes, thus minimizing the attack surface of the proof data, and eliminating the risk of leaking private data at the source. Although some computations are added, the experimental results show that the time overhead is within acceptable bounds.

Resolution proof transformation for compression and interpolation

Verification methods based on SAT, SMT, and Theorem Proving often rely on proofs of unsatisfiability as a powerful tool to extract information in order to reduce the overall effort. For example a proof may be traversed to identify a minimal reason that led to unsatisfiability, for computing abstractions, or for deriving Craig interpolants. In this paper we focus on two important aspects that concern efficient handling of proofs of unsatisfiability: compression and manipulation. First of all, since the proof size can be very large in general (exponential in the size of the input problem), it is indeed beneficial to adopt techniques to compress it for further processing. Secondly, proofs can be manipulated as a flexible preprocessing step in preparation for interpolant computation. Both these techniques are implemented in a framework that makes use of local rewriting rules to transform the proofs. We show that a careful use of the rules, combined with existing algorithms, can result in an effective simplification of the original proofs. We have evaluated several heuristics on a wide range of unsatisfiable problems deriving from SAT and SMT test cases.

Playing in the grey area of proofs

Interpolation is an important technique in verification and static analysis of programs. In particular, interpolants extracted from proofs of various properties are used in invariant generation and bounded model checking. A number of recent papers studies interpolation in various theories and also extraction of smaller interpolants from proofs. In particular, there are several algorithms for extracting of interpolants from so-called local proofs. The main contribution of this paper is a technique of minimising interpolants based on transformations of what we call the "grey area" of local proofs. Another contribution is a technique of transforming, under certain common conditions, arbitrary proofs into local ones. Unlike many other interpolation techniques, our technique is very general and applies to arbitrary theories. Our approach is implemented in the theorem prover Vampire and evaluated on a large number of benchmarks coming from first-order theorem proving and bounded model checking using logic with equality, uninterpreted functions and linear integer arithmetic. Our experiments demonstrate the power of the new techniques: for example, it is not unusual that our proof transformation gives more than a tenfold reduction in the size of interpolants.

Proof Transformation via Interpretation Functions: Results, Problems and Applications

Change is a constant factor in Software Engineering process. Redesign of a class structure requires transformation of the corresponding OCL constraints. In a previous paper we have shown how to use, what we call, interpretation functions for transformation of constraints. In this paper we discuss recently obtained results concerning proof transformations via such functions. In particular we detail the fact that they preserve proofs in equational logic, as well as proofs in other logical systems like propositional logic with modus ponens or proofs using resolution rule. Those results have direct applications to redesign of UML State Machines and Sequence Diagrams. If states in a State Machine are interpreted by State Invariants, then the topological relations between its states can be interpreted as logical relations between the corresponding formulas. Preservation of the consequence relation can bee seen as preservation of the topology of State Machines. We indicate also an unsolved problem and discuss the mining of its positive solution.

Register allocation by proof transformation

This paper presents a proof-theoretical framework that accounts for the entire process of register allocation—liveness analysis is proof reconstruction (similar to type inference), and register allocation is proof transformation from a proof system with unrestricted variable accesses to a proof system with restricted variable access. In our framework, the set of registers acts as a “working set” of the live variables at each instruction step, which changes during the execution of the code. This eliminates the ad hoc notion of “spilling”. Memory–register moves are systematically incorporated in our proof transformation process. Its correctness is a direct corollary of our construction; the resulting proof is equivalent to the proof of the original code modulo treatment of structural rules. The framework serves as a basis for reasoning about formal properties of register allocation process, and it also yields a clean and systematic register allocation algorithm. The algorithm has been implemented, demonstrating the feasibility of the framework.

Presentation of proofs in modal natural deduction

We introduce a calculus for transforming first-order proofs of theorems originally formulated in modal logic, into modal natural deduction proofs. With a transformation procedure based on this calculus, we are able to present a proof in the language in which the problem was originally formulated, and in a formalism giving better insight into the contents of the proof. As a target language of the proof transformation we use a linearized modal natural deduction calculus which makes the reasoning involving modal contexts explicit.

Recursive Program Optimization through Inductive Synthesis Proof Transformation

The research described in this paper involved developing transformation techniques that increase the efficiency of the original program, the source, by transforming its synthesis proof into one, the target, which yields a computationally more efficient algorithm. We describe a working proof transformation system that, by exploiting the duality between mathematical induction and recursion, employs the novel strategy of optimizing recursive programs by transforming inductive proofs. We compare and contrast this approach with the more traditional approaches to program transformation and highlight the benefits of proof transformation with regards to search, correctness, automatability, and generality.

Intuitionistic Proof Transformations: Complexity and Applications: Extended Abstract

We investigate a proof transformation from the multi-succedent calculus LJmc to Gentzen's single-succedent calculus LJ intuitionistic logic. We analyze the complexity of such a transformation and show that there exists no polynomial simulation between the cut-free versions of LJmc and CJ . Applications of proof transformations are motivated within constructive program synthesis systems since LJmc gives a basis for automated proof search whereas LJ is better suited for proof presentation and program construction from proofs. Well-known transformations from the literature are based on the cut-rule and suffer from the undesired consequence that the resulting program terms are not intuitive. We present a cut-free transformation of intuitionistic sequent proofs from LJmc to CJ based on permutation of inferences, and contrast its worst-case complexity with its effects on the quality of program terms.

TMPR: A tree-structured modified problem reduction proof procedure and its extension to three-valued logic

This paper deals with automated deduction for classical and partial logics, especially for the three-valued logic L3, which has been introduced, for example, in the study of natural language semantics. Based on ideas from a Plaisted's Gentzen style system for classical two-valued logic, we present a new tree-structured proof procedure (TMPR) together with a new completeness proof using proof transformation techniques and some improvements including the generation and use of lemmata. TMPR extends SLD-resolution with a Prolog-style backward chaining to full first-order logic by a controlled use of case analysis. This is done without having to extend negative goals needed, for example, for model elimination. A classification of TMPR, model elimination and related calculi in a common tableau framework is given. Thereafter, we present our extension of the TMPR proof procedure to L3 and show its soundness and completeness. As a side result, a TMPR proof system for the four-valued logic L4 is given. Finally, the restriction of TMPR to ‘L3-Horn clauses’ is considered, and, additionally, an idea for similarly extending model elimination and related systems to L3 (and L4) is illustrated.