Departmental Papers (CIS)
Our faculty have research activities across many areas of computer science and are from schools throughout Penn, including Penn Engineering and the School of Arts and Sciences. For more information about CIS research, visit our research areas page.
Search results
Publication CurveQuad: A Centimeter-Scale Origami Quadruped that Leverages Curved Creases to Self-Fold and Crawl with One Motor(IEEE/RSJ, 2023-10-01) Feshbach, Daniel AdamWe present CurveQuad, a miniature curved origami quadruped that is able to self-fold and unfold, crawl, and steer, all using a single actuator. CurveQuad is designed for planar manufacturing, with parts that attach and stack sequentially on a flat body. The design uses 4 curved creases pulled by 2 pairs of tendons from opposite ends of a link on a 270° servo. It is 8 cm in the longest direction and weighs 10.9 g. Rotating the horn pulls the tendons inwards to induce folding. Continuing to rotate the horn shears the robot, enabling the robot to shuffle forward while turning in either direction. We experimentally validate the robot's ability to fold, steer, and unfold by changing the magnitude of horn rotation. We also demonstrate basic feedback control by steering towards a light source from a variety of starting positions and orientations, and swarm aggregation by having 4 robots simultaneously steer towards the light. The results demonstrate the potential of using curved crease origami in self-assembling and deployable robots with complex motions such as locomotion.Publication Lessons Learned from a PLTL-CS Program(2011-01-01) Murphy, Christian; Powell, Rita; Parton, Kristen; Cannon, AdamThe Peer-Led Team Learning (PLTL) approach has previously been shown to be effective in recruiting and retaining students, particularly under-represented students, in undergraduate introductory CS courses. In PLTL, small groups of students are led by an undergraduate peer and work together to solve problems related to CS. At Columbia University, the Columbia Emerging Scholars Program has used PLTL in an effort to increase enrollment in CS courses beyond the introductory level, and to increase the number of students who select Computer Science as their major, by demonstrating that CS is necessarily a collaborative activity that focuses more on problem solving and algorithmic thinking than on programming. Over the past five semesters, 68 students have completed the program, and preliminary results indicate that this program has had a positive effect on increasing participation in the major. This paper discusses our experiences of building and expanding the Columbia Emerging Scholars program, and addresses such topics as recruiting, training, scheduling, student behavior, and evaluation. We expect that this paper will provide a valuable set of lessons learned to other educators who seek to launch or grow a PLTL program at their institution as well.Publication A Clustering Coefficient Network Formation Game(2011-10-04) Brautbar, Michael; Kearns, Michael JSocial and other networks have been shown empirically to exhibit high edge clustering: that is, the density of local neighborhoods, as measured by the clustering coefficient, is often much larger than the overall edge density of the network. In social networks, a desire for tightknit circles of friendships the colloquial social clique is often cited as the primary driver of such structure. We introduce and analyze a new network formation game in which rational players must balance edge purchases with a desire to maximize their own clustering coefficient. Our results include the following: -Construction of a number of specific families of equilibrium networks, including ones showing that equilibria can have rather general binary tree-like structure, including highly asymmetric binary trees. This is in contrast to other network formation games that yield only symmetric equilibrium networks. Our equilibria also include ones with large or small diameter, and ones with wide variance of degrees. -A general characterization of (non-degenerate) equilibrium networks, showing that such networks are always sparse and paid for by low degree vertices, whereas high-degree "free riders" always have low utility. -A proof that for edge cost a ¥ 1/2 the Price of Anarchy grows linearly with the population size n while for edge cost less than 1/2, the Price of Anarchy of the formation game is bounded by a constant depending only on, and independent of n. Moreover, an explicit upper bound is constructed when the edge cost is a simple rational (small numerator) less than 1/2. -A proof that for edge cost less than 1=2 the average vertex clustering coefficient grows at least as fast as a function depending only on, while the overall edge density goes to zero at a rate inversely proportional to the number of vertices in the network. -Results establishing the intractability of even weakly approximating best response computations. Several of our results hold even for weaker notions of equilibrium, such as those based on link stability.Publication Binders Unbound(2011-09-19) Weirich, Stephanie; Yorgey, Brent A; Sheard, TimImplementors of compilers, program refactorers, theorem provers, proof checkers, and other systems that manipulate syntax know that dealing with name binding is difficult to do well. Operations such as -equivalence and capture-avoiding substitution seem simple, yet subtle bugs often go undetected. Furthermore, their implementations are tedious, requiring boilerplate code that must be updated whenever the object language definition changes. Many researchers have therefore sought to specify binding syntax declaratively, so that tools can correctly handle the details behind the scenes. This idea has been the inspiration for many new systems (such as Beluga, Delphin, FreshML, FreshOCaml, C ml, FreshLib, and Ott) but there is still room for improvement in expressivity, simplicity and convenience. In this paper, we present a new domain-specific language, UNBOUND, for specifying binding structure. Our language is particularly expressive it supports multiple atom types, pattern binders, type annotations, recursive binders, and nested binding (necessary for telescopes, a feature found in dependently-typed languages). However, our specification language is also simple, consisting of just five basic combinators. We provide a formal semantics for this language derived from a locally nameless representation and prove that it satisfies a number of desirable properties. We also present an implementation of our binding specification language as a GHC Haskell library implementing an embedded domain specific language (EDSL). By using Haskell type constructors to represent binding combinators, we implement the EDSL succinctly using datatype-generic programming. Our implementation supports a number of features necessary for practical programming, including flexibility in the treatment of user-defined types, best effort name preservation (for error messages), and integration with Haskell's monad transformer library.Publication A Temporal Logic Based Theory of Test Coverage and Generation(2002-04-08) Lee, Insup; Hong, Hyoung Seok; Sokolsky, Oleg; Ural, HasanThis paper presents a theory of test coverage and generation from specifications written in extended finite state machines (EFSMs). We investigate a family of coverage criteria based on the information of control flow and data flow in EFSMs and characterize them using the temporal logic CTL. We discuss the complexity of minimal cost test generation and describe a simple heuristic which uses the capability of model checkers to construct counterexamples. Our approach extends the range of applications of model checking from automatic verification of finite state systems to automatic test generation from finite state systems.Publication Computational Analysis of Run-time Monitoring: Fundamentals of Java-MaC(2002-07-26) Kannan, Sampath; Lee, Insup; Kim, Moonjoo; Sokolsky, Oleg; Viswanathan, MaheshA run-time monitor shares computational resources, such as memory and CPU time, with the target program. Furthermore, heavy computation performed by a monitor for checking target program's execution with respect to requirement properties can be a bottleneck to the target program's execution. Therefore, computational characteristics of run-time monitoring cause a significant impact on the target program's execution. We investigate computational issues on run-time monitoring. The first issue is the power of run-time monitoring. In other words, we study the class of properties run-time monitoring can evaluate. The second issue is computational complexity of evaluating properties written in process algebraic language. Third, we discuss sound abstraction of the target program's execution, which does not change the result of property evaluation. This abstraction can be used as a technique to reduce monitoring overhead. Theoretical understanding obtained from these issues affects the implementation of Java-MaC, a toolset for the run-time monitoring and checking of Java programs. Finally, we demonstrate the abstraction-based overhead reduction technique implemented in Java-MaC through a case study.Publication Monitoring, Checking, and Steering of Real-Time Systems(2002-07-26) Lee, Insup; Kim, Moonjoo; Sammapun, Usa; Sokolsky, Oleg; Shin, JangwooThe MaC system has been developed to provide assurance that a target program is running correctly with respect to formal requirements specification. This is achieved by monitoring and checking the execution of the target program at run-time. MaC bridges the gap between formal verification, which ensures the correctness of a design rather than an implementation, and testing, which only partially validates an implementation. One weakness of the MaC system is that it can detect property violations but cannot provide any feedback to the running system. To remedy this weakness, the MaC system has been extended with a feedback capability. The resulting system is called MaCS (Monitoring and Checking with Steering). The feedback component uses the information collected during monitoring and checking to steer the application back to a safe state after an error occurs. We present a case study where MaCS is used in a control system that keeps an inverted pendulum upright. MaCS detects faults in controllers and performs dynamic reconfiguration of the control system using steering.Publication A General Resource Framework for Real-Time Systems(2002-10-08) Lee, Insup; Sokolsky, Oleg; Philippou, AnnaThe paper describes a formal framework for designing and reasoning about resource-constrained systems. The framework is based on a series of process algebraic formalisms which have been previously developed to describe and analyze various aspects of real-time communicating, concurrent systems. We develop a uniform framework for formal treatment of resources and demonstrate how previous work fits into the new framework.Publication Realizability and Verification of MSC Graphs(2005-02-15) Alur, Rajeev; Etessami, Kousha; Yannakakis, MihalisScenario-based specifications such as message sequence charts (MSC) offer an intuitive and visual way to describe design requirements. MSC-graphs allow convenient expression of multiple scenarios, and can be viewed as an early model of the system that can be subjected to a variety of analyses. Problems such as LTL model checking are undecidable for MSC-graphs in general, but are known to be decidable for the class of bounded MSC-graphs. Our first set of results concerns checking realizability of bounded MSC-graphs. An MSC-graph is realizable if there is a distributed implementation that generates precisely the behaviors in the graph. There are two notions of realizability, weak and safe, depending on whether or not we require the implementation to be deadlock-free. It is known that for a finite set of MSCs, weak realizability is coNP-complete while safe realizability has a polynomial-time solution. We establish that for bounded MSC-graphs, weak realizability is, surprisingly, undecidable, while safe realizability is in EXPSPACE. Our second set of results concerns verification of MSC-graphs. While checking properties of a graph G, besides verifying all the scenarios in the set L(G) of MSCs specified by G, it is desirable to verify all the scenarios in the set Lw(G)--the closure of G, that contains the implied scenarios that any distributed implementation of G must include. For checking whether a given MSC M is a possible behavior, checking M ∈ L(G) is NP-complete, but checking M ∈ Lw(G) has a quadratic solution. For temporal logic specifications, considering the closure makes the verification problem harder: while checking LTL properties of L(G) is PSPACE-complete for bounded graphs G, checking even simple "local" properties of Lw(G) is undecidable.Publication Sound Code Generation from Communicating Hybrid Models(2004-03-25) Hur, Yerang; Kim, Jesung; Lee, Insup; Choi, Jin-YoungPrecise translation from hybrid models to code is difficult because models are defined in the continuous-time domain whereas code executes on digital computers in a discrete fashion. Traditional approach is to associate the model with a sampling rate before code generation, and rely on an approximate algorithm that computes the next state numerically. Depending on the choice of the sampling rate and the algorithm, the behavior of the code may vary significantly due to numerical errors, but the discrepancy has been addressed informally, making the analysis results at the model level less meaningful for implementation. Formal relationship between the model and the code becomes even more unclear when components of the code execute concurrently. In this paper, we propose a formal framework that addresses the issue of soundness of concurrent programs generated from communicating hybrid models. The motivation is that concurrent programs executing in different rates may cause an erroneous transition when transition conditions are evaluated using values from different time instances. The essence of our technique is to refine the model by tightening transition conditions according to the maximum errors due to different sampling rates. We claim that the generated code has a trace of discrete transitions that is equivalent to one of the traces observable from the model, and that the values of variables are bounded. Our framework demonstrates how hybrid models defined in the continuous time domain are translated into discretized models with or without consideration of errors due to asynchronous sampling, and finally into executable code with real-time scheduling.