Browsing by Author "Chaudhuri, Swarat"
Now showing 1 - 20 of 25
Results Per Page
Sort Options
Item A Constraint and Sampling-Based Approach to Integrated Task and Motion Planning(2014-09-30) Prabhu, Sailesh Naveena; Chaudhuri, Swarat; Kavraki, Lydia E; McLurkin, James; Vardi, Moshe VThis thesis tackles the Integrated Task and Motion Planning (ITMP) Problem. The ITMP problem extends classical task planning with actions that require a motion plan. The agent seeks a sequence of actions and the necessary motions to achieve the goal. The user partially specifies the task plan by providing the actions' known parameters. An SMT solver, then, discovers values for the unkown parameters that satisfies constraints requiring the task plan to achieve the goal. The SMT solver utilizes an annotated Probabilistic Roadmap (PRM) to query for motion planning information. A sampling algorithm generates the PRM's vertices to permit a mobile manipulator to grasp numerous object configurations. Each iteration samples several base configurations and adds a base configuration to the PRM that increases the object configurations grasped from its vertices. Our results indicate that increasing the samples per iteration improves the probability the SMT solver discovers a satisfying assignment without adversely affecting the resulting task plan.Item A Constraint-Based Approach to Reactive Task and Motion Planning(2016-01-26) Wang, Yue; Chaudhuri, Swarat; Kavraki, Lydia E; Vardi, Moshe YThis thesis presents a novel and scalable approach for Reactive Task and Motion Planning. We consider changing environments with uncontrollable agents, where the robot needs a policy to respond correctly in the infinite interaction with the environment. Our approach operates on task and motion domains that combine actions over discrete states with continuous, collision-free paths. We synthesize a policy by iteratively verifying and searching for a policy candidate. For efficient verification, we employ Satisfiability Modulo Theories (SMT) solvers using a new extension of proof rules for Temporal Property Verification. For efficient policy search, we apply domain-specific heuristics to generalize verification failures. Furthermore, the SMT solver enables quantitative specifications such as energy limits. We benchmark our policy synthesizer in a mobile manipulation domain, showing that our approach offers better scalability compared to a state-of-the-art robotic synthesis tool in the tested benchmarks and demonstrating order-of-magnitude speedup from our heuristics.Item Algorithmic analysis of Regular repeated games(2016-09-15) Bansal, Suguman; Chaudhuri, SwaratThe problem on computing rational behaviors in multi-agent systems with selfish agents (Games) has become paramount for the analysis of such systems. {\em Nash equilibria} is one of the most central notions of rational behavior. While the problem of computing Nash equilibria in simple games is well understood, the same cannot be said for more complex games. {\em Repeated games} are one such class of games. In this thesis, we introduce {\em regular repeated games} as a model for repeated games with bounded rationality. In regular repeated games, agent strategies are given by weighted (discounted-sum aggregate), non-deterministic B\"uchi transducers. We design an algorithm {\ComputeNash} to compute all Nash equilibria in a regular repeated game. The crux of the algorithm lies in determining if a strategy profile is in Nash equilibria or not. For this it is necessary to compare the discounted sum on one infinite execution with that one other executions. Such relational reasoning has not been studies in the literature before. To this end, we introduce the concept of an {\em $\omega$-regular comparators}. We demonstrate promise of our approach via experimental analysis on case studies: Iterated Prisoner's Dilemma, repeated auctions, and a model of the Bitcoin protocol.Item An incremental constraint-based framework for task and motion planning(Sage, 2018) Dantam, Neil T.; Kingston, Zachary K.; Chaudhuri, Swarat; Kavraki, Lydia E.We present a new constraint-based framework for task and motion planning (TMP). Our approach is extensible, probabilistically complete, and offers improved performance and generality compared with a similar, state-of-the-art planner. The key idea is to leverage incremental constraint solving to efficiently incorporate geometric information at the task level. Using motion feasibility information to guide task planning improves scalability of the overall planner. Our key abstractions address the requirements of manipulation and object rearrangement. We validate our approach on a physical manipulator and evaluate scalability on scenarios with many objects and long plans, showing order-of-magnitude gains compared with the benchmark planner and improved scalability from additional geometric guidance. Finally, in addition to describing a new method for TMP and its implementation on a physical robot, we also put forward requirements and abstractions for the development of similar planners in the future.Item Assertion-Based Flow Monitoring of SystemC Models(2014-04-22) Dutta, Sonali; Vardi, Moshe Y.; Chaudhuri, Swarat; Nakhleh, Luay K.SystemC is the de facto system modeling language, and verification of SystemC models is a major research direction. Assertion-Based Monitoring is a dynamic verification technique that allows the user to dynamically verify formal properties of the system by automatically generating runtime monitors from them. A typical hardware-software system is concurrent and reactive. Examples of such systems can be a computer, an ATM server etc. Such systems perform multiple jobs of different types during their execution. For example, different types of jobs in a computer can be ‘launching a web browser’, ‘searching the file system’ etc. A job can be submitted by an external user or generated by an internal component of the system. A job can begin at any point in time during the execution of the system, the beginning time being completely unknown beforehand. A job begins with a set of inputs, travels from one system component to another to generate a set of outputs and ends after a finite amount of time. Since a job “flows” among the system components, we call it a flow. In a concurrent system multiple flows can begin and travel though the system at the same time. This work focuses on verifying formal properties about these dynamic and concurrent flows (called flow properties) in a concurrent reactive system, modeled in SystemC. The contribution of this thesis is three fold: First, a light-weight C++ library, called iii Flow Library, that enables modeling of flows in SystemC in a structured manner. Second, an algorithm, implemented in the FlowMonGen tool, to generate C++ monitor class from a flow property, which is an LTL formula interpreted over the finite trace of a flow. Third, a dynamic and decentralized algorithm to monitor the concurrent flows in a SystemC model. Our completely automated and efficient Flow Monitoring Framework implements this algorithm.Item Bounded Policy Synthesis for POMDPs with Safe-Reachability and Quantitative Objectives(2018-10-05) Wang, Yue; Chaudhuri, Swarat; Kavraki, Lydia E.Robots are being deployed for many real-world applications like autonomous driving, disaster rescue, and personal assistance. Effectively planning robust executions under uncertainty is critical for building these autonomous robots. Partially Observable Markov Decision Processes (POMDPs) provide a standard approach to model many robot applications under uncertainty. A key algorithmic problem for POMDPs is the synthesis of policies that specify the actions to take contingent on all possible events. Policy synthesis for POMDPs with two kinds of objectives is considered in this thesis: (1) boolean objectives for a correctness guarantee of accomplishing tasks and (2) quantitative objectives for optimal behaviors. For boolean objectives, this thesis focuses on a common safe-reachability objective: with a probability above a threshold, a goal state is eventually reached while keeping the probability of visiting unsafe states below a different threshold. Previous results have shown that policy synthesis for POMDPs over infinite horizon is generally undecidable. For decidability, this thesis focuses on POMDPs over a bounded horizon. Solving POMDPs requires reasoning over a vast space of beliefs (probability distributions). To address this, this thesis introduces the notion of a goal-constrained belief space that only contains beliefs reachable under desired executions that can achieve the safe-reachability objectives. Based on this notion, this thesis presents an offline approach that constructs policies over the goal-constrained belief space instead of the entire belief space. Simulation experiments show that this offline approach can scale to large belief spaces by focusing on the goal-constrained belief space. A full policy is generally costly to compute. To improve efficiency, this thesis presents an online approach that interleaves the computation of partial policies and execution. A partial policy is parameterized by a replanning probability and only contain a sampled subset of all possible events. This online approach allows users to specify an appropriate bound on the replanning probability to balance efficiency and correctness. Finally, this thesis presents an approximate policy synthesis approach that combines the safe-reachability objectives with the quantitative objectives. The results demonstrate that the constructed policies not only achieve the safe-reachability objective but also are of high quality concerning the quantitative objective.Item Comparator automata in quantitative verification(EPI Sciences, 2022) Vardi, Moshe Y.; Chaudhuri, Swarat; Bansal, SugumanThe notion of comparison between system runs is fundamental in formal verification. This concept is implicitly present in the verification of qualitative systems, and is more pronounced in the verification of quantitative systems. In this work, we identify a novel mode of comparison in quantitative systems: the online comparison of the aggregate values of two sequences of quantitative weights. This notion is embodied by comparator automata (comparators, in short), a new class of automata that read two infinite sequences of weights synchronously and relate their aggregate values. We show that aggregate functions that can be represented with B\"uchi automaton result in comparators that are finite-state and accept by the B\"uchi condition as well. Such $\omega$-regular comparators further lead to generic algorithms for a number of well-studied problems, including the quantitative inclusion and winning strategies in quantitative graph games with incomplete information, as well as related non-decision problems, such as obtaining a finite representation of all counterexamples in the quantitative inclusion problem. We study comparators for two aggregate functions: discounted-sum and limit-average. We prove that the discounted-sum comparator is $\omega$-regular iff the discount-factor is an integer. Not every aggregate function, however, has an $\omega$-regular comparator. Specifically, we show that the language of sequence-pairs for which limit-average aggregates exist is neither $\omega$-regular nor $\omega$-context-free. Given this result, we introduce the notion of prefix-average as a relaxation of limit-average aggregation, and show that it admits $\omega$-context-free comparators i.e. comparator automata expressed by B\"uchi pushdown automata.Item computer-aided mechanism design(2015-04-17) Fang, Ye; Chaudhuri, Swarat; Vardi, Moshi; Nakhleh, Luay K.; Jermaine, Christopher M.Algorithmic mechanism design, as practised today, is a manual process; however, manual design and reasoning do not scale well with the complexity of design tasks. In this thesis, we study computer-aided mechanism design as an alternative to manual construction and analysis of mechanisms. In our approach, a mechanism is a program that receives inputs from agents with private preferences, and produces a public output. Rather than programming such a mechanism manually, the human designer writes a high-level partial specification that includes behavioral models of agents and a set of logical correctness requirements (for example, truth-telling) on the desired mechanism. A program synthesis algorithm is now used to automatically search a large space of candidate mechanisms and find one that satis es the requirements. The algorithm is based on a reduction to automated rst-order logic theorem proving | speci cally, deciding the satis ability of quanti er-free formulas in the rst-order theory of reals. We present an implementation of our synthesis approach on top of a Satis ability Modulo Theories solver. The system is evaluated through several case studies where we automatically synthesize a set of classic mechanisms and their variations, including the Vickrey auction, a multistage auction, a position auction, and a voting mechanism.Item Constrained Counting and Sampling: Bridging the Gap Between Theory and Practice(2017-09-29) Meel, Kuldeep Singh; Chakraborty, Supratik; Chaudhuri, Swarat; Duenas-Osorio, Leonardo; Seshia, Sanjit A.; Vardi, Moshe Y.Constrained counting and sampling are two fundamental problems in Computer Science with numerous applications, including network reliability, privacy, probabilistic reasoning, and constrained-random verification. In constrained counting, the task is to compute the total weight, subject to a given weighting function, of the set of solutions of the given constraints. In constrained sampling, the task is to sample randomly, subject to a given weighting function, from the set of solutions to a set of given constraints. Consequently, Constrained counting and sampling have been subject to intense theoretical and empirical investigations over the years. Prior work, however, offered either heuristic techniques with poor guarantees of accuracy or approaches with proven guarantees but poor performance in practice. In this thesis, we introduce a novel hashing-based algorithmic framework for constrained sampling and counting that combines the classical algorithmic technique of universal hashing with the dramatic progress made in Boolean reasoning solving, in particular, {\SAT} and {\SMT}, over the past two decades. By exploiting the connection between definability of formulas and variance of the distribution of solutions in a cell defined by 3-universal hash functions, we introduced an algorithmic technique, {\MIS}, that reduced the size of XOR constraints employed in the underlying universal hash functions by as much as two orders of magnitude. The resulting frameworks for counting ( {\ScalApproxMC}) and sampling ({\UniGen}) can handle formulas with up to million variables representing a significant boost up from the prior state of the art tools' capability to handle few hundreds of variables. If the initial set of constraints is expressed as Disjunctive Normal Form (DNF), {\ScalApproxMC} is the only known Fully Polynomial Randomized Approximation Scheme (FPRAS) that does not involve Monte Carlo steps. We demonstrate the utility of the above techniques on various real applications including probabilistic inference, design verification and estimating the reliability of critical infrastructure networks during natural disasters. The high parallelizability of our approach opens up new directions for development of artificial intelligence tools that can effectively leverage high-performance computing resources.Item Cooperative Execution of Parallel Tasks with Synchronization Constraints(2015-10-14) Imam, Shams Mahmood; Sarkar, Vivek; Mellor-Crummey, John; Chaudhuri, Swarat; Zhong, LinThe topic of this thesis is the effective execution of parallel applications on emerging multicore and manycore systems in the presence of modern synchronization and coordination constraints. Synchronization and coordination can contribute significant productivity and performance overheads to the development and execution of parallel programs. Higher-level programming models, such as the Task Parallel Model and Actor Model, provide abstractions that can be used to simplify writing parallel programs, in contrast to lower-level programming models that directly expose locks, threads and processes. However, these higher-level models often lack efficient support for general synchronization patterns that are necessary for a wide range of applications. Many modern synchronization and coordination constructs in parallel programs can incur significant performance overheads on current runtime systems, or significant productivity overheads when the programmer is forced to complicate their code to mitigate these performance overheads. We believe that a cooperation between the programmer and the runtime system is necessary to reduce the parallel overhead and to execute the available parallelism efficiently in the presence of synchronization constraints. In a cooperative approach, an executing entity yields control to other entities at well-defined points during its execution. This thesis shows that the use of cooperative techniques is critical to performance and scalability of certain parallel programming models, especially in the presence of modern synchronization and coordination constraints such as asynchronous tasks, futures, phasers, data-driven tasks, and actors. In particular, we focus on cooperative extensions and runtimes for the async-finish Task Parallel Model and the Actor Model in this thesis. Our work shows that cooperative techniques simplify programmability and deliver significant performance improvements by reducing the overhead in modern parallel programming models.Item Corpus-Driven Systems for Program Synthesis and Refactoring(2019-04-18) Lu, Yanxin; Chaudhuri, SwaratProgramming is a difficult task. Programmers need to deal with small details inside overly complex computer programs. Sometimes it is inevitable for programmers to make small mistakes. To deal with this problem, software engineering techniques and formal method based techniques have been proposed to help facilitate programming. These techniques include various software engineering methodologies, design patterns, sophisticated testing methods, program repair algorithms, model checking algorithms, and program synthesis methods. In this thesis, we propose two additional corpus-driven systems for program synthesis and refactoring. We first introduce program splicing, a programming methodology that aims to automate the workflow of copying, pasting, and modifying code available online. Here, the programmer starts by writing a “draft” that mixes unfinished code, natural language comments, and correctness requirements. A program synthesizer that interacts with a large, searchable database of program snippets is used to automatically complete the draft into a program that meets the requirements. Our evaluation uses the system in a suite of everyday programming tasks, and includes a comparison with a state-of-the-art competing approach as well as a user study. The results point to the broad scope and scalability of program splicing and indicate that the approach can significantly boost programmer productivity. Next, we propose an algorithm that automates the process of API refactoring, where the goal is to rewrite an API call sequence into another sequence that only uses the API calls defined in the target library without modifying the functionality. We solve the problem of API refactoring by combining the techniques of API translation and API sequence synthesis. We evaluated our algorithm on a diverse set of benchmark problems, and our algorithm can refactor API sequences with high accuracy. In addition, we conducted a user study which indicates that our algorithm can help human developers with API refactoring.Item Differentiable Program Learning with an Admissible Neural Heuristic(2020-08-11) Shah, Ameesh; Jermaine, Chris; Chaudhuri, SwaratWe study the problem of learning differentiable functions expressed as programs in a domain-specific language. Such programmatic models can offer benefits such as composability and interpretability; however, learning them requires optimizing over a combinatorial space of program “architectures”. We frame this optimization problem as a search in a weighted graph whose paths encode top-down derivations of program syntax. Our key innovation is to view various classes of neural networks as continuous relaxations over the space of programs, which can then be used to complete any partial program. This relaxed program is differentiable and can be trained end-to-end, and the resulting training loss is an approximately admissible heuristic that can guide the combinatorial search. We instantiate our approach on top of the A* algorithm and an iteratively deepened branch-and-bound search, and use these algorithms to learn programmatic classifiers in three sequence classification tasks. Our experiments show that the algorithms outperform state-of-the-art methods for program learning, and that they discover programmatic classifiers that yield natural interpretations and achieve competitive accuracy.Item Habanero-Scala: A Hybrid Programming model integrating Fork/Join and Actor models(2013-07-24) Imam, Shams; Sarkar, Vivek; Cartwright, Robert S.; Chaudhuri, SwaratThis study presents a hybrid concurrent programming model combining the previously developed Fork-Join model (FJM) and Actor model (AM). With the advent of multi-core computers, there is a renewed interest in programming models that reduce the burden of reasoning about and writing efficient concurrent programs. The proposed hybrid model shows how the divide-and-conquer approach of the FJM and the no-shared mutable state and event-driven philosophy of the AM can be combined to solve certain classes of problems more efficiently and productively than either of the aforementioned models individually. The hybrid model adds actor creation and coordination to into the FJM, while also enabling parallelization within actors. This study uses the Habanero-Java and Scala programming languages as the base for the FJM and AM respectively, and provides an implementation of the hybrid model as an extension of the Scala language called Habanero-Scala. The hybrid model adds to the foundations of parallel programs, and to the tools available for the programmer to aid in productivity and performance while developing parallel software.Item Implementing Asynchronous Checkpoint/Restart for the Concurrent Collections Model(2014-08-12) Vrvilo, Nick; Sarkar, Vivek; Mellor-Crummey, John; Chaudhuri, SwaratIt has been claimed that what simplifies parallelism can also simplify resilience. Based on that assertion, we present the Concurrent Collections programming model (CnC) as an ideal target for a simple yet powerful resilience system for parallel computations. Specifically, we claim that the same attributes that simplify reasoning about parallel applications written in CnC will similarly simplify the implementation of a checkpoint/restart system within the CnC runtime. We define these properties of CnC in the context of a model built in K. To demonstrate how these simplifying properties of CnC help to simplify resilience, we have implemented a simple checkpoint/restart system within Rice’s Habanero C implementation of the CnC runtime. We show how the CnC runtime can fully encapsulate the checkpointing and restarting processes, allowing application programmers to gain all the benefits of resilience without any added effort beyond implementing the application in CnC, while avoiding the synchronization overheads present in traditional techniques.Item Improving Peer Evaluation Quality in Massive Open Online Courses(2015-05-26) Lu, Yanxin; Chaudhuri, Swarat; Warren, Joe; Jermaine, ChrisAs several online course providers such as Coursera, Udacity and edX emerged in 2012, Massive Open Online Courses (MOOCs) gained much attention across the globe. While MOOCs provide learning opportunities for many people, several challenges exist in the context of MOOC and one of those is how to ensure the quality of peer grading. Interactive Programming in Python course (IPP) that Rice has offered for a number of years on Coursera has suffered from the problem of low-quality peer evaluations. In this thesis, we propose our solution to improve the quality of peer evaluations by motivating peer graders. Specifically, we want to answer the question: when a student knows that his or her own peer grading efforts are being examined and they are able to grade other peer evaluations, do those tend to motivate the student to do a better job when grading assignments? We implemented a web application where students can grade peer evaluations and we also conduct a series of controlled experiments. Finally, we find a strong effect on peer evaluation quality simply because students know that they are going to be studied using a software that is supposed to help with peer grading. In addition, we find strong evidence that by grading peer evaluations students tend to give better peer evaluations. However, the strongest effect seems to be obtained via the act of grading others’ evaluations, and not from the knowledge that one’s own peer evaluation will be examined.Item Inductive Program Synthesis from Input-Output Examples(2016-04-21) Feser, Jack Killian; Chaudhuri, SwaratWe present a method for example-guided synthesis of higher-order functional pro- grams. Given a set of input-output examples, our method synthesizes a program in a functional language with higher-order combinators like map and fold. The synthesized program is guaranteed to be the simplest program in the language to fit the examples. Our approach combines three technical ideas: inductive generalization, deduction, and enumerative search. First, we generalize the input-output examples into hypotheses about the structure of the target program. For each hypothesis, we use deduction to infer new input-output examples for the missing subexpressions. This leads to a new subproblem where the goal is to synthesize expressions within each hypothesis. Since not every hypothesis can be realized into a program that fits the examples, we use a combination of best-first enumeration and deduction to search for a hypothesis that meets our needs. We have implemented our method in a tool called λ2, and we evaluate this tool on a large set of synthesis problems involving lists, trees, and nested data structures. The experiments demonstrate the scalability and broad scope of λ2. A highlight is the synthesis of a program believed to be the world’s earliest functional pearl.Item Learning Program Invariants from Proof Corpora(2018-04-13) Rahbar, Afsaneh; Chaudhuri, SwaratIn program verification, loop invariants are of particular interest. Indeed, writing a correct and useful invariant is as challenging as verifying the program itself. Current approaches to solving the problem of automatically generating invariants either generate invariants by analyzing the program or using machine learning to learn from program input and output examples, counterexamples, and so on. Each of these approaches works on particular type of programs and specific data structures. In this thesis, we describe the technique we have developed for generating these loop invariants automatically. We introduce a more general learning technique that learns from a database of annotated verified programs. Our new data-driven approach uses the existing proofs to learn proof templates, or as we call them proof blocks. In our method, the algorithm iterates over all possible proof block formulas by using logical connectors until it finds an appropriate invariant formula. We evaluated our approach on benchmarks and demonstrated the potential of our technique in verification of programs. Using the approach of learning from verified annotated programs makes invariant generation easier and reduces the burden on the verification engineer.Item Point-Based Policy Synthesis for POMDPs With Boolean and Quantitative Objectives(IEEE, 2019) Wang, Yue; Chaudhuri, Swarat; Kavraki, Lydia E.Effectively planning robust executions under uncertainty is critical for building autonomous robots. Partially observable Markov decision processes (POMDPs) provide a standard framework for modeling many robot applications under uncertainty. We study POMDPs with two kinds of objectives: (1) Boolean objectives for a correctness guarantee of accomplishing tasks and (2) quantitative objectives for optimal behaviors. For robotic domains that require both correctness and optimality, POMDPs with Boolean and quantitative objectives are natural formulations. We present a practical policy synthesis approach for POMDPs with Boolean and quantitative objectives by combining policy iteration and policy synthesis for POMDPs with only Boolean objectives. To improve efficiency, our approach produces approximate policies by performing the point-based backup on a small set of representative beliefs. Despite being approximate, our approach maintains validity (satisfying Boolean objectives) and guarantees improved policies at each iteration before termination. Moreover, the error due to approximation is bounded. We evaluate our approach in several robotic domains. The results show that our approach produces good approximate policies that guarantee task completion.Item Regular Real Analysis(Association for Computing Machinery, 2013) Chaudhuri, Swarat; Sankaranarayanan, Sriram; Vardi, Moshe Y.We initiate the study of regular real analysis, or the analysis of real functions that can be encoded by automata on infinite words. It is known that ω-automata can be used to represent {relations} between real vectors, reals being represented in exact precision as infinite streams. The regular functions studied here constitute the functional subset of such relations. We show that some classic questions in function analysis can become elegantly computable in the context of regular real analysis. Specifically, we present an automata-theoretic technique for reasoning about limit behaviors of regular functions, and obtain, using this method, a decision procedure to verify the continuity of a regular function. Several other decision procedures for regular functions-for finding roots, fix points, minima, etc.-are also presented. At the same time, we show that the class of regular functions is quite rich, and includes functions that are highly challenging to encode using traditional symbolic notation.Item Robot Manipulation Planning Under Linear Temporal Logic Specifications(2015-12-07) He, Keliang; Kavraki, Lydia E; Vardi, Moshe Y; Chaudhuri, SwaratAutomated planning for manipulation tasks is highly desirable, for it enables robot manipulators to be used by none robotics experts. This thesis presents one approach to solving manipulation planning for tasks expressed in linear temporal logic (ltl). This approach is based on the synergistic framework, which provides probabilistic completeness guarantees. Even though the synergistic framework has shown to work well for planning for ltl tasks in the navigation domain, it lacked an abstraction that can capture the high dimensionality of manipulation. This thesis enables manipulation planning using the synergistic framework by introducing a manipulation abstraction and modifying the interaction between task and motion planning in the framework. The modified framework is shown to be effectively in case studies in both simulation and physical systems. The case studies also show that the synergistic framework plans for manipulation problems more effective using the manipulation abstraction in comparison with a naive abstraction.