Automated Theorem Proving with Extensions of First-Order Logic

Automated theorem provers are computer programs that check whether a logical conjecture follows from a set of logical statements. The conjecture and the statements are expressed in the language of some formal logic, such as first-order logic. Theorem provers for first-order logic have been used for automation in proof assistants, verification of programs, static analysis of networks, and other purposes. However, the efficient usage of these provers remains challenging. One of the challenges is the complexity of translating domain problems to first-order logic. Not only can such translation be cumbersome due to semantic differences between the domain and the logic, but it might inadvertently result in problems that provers cannot easily handle.The work presented in the thesis addresses this challenge by developing an extension of first-order logic named FOOL. FOOL contains syntactical features of programming languages and more expressive logics, is friendly for translation of problems from various domains, and can be efficiently supported by existing theorem provers. We describe the syntax and semantics of FOOL and present a simple translation from FOOL to plain first-order logic. We describe an efficient clausal normal form transformation algorithm for FOOL and based on it implement a support for FOOL in the Vampire theorem prover. We illustrate the efficient use of FOOL for program verification by describing a concise encoding of next state relations of imperative programs in FOOL. We show a usage of features of FOOL in problems of static analysis of networks. We demonstrate the efficiency of automated theorem proving in FOOL with an extensive set of experiments. In these experiments we compare the performance of Vampire on a large collection of problems from various sources translated to FOOL and ordinary first-order logic. Finally, we fix the syntax for FOOL in TPTP, the standard language of first-order theorem provers

Type-Directed Language Extension for Effectful Computations

ABSTRACT Computation types such as functors, applicative functors and monads have become common abstractions for modeling effectful computations in functional programming languages. They are often used together with special language extensions intended to simplify the syntax of monadic expressions. We can simplify it even more by employing types rather than just mechanical syntactic transformation. In this paper we present scala-workflow, a macro-based extension to the Scala programming language that offers uniform syntax for structuring effectful computations expressed as abstract interfaces with a stackable set of combinators. Unlike similar syntactic extensions, such as F#'s computation expressions, Haskell's do-notation and Scala's own for-expressions, scala-workflow allows users to transparently blend pure and effectful functions in a bounded context, as they are separated during macro expansion based on the types of subexpressions

Reachability analysis for AWS-based networks

Cloud services provide the ability to provision virtual networked infrastructure on demand over the Internet. The rapid growth of these virtually provisioned cloud networks has increased the demand for automated reasoning tools capable of identifying misconfigurations or security vulnerabilities. This type of automation gives customers the assurance they need to deploy sensitive workloads. It can also reduce the cost and time-to-market for regulated customers looking to establish compliance certification for cloud-based applications. In this industrial case-study, we describe a new network reachability reasoning tool, called Tiros, that uses off-the-shelf automated theorem proving tools to fill this need. Tiros is the foundation of a recently introduced network security analysis feature in the Amazon Inspector service now available to millions of customers building applications in the cloud. Tiros is also used within Amazon Web Services (AWS) to automate the checking of compliance certification and adherence to security invariants for many AWS services that build on existing AWS networking features

Type-directed language extension for effectful computations

Computation types such as functors, applicative functors and monads have become common abstractions for modeling effectful computations in functional programming languages. They are often used together with special language extensions intended to simplify the syntax of monadic expressions. We can simplify it even more by employing types rather than just mechanical syntactic transformation. In this paper we present scala-workflow, a macro-based extension to the Scala programming language that offers uniform syntax for structuring effectful computations expressed as abstract interfaces with a stackable set of combinators. Unlike similar syntactic extensions, such as F#\u27s computation expressions, Haskell\u27s do-notation and Scala\u27s own for-expressions, scala-workflow allows users to transparently blend pure and effectful functions in a bounded context, as they are separated during macro expansion based on the types of subexpressions

Automated Theorem Proving in a First-Order Logic with First class Boolean Sort

Automated theorem proving is one of the central areas of computer mathematics. It studies methods and techniques for establishing validity of mathematical problems using a computer. The problems are expressed in a variety of formal logics, including first-order logic. Algorithms of automated theorem proving are implemented in computer programs called theorem provers. They find significant application in formal methods of system development and as a mean of automation in proof assistants.This thesis contributes to automated theorem proving with an ex- tension of many-sorted first-order logic called FOOL. In FOOL boolean sort has a fixed interpretation and boolean terms are treated as formulas. In addition, FOOL contains if-then-else and let-in constructs. We argue that these extensions are useful for expressing problems coming from program analysis and interactive theorem proving.We give a formalisation of FOOL and a translation of FOOL formulas to ordinary first-order logic. This translation can be used for proving theorems of FOOL using a first-order theorem prover. We describe our implementation of this translation in the Vampire theorem prover. We extend TPTP, the standard input language of first-order provers, to sup- port formulas of FOOL. We simplify TPTP by providing more powerful and uniform representations of if-then-else and let-in expressions.We discuss a modification of superposition calculus that can reason efficiently about formulas with interpreted boolean sort. We present a superposition-friendly translation of FOOL formulas to clausal normal form. We demonstrate usability and high performance of these modifications in Vampire on a series of benchmarks coming from various libraries of problems for automated provers.Finally, we present an extension of FOOL, aimed to be used for auto- mated program analysis. With this extension, the next state relation of a program can be expressed as a boolean formula which is linear in the size of the program

Automated Theorem Proving in a First-Order Logic with First class Boolean Sort

Automated theorem proving is one of the central areas of computer mathematics. It studies methods and techniques for establishing validity of mathematical problems using a computer. The problems are expressed in a variety of formal logics, including first-order logic. Algorithms of automated theorem proving are implemented in computer programs called theorem provers. They find significant application in formal methods of system development and as a mean of automation in proof assistants. This thesis contributes to automated theorem proving with an ex- tension of many-sorted first-order logic called FOOL. In FOOL boolean sort has a fixed interpretation and boolean terms are treated as formulas. In addition, FOOL contains if-then-else and let-in constructs. We argue that these extensions are useful for expressing problems coming from program analysis and interactive theorem proving. We give a formalisation of FOOL and a translation of FOOL formulas to ordinary first-order logic. This translation can be used for proving theorems of FOOL using a first-order theorem prover. We describe our implementation of this translation in the Vampire theorem prover. We extend TPTP, the standard input language of first-order provers, to sup- port formulas of FOOL. We simplify TPTP by providing more powerful and uniform representations of if-then-else and let-in expressions. We discuss a modification of superposition calculus that can reason efficiently about formulas with interpreted boolean sort. We present a superposition-friendly translation of FOOL formulas to clausal normal form. We demonstrate usability and high performance of these modifications in Vampire on a series of benchmarks coming from various libraries of problems for automated provers. Finally, we present an extension of FOOL, aimed to be used for auto- mated program analysis. With this extension, the next state relation of a program can be expressed as a boolean formula which is linear in the size of the program

TFX: The TPTP Extended Typed First-Order Form

The TPTP world is a well established infrastructure that supports research, development, and deployment of Automated Theorem Proving systems for classical logics. The TPTP language is one of the keys to the success of the TPTP world. Originally the TPTP world supported only first-order clause normal form (CNF). Over the years support for full first-order form (FOF), monomorphic typed first-order form (TF0), rank-1 polymorphic typed first-order form (TF1), monomorphic typed higher-order form (TH0), and rank-1 polymorphic typed higher-order form (TH1), have been added. TF0 and TF1 together form the TFF language family; TH0 and TH1 together form the THF language family. This paper introduces the eXtended Typed First-order form (TFX), which extends TFF to include Boolean terms, tuples, conditional expressions, and let expressions