499 research outputs found
Characterization of homologs of the small RNA SgrS reveals diversity in function
SgrS is a small RNA (sRNA) that requires the RNA chaperone Hfq for its function. SgrS is a unique dual-function sRNA with a base pairing function that regulates mRNA targets and an mRNA function that allows production of the 43-amino-acid protein SgrT. SgrS is expressed when non-metabolizable sugars accumulate intracellularly (glucose-phosphate stress) and is required to allow Escherichia coli cells to recover from stress. In this study, homologs of SgrS were used to complement an E. coli sgrS mutant in order elucidate the physiological relevance of differences among homologs. These analyses revealed that the base pairing function of E. coli and Yersinia pestis SgrS homologs is critical for rescue from glucose-phosphate stress. In contrast, base pairing-deficient SgrS homologs from Salmonella typhimurium, Erwinia carotovora and Klebsiella pneumoniae rescue E. coli cells from stress despite their failure to regulate target mRNAs. Compared with E. coli SgrS, S. typhimurium SgrS produces more SgrT and this rescues cell growth even when the base pairing function is inactivated. Genetic evidence suggests that a secondary structure in the E. coli SgrS 5′ region inhibits sgrT translation. This structure is not present in S. typhimurium SgrS, which explains its higher level of SgrT production
Liveness-Based Garbage Collection for Lazy Languages
We consider the problem of reducing the memory required to run lazy
first-order functional programs. Our approach is to analyze programs for
liveness of heap-allocated data. The result of the analysis is used to preserve
only live data---a subset of reachable data---during garbage collection. The
result is an increase in the garbage reclaimed and a reduction in the peak
memory requirement of programs. While this technique has already been shown to
yield benefits for eager first-order languages, the lack of a statically
determinable execution order and the presence of closures pose new challenges
for lazy languages. These require changes both in the liveness analysis itself
and in the design of the garbage collector.
To show the effectiveness of our method, we implemented a copying collector
that uses the results of the liveness analysis to preserve live objects, both
evaluated (i.e., in WHNF) and closures. Our experiments confirm that for
programs running with a liveness-based garbage collector, there is a
significant decrease in peak memory requirements. In addition, a sizable
reduction in the number of collections ensures that in spite of using a more
complex garbage collector, the execution times of programs running with
liveness and reachability-based collectors remain comparable
A Proof Strategy Language and Proof Script Generation for Isabelle/HOL
We introduce a language, PSL, designed to capture high level proof strategies
in Isabelle/HOL. Given a strategy and a proof obligation, PSL's runtime system
generates and combines various tactics to explore a large search space with low
memory usage. Upon success, PSL generates an efficient proof script, which
bypasses a large part of the proof search. We also present PSL's monadic
interpreter to show that the underlying idea of PSL is transferable to other
ITPs.Comment: This paper has been submitted to CADE2
Combining Static and Dynamic Contract Checking for Curry
Static type systems are usually not sufficient to express all requirements on
function calls. Hence, contracts with pre- and postconditions can be used to
express more complex constraints on operations. Contracts can be checked at run
time to ensure that operations are only invoked with reasonable arguments and
return intended results. Although such dynamic contract checking provides more
reliable program execution, it requires execution time and could lead to
program crashes that might be detected with more advanced methods at compile
time. To improve this situation for declarative languages, we present an
approach to combine static and dynamic contract checking for the functional
logic language Curry. Based on a formal model of contract checking for
functional logic programming, we propose an automatic method to verify
contracts at compile time. If a contract is successfully verified, dynamic
checking of it can be omitted. This method decreases execution time without
degrading reliable program execution. In the best case, when all contracts are
statically verified, it provides trust in the software since crashes due to
contract violations cannot occur during program execution.Comment: Pre-proceedings paper presented at the 27th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2017), Namur,
Belgium, 10-12 October 2017 (arXiv:1708.07854
Uniqueness Typing for Resource Management in Message-Passing Concurrency
We view channels as the main form of resources in a message-passing
programming paradigm. These channels need to be carefully managed in settings
where resources are scarce. To study this problem, we extend the pi-calculus
with primitives for channel allocation and deallocation and allow channels to
be reused to communicate values of different types. Inevitably, the added
expressiveness increases the possibilities for runtime errors. We define a
substructural type system which combines uniqueness typing and affine typing to
reject these ill-behaved programs
A semantical approach to equilibria and rationality
Game theoretic equilibria are mathematical expressions of rationality.
Rational agents are used to model not only humans and their software
representatives, but also organisms, populations, species and genes,
interacting with each other and with the environment. Rational behaviors are
achieved not only through conscious reasoning, but also through spontaneous
stabilization at equilibrium points.
Formal theories of rationality are usually guided by informal intuitions,
which are acquired by observing some concrete economic, biological, or network
processes. Treating such processes as instances of computation, we reconstruct
and refine some basic notions of equilibrium and rationality from the some
basic structures of computation.
It is, of course, well known that equilibria arise as fixed points; the point
is that semantics of computation of fixed points seems to be providing novel
methods, algebraic and coalgebraic, for reasoning about them.Comment: 18 pages; Proceedings of CALCO 200
Liberal Typing for Functional Logic Programs
We propose a new type system for functional logic programming which is more liberal than the classical Damas-Milner usually adopted, but it is also restrictive enough to ensure type soundness. Starting from Damas-Milner typing of expressions we propose a new notion of well-typed program that adds support for type-indexed functions, existential types, opaque higher-order patterns and generic functions-as shown by an extensive collection of examples that illustrate the possibilities of our proposal. In the negative side, the types of functions must be declared, and therefore types are checked but not inferred. Another consequence is that parametricity is lost, although the impact of this flaw is limited as "free theorems" were already compromised in functional logic programming because of non-determinism
A New Linear Logic for Deadlock-Free Session-Typed Processes
The π -calculus, viewed as a core concurrent programming language, has been used as the target of much research on type systems for concurrency. In this paper we propose a new type system for deadlock-free session-typed π -calculus processes, by integrating two separate lines of work. The first is the propositions-as-types approach by Caires and Pfenning, which provides a linear logic foundation for session types and guarantees deadlock-freedom by forbidding cyclic process connections. The second is Kobayashi’s approach in which types are annotated with priorities so that the type system can check whether or not processes contain genuine cyclic dependencies between communication operations. We combine these two techniques for the first time, and define a new and more expressive variant of classical linear logic with a proof assignment that gives a session type system with Kobayashi-style priorities. This can be seen in three ways: (i) as a new linear logic in which cyclic structures can be derived and a CYCLE -elimination theorem generalises CUT -elimination; (ii) as a logically-based session type system, which is more expressive than Caires and Pfenning’s; (iii) as a logical foundation for Kobayashi’s system, bringing it into the sphere of the propositions-as-types paradigm
- …