Synthesis and compositional verification using language learning

Formal analysis was proposed to verify correctness of complex systems. Especially, symbolic model checking using BDDs and/or S AT solvers has successfully been applied to discover subtle errors in various protocols and hardware designs, and many researches are recently being conducted for software model checking. However, many challenges are still remaining in the formal analysis field. For instance, there is some gap between real systems we want to analyze and models we can verify with the current technique, and some synthesis problems are too complex to solve efficiently. Learning techniques for regular languages provide efficient algorithms to construct a minimal DFA for an unknown regular language by asking membership and/or equivalence queries to a teacher (oracle) who knows the language. Although the learning techniques are very useful to solve a number of problems, application of them has been studied relatively less since it is difficult to provide an efficient teacher who should answer the queries. In this thesis, we present novel techniques using a learning algorithm in order to solve several formal analysis problems for which a DFA can be a representation for solutions. To apply the learning technique, we first define what language is the correct solution for each problem, and then we provide a teacher for the regular language. By the teacher implemented using symbolic model checking techniques, we can efficiently get the answers for queries, and construct a minimal DFA as the solution. We apply this new technique to following problems: JAVA interface synthesis, compositional verification, and safety planning problem. As the first problem, we consider JAVA interface synthesis. While a typical software component, e.g. a JAVA class, has a clear documentation for static interface iv in terms of the methods and the types of input/output parameters they support, information about the correct sequences of method calls the client must invoke is usually undocumented. Given a JAVA class and a safety property, the corresponding dynamic interface is the most general way of invoking the methods in the class so that the safety property is not violated. In this thesis, we propose a sound solution to automatically extract such temporal specifications, which uses regular language learning and symbolic model checking. We adopt compositional verification based on assume-guarantee reasoning, as our second problem. The verification problem for a large system can be decomposed into simpler sub-problems for its components, and compositional verification is a technique to use such a "divide and conquer" strategy. However, the compositional reasoning requires user guidance to identify appropriate assumptions for components. For this problem, we propose an automated solution for discovering assumptions based on the learning algorithm. We present a symbolic implementation of the learning algorithm, and incorporate it in the symbolic model checker NUSMV. For the last problem, we study a safety planning problem with partial observability. While traditional planning assumes reachability goals and/or full observability, the combination of temporally extended goals with partial observability is rarely studied due to the hardness of these problems. In the safety planning problem with partial observability, we want a plan to guide, only with partial information about the state of a given planning domain, the planning domain to stay forever states satisfying a given safety requirement. In this dissertation, we introduce a new technique to synthesize such a safe plan. Given a planning domain and a safety requirement, we first use the language learning technique to identify a safe plan with respect to the safety requirement. Then, we also check that the safe plan being constructedis permissive enough with respect to a given reachability requirement. Our solution always synthesizes a safe plan, and attempts to make it permissive for the reachability requirement.