---
_id: '4253'
abstract:
- lang: eng
text: We consider a single genetic locus which carries two alleles, labelled P and
Q. This locus experiences selection and mutation. It is linked to a second neutral
locus with recombination rate r. If r = 0, this reduces to the study of a single
selected locus. Assuming a Moran model for the population dynamics, we pass to
a diffusion approximation and, assuming that the allele frequencies at the selected
locus have reached stationarity, establish the joint generating function for the
genealogy of a sample from the population and the frequency of the P allele. In
essence this is the joint generating function for a coalescent and the random
background in which it evolves. We use this to characterize, for the diffusion
approximation, the probability of identity in state at the neutral locus of a
sample of two individuals (whose type at the selected locus is known) as solutions
to a system of ordinary differential equations. The only subtlety is to find the
boundary conditions for this system. Finally, numerical examples are presented
that illustrate the accuracy and predictions of the diffusion approximation. In
particular, a comparison is made between this approach and one in which the frequencies
at the selected locus are estimated by their value in the absence of fluctuations
and a classical structured coalescent model is used.
author:
- first_name: Nicholas H
full_name: Nicholas Barton
id: 4880FE40-F248-11E8-B48F-1D18A9856A87
last_name: Barton
orcid: 0000-0002-8548-5240
- first_name: Alison
full_name: Etheridge, Alison M
last_name: Etheridge
- first_name: Anja
full_name: Sturm, Anja K
last_name: Sturm
citation:
ama: Barton NH, Etheridge A, Sturm A. Coalescence in a Random Background. Annals
of Applied Probability. 2004;14(2):754-785.
apa: Barton, N. H., Etheridge, A., & Sturm, A. (2004). Coalescence in a Random
Background. Annals of Applied Probability. Institute of Mathematical Statistics.
chicago: Barton, Nicholas H, Alison Etheridge, and Anja Sturm. “Coalescence in a
Random Background.” Annals of Applied Probability. Institute of Mathematical
Statistics, 2004.
ieee: N. H. Barton, A. Etheridge, and A. Sturm, “Coalescence in a Random Background,”
Annals of Applied Probability, vol. 14, no. 2. Institute of Mathematical
Statistics, pp. 754–785, 2004.
ista: Barton NH, Etheridge A, Sturm A. 2004. Coalescence in a Random Background.
Annals of Applied Probability. 14(2), 754–785.
mla: Barton, Nicholas H., et al. “Coalescence in a Random Background.” Annals
of Applied Probability, vol. 14, no. 2, Institute of Mathematical Statistics,
2004, pp. 754–85.
short: N.H. Barton, A. Etheridge, A. Sturm, Annals of Applied Probability 14 (2004)
754–785.
date_created: 2018-12-11T12:07:52Z
date_published: 2004-05-01T00:00:00Z
date_updated: 2021-01-12T07:55:38Z
day: '01'
extern: 1
intvolume: ' 14'
issue: '2'
main_file_link:
- open_access: '0'
url: http://www.jstor.org/stable/4140427
month: '05'
page: 754 - 785
publication: Annals of Applied Probability
publication_status: published
publisher: Institute of Mathematical Statistics
publist_id: '1842'
quality_controlled: 0
status: public
title: Coalescence in a Random Background
type: journal_article
volume: 14
year: '2004'
...
---
_id: '4372'
acknowledgement: This work was partially supported by the EC projects IST-2001-33520
CC (Control and Computation), IST-2001-35302 AMETIST (Advanced Methods for Timed
Systems) and IST-2003-507219 PROSYD (Property-Based System Design).
alternative_title:
- LNCS
article_processing_charge: No
author:
- first_name: Oded
full_name: Maler, Oded
last_name: Maler
- first_name: Dejan
full_name: Nickovic, Dejan
id: 41BCEE5C-F248-11E8-B48F-1D18A9856A87
last_name: Nickovic
citation:
ama: 'Maler O, Nickovic D. Monitoring Temporal Properties of Continuous Signals.
In: Springer; 2004:152-166. doi:10.1007/978-3-540-30206-3_12'
apa: 'Maler, O., & Nickovic, D. (2004). Monitoring Temporal Properties of Continuous
Signals (pp. 152–166). Presented at the FORMATS: Formal Modeling and Analysis
of Timed Systems, Springer. https://doi.org/10.1007/978-3-540-30206-3_12'
chicago: Maler, Oded, and Dejan Nickovic. “Monitoring Temporal Properties of Continuous
Signals,” 152–66. Springer, 2004. https://doi.org/10.1007/978-3-540-30206-3_12.
ieee: 'O. Maler and D. Nickovic, “Monitoring Temporal Properties of Continuous Signals,”
presented at the FORMATS: Formal Modeling and Analysis of Timed Systems, 2004,
pp. 152–166.'
ista: 'Maler O, Nickovic D. 2004. Monitoring Temporal Properties of Continuous Signals.
FORMATS: Formal Modeling and Analysis of Timed Systems, LNCS, , 152–166.'
mla: Maler, Oded, and Dejan Nickovic. Monitoring Temporal Properties of Continuous
Signals. Springer, 2004, pp. 152–66, doi:10.1007/978-3-540-30206-3_12.
short: O. Maler, D. Nickovic, in:, Springer, 2004, pp. 152–166.
conference:
name: 'FORMATS: Formal Modeling and Analysis of Timed Systems'
date_created: 2018-12-11T12:08:31Z
date_published: 2004-12-14T00:00:00Z
date_updated: 2025-06-26T09:05:17Z
day: '14'
doi: 10.1007/978-3-540-30206-3_12
extern: '1'
language:
- iso: eng
month: '12'
oa_version: None
page: 152 - 166
publication_status: published
publisher: Springer
publist_id: '1088'
quality_controlled: '1'
scopus_import: '1'
status: public
title: Monitoring Temporal Properties of Continuous Signals
type: conference
user_id: 2DF688A6-F248-11E8-B48F-1D18A9856A87
year: '2004'
...
---
_id: '4424'
abstract:
- lang: eng
text: "The enormous cost and ubiquity of software errors necessitates the need for
techniques and tools that can precisely analyze large systems and prove that they
meet given specifications, or if they don't, return counterexample behaviors showing
how the system fails. Recent advances in model checking, decision procedures,
program analysis and type systems, and a shift of focus to partial specifications
common to several systems (e.g., memory safety and race freedom) have resulted
in several practical verification methods. However, these methods are either precise
or they are scalable, depending on whether they track the values of variables
or only a fixed small set of dataflow facts (e.g., types), and are usually insufficient
for precisely verifying large programs.\r\n\r\nWe describe a new technique called
Lazy Abstraction (LA) which achieves both precision and scalability by localizing
the use of precise information. LA automatically builds, explores and refines
a single abstract model of the program in a way that different parts of the model
exhibit different degrees of precision, namely just enough to verify the desired
property. The algorithm automatically mines the information required by partitioning
mechanical proofs of unsatisfiability of spurious counterexamples into Craig Interpolants.
For multithreaded systems, we give a new technique based on analyzing the behavior
of a single thread executing in a context which is an abstraction of the other
(arbitrarily many) threads. We define novel context models and show how to automatically
infer them and analyze the full system (thread + context) using LA.\r\n\r\nLA
is implemented in BLAST. We have run BLAST on Windows and Linux Device Drivers
to verify API conformance properties, and have used it to find (or guarantee the
absence of) data races in multithreaded Networked Embedded Systems (NESC) applications.
BLAST is able to prove the absence of races in several cases where earlier methods,
which depend on lock-based synchronization, fail."
article_processing_charge: No
author:
- first_name: Ranjit
full_name: Jhala, Ranjit
last_name: Jhala
citation:
ama: Jhala R. Program verification by lazy abstraction. 2004:1-165.
apa: Jhala, R. (2004). Program verification by lazy abstraction. University
of California, Berkeley.
chicago: Jhala, Ranjit. “Program Verification by Lazy Abstraction.” University of
California, Berkeley, 2004.
ieee: R. Jhala, “Program verification by lazy abstraction,” University of California,
Berkeley, 2004.
ista: Jhala R. 2004. Program verification by lazy abstraction. University of California,
Berkeley.
mla: Jhala, Ranjit. Program Verification by Lazy Abstraction. University
of California, Berkeley, 2004, pp. 1–165.
short: R. Jhala, Program Verification by Lazy Abstraction, University of California,
Berkeley, 2004.
date_created: 2018-12-11T12:08:47Z
date_published: 2004-12-01T00:00:00Z
date_updated: 2021-01-12T07:56:52Z
day: '01'
extern: '1'
language:
- iso: eng
month: '12'
oa_version: None
page: 1 - 165
publication_status: published
publisher: University of California, Berkeley
publist_id: '307'
status: public
supervisor:
- first_name: Thomas A
full_name: Henzinger, Thomas A
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000-0002-2985-7724
title: Program verification by lazy abstraction
type: dissertation
user_id: 2DF688A6-F248-11E8-B48F-1D18A9856A87
year: '2004'
...
---
_id: '4445'
abstract:
- lang: eng
text: We present a type system for E code, which is an assembly language that manages
the release, interaction, and termination of real-time tasks. E code specifies
a deadline for each task, and the type system ensures that the deadlines are path-insensitive.
We show that typed E programs allow, for given worst-case execution times of tasks,
a simple schedulability analysis. Moreover, the real-time programming language
Giotto can be compiled into typed E~code. This shows that typed E~code identifies
an easily schedulable yet expressive class of real-time programs. We have extended
the Giotto compiler to generate typed E code, and enabled the run-time system
for E code to perform a type and schedulability check before executing the code.
acknowledgement: This research was supported in part by the AFOSR MURI grant F49620-00-1-0327
and by the NSF grants CCR- 0208875 and CCR-0225610.
author:
- first_name: Thomas A
full_name: Thomas Henzinger
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000−0002−2985−7724
- first_name: Christoph
full_name: Kirsch, Christoph M
last_name: Kirsch
citation:
ama: 'Henzinger TA, Kirsch C. A typed assembly language for real-time programs.
In: ACM; 2004:104-113. doi:10.1145/1017753.1017774'
apa: 'Henzinger, T. A., & Kirsch, C. (2004). A typed assembly language for real-time
programs (pp. 104–113). Presented at the EMSOFT: Embedded Software , ACM. https://doi.org/10.1145/1017753.1017774'
chicago: Henzinger, Thomas A, and Christoph Kirsch. “A Typed Assembly Language for
Real-Time Programs,” 104–13. ACM, 2004. https://doi.org/10.1145/1017753.1017774.
ieee: 'T. A. Henzinger and C. Kirsch, “A typed assembly language for real-time programs,”
presented at the EMSOFT: Embedded Software , 2004, pp. 104–113.'
ista: 'Henzinger TA, Kirsch C. 2004. A typed assembly language for real-time programs.
EMSOFT: Embedded Software , 104–113.'
mla: Henzinger, Thomas A., and Christoph Kirsch. A Typed Assembly Language for
Real-Time Programs. ACM, 2004, pp. 104–13, doi:10.1145/1017753.1017774.
short: T.A. Henzinger, C. Kirsch, in:, ACM, 2004, pp. 104–113.
conference:
name: 'EMSOFT: Embedded Software '
date_created: 2018-12-11T12:08:53Z
date_published: 2004-09-01T00:00:00Z
date_updated: 2021-01-12T07:57:01Z
day: '01'
doi: 10.1145/1017753.1017774
extern: 1
month: '09'
page: 104 - 113
publication_status: published
publisher: ACM
publist_id: '285'
quality_controlled: 0
status: public
title: A typed assembly language for real-time programs
type: conference
year: '2004'
...
---
_id: '4458'
abstract:
- lang: eng
text: 'The success of model checking for large programs depends crucially on the
ability to efficiently construct parsimonious abstractions. A predicate abstraction
is parsimonious if at each control location, it specifies only relationships between
current values of variables, and only those which are required for proving correctness.
Previous methods for automatically refining predicate abstractions until sufficient
precision is obtained do not systematically construct parsimonious abstractions:
predicates usually contain symbolic variables, and are added heuristically and
often uniformly to many or all control locations at once. We use Craig interpolation
to efficiently construct, from a given abstract error trace which cannot be concretized,
a parsominous abstraction that removes the trace. At each location of the trace,
we infer the relevant predicates as an interpolant between the two formulas that
define the past and the future segment of the trace. Each interpolant is a relationship
between current values of program variables, and is relevant only at that particular
program location. It can be found by a linear scan of the proof of infeasibility
of the trace.We develop our method for programs with arithmetic and pointer expressions,
and call-by-value function calls. For function calls, Craig interpolation offers
a systematic way of generating relevant predicates that contain only the local
variables of the function and the values of the formal parameters when the function
was called. We have extended our model checker Blast with predicate discovery
by Craig interpolation, and applied it successfully to C programs with more than
130,000 lines of code, which was not possible with approaches that build less
parsimonious abstractions.'
author:
- first_name: Thomas A
full_name: Thomas Henzinger
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000−0002−2985−7724
- first_name: Ranjit
full_name: Jhala, Ranjit
last_name: Jhala
- first_name: Ritankar
full_name: Majumdar, Ritankar S
last_name: Majumdar
- first_name: Kenneth
full_name: McMillan, Kenneth L
last_name: Mcmillan
citation:
ama: 'Henzinger TA, Jhala R, Majumdar R, Mcmillan K. Abstractions from proofs. In:
ACM; 2004:232-244. doi:10.1145/964001.964021'
apa: 'Henzinger, T. A., Jhala, R., Majumdar, R., & Mcmillan, K. (2004). Abstractions
from proofs (pp. 232–244). Presented at the POPL: Principles of Programming Languages,
ACM. https://doi.org/10.1145/964001.964021'
chicago: Henzinger, Thomas A, Ranjit Jhala, Ritankar Majumdar, and Kenneth Mcmillan.
“Abstractions from Proofs,” 232–44. ACM, 2004. https://doi.org/10.1145/964001.964021.
ieee: 'T. A. Henzinger, R. Jhala, R. Majumdar, and K. Mcmillan, “Abstractions from
proofs,” presented at the POPL: Principles of Programming Languages, 2004, pp.
232–244.'
ista: 'Henzinger TA, Jhala R, Majumdar R, Mcmillan K. 2004. Abstractions from proofs.
POPL: Principles of Programming Languages, 232–244.'
mla: Henzinger, Thomas A., et al. Abstractions from Proofs. ACM, 2004, pp.
232–44, doi:10.1145/964001.964021.
short: T.A. Henzinger, R. Jhala, R. Majumdar, K. Mcmillan, in:, ACM, 2004, pp. 232–244.
conference:
name: 'POPL: Principles of Programming Languages'
date_created: 2018-12-11T12:08:57Z
date_published: 2004-04-01T00:00:00Z
date_updated: 2021-01-12T07:57:06Z
day: '01'
doi: 10.1145/964001.964021
extern: 1
month: '04'
page: 232 - 244
publication_status: published
publisher: ACM
publist_id: '270'
quality_controlled: 0
status: public
title: Abstractions from proofs
type: conference
year: '2004'
...
---
_id: '4459'
abstract:
- lang: eng
text: Software model checking has been successful for sequential programs, where
predicate abstraction offers suitable models, and counterexample-guided abstraction
refinement permits the automatic inference of models. When checking concurrent
programs, we need to abstract threads as well as the contexts in which they execute.
Stateless context models, such as predicates on global variables, prove insufficient
for showing the absence of race conditions in many examples. We therefore use
richer context models, which combine (1) predicates for abstracting data state,
(2) control flow quotients for abstracting control state, and (3) counters for
abstracting an unbounded number of threads. We infer suitable context models automatically
by a combination of counterexample-guided abstraction refinement, bisimulation
minimization, circular assume-guarantee reasoning, and parametric reasoning about
an unbounded number of threads. This algorithm, called CIRC, has been implemented
in BLAST and succeeds in checking many examples of NESC code for data races. In
particular, BLAST proves the absence of races in several cases where previous
race checkers give false positives.
author:
- first_name: Thomas A
full_name: Thomas Henzinger
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000−0002−2985−7724
- first_name: Ranjit
full_name: Jhala, Ranjit
last_name: Jhala
- first_name: Ritankar
full_name: Majumdar, Ritankar S
last_name: Majumdar
citation:
ama: 'Henzinger TA, Jhala R, Majumdar R. Race checking by context inference. In:
ACM; 2004:1-13. doi:10.1145/996841.996844'
apa: 'Henzinger, T. A., Jhala, R., & Majumdar, R. (2004). Race checking by context
inference (pp. 1–13). Presented at the PLDI: Programming Languages Design and
Implementation, ACM. https://doi.org/10.1145/996841.996844'
chicago: Henzinger, Thomas A, Ranjit Jhala, and Ritankar Majumdar. “Race Checking
by Context Inference,” 1–13. ACM, 2004. https://doi.org/10.1145/996841.996844.
ieee: 'T. A. Henzinger, R. Jhala, and R. Majumdar, “Race checking by context inference,”
presented at the PLDI: Programming Languages Design and Implementation, 2004,
pp. 1–13.'
ista: 'Henzinger TA, Jhala R, Majumdar R. 2004. Race checking by context inference.
PLDI: Programming Languages Design and Implementation, 1–13.'
mla: Henzinger, Thomas A., et al. Race Checking by Context Inference. ACM,
2004, pp. 1–13, doi:10.1145/996841.996844.
short: T.A. Henzinger, R. Jhala, R. Majumdar, in:, ACM, 2004, pp. 1–13.
conference:
name: 'PLDI: Programming Languages Design and Implementation'
date_created: 2018-12-11T12:08:57Z
date_published: 2004-06-01T00:00:00Z
date_updated: 2021-01-12T07:57:07Z
day: '01'
doi: 10.1145/996841.996844
extern: 1
month: '06'
page: 1 - 13
publication_status: published
publisher: ACM
publist_id: '271'
quality_controlled: 0
status: public
title: Race checking by context inference
type: conference
year: '2004'
...
---
_id: '4461'
abstract:
- lang: eng
text: One of the central axioms of extreme programming is the disciplined use of
regression testing during stepwise software development. Due to recent progress
in software model checking, it has become possible to supplement this process
with automatic checks for behavioral safety properties of programs, such as conformance
with locking idioms and other programming protocols and patterns. For efficiency
reasons, all checks must be incremental, i.e., they must reuse partial results
from previous checks in order to avoid all unnecessary repetition of expensive
verification tasks. We show that the lazy-abstraction algorithm, and its implementation
in Blast, can be extended to support the fully automatic and incremental checking
of temporal safety properties during software development.
acknowledgement: 'This work was supported in part by the NSF grants CCR-9988172, CCR-0085949,
and CCR-0234690, the ONR grant N00014-02-1-0671, the DARPA grant F33615-00-C-1693,
and the MARCO grant 98-DT-660. '
alternative_title:
- LNCS
author:
- first_name: Thomas A
full_name: Thomas Henzinger
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000−0002−2985−7724
- first_name: Ranjit
full_name: Jhala, Ranjit
last_name: Jhala
- first_name: Ritankar
full_name: Majumdar, Ritankar S
last_name: Majumdar
- first_name: Marco
full_name: Sanvido, Marco A
last_name: Sanvido
citation:
ama: 'Henzinger TA, Jhala R, Majumdar R, Sanvido M. Extreme model checking. In:
Verification: Theory and Practice. Vol 2772. Springer; 2004:332-358. doi:10.1007/978-3-540-39910-0_16'
apa: 'Henzinger, T. A., Jhala, R., Majumdar, R., & Sanvido, M. (2004). Extreme
model checking. In Verification: Theory and Practice (Vol. 2772, pp. 332–358).
Springer. https://doi.org/10.1007/978-3-540-39910-0_16'
chicago: 'Henzinger, Thomas A, Ranjit Jhala, Ritankar Majumdar, and Marco Sanvido.
“Extreme Model Checking.” In Verification: Theory and Practice, 2772:332–58.
Springer, 2004. https://doi.org/10.1007/978-3-540-39910-0_16.'
ieee: 'T. A. Henzinger, R. Jhala, R. Majumdar, and M. Sanvido, “Extreme model checking,”
in Verification: Theory and Practice, vol. 2772, Springer, 2004, pp. 332–358.'
ista: 'Henzinger TA, Jhala R, Majumdar R, Sanvido M. 2004.Extreme model checking.
In: Verification: Theory and Practice. LNCS, vol. 2772, 332–358.'
mla: 'Henzinger, Thomas A., et al. “Extreme Model Checking.” Verification: Theory
and Practice, vol. 2772, Springer, 2004, pp. 332–58, doi:10.1007/978-3-540-39910-0_16.'
short: 'T.A. Henzinger, R. Jhala, R. Majumdar, M. Sanvido, in:, Verification: Theory
and Practice, Springer, 2004, pp. 332–358.'
date_created: 2018-12-11T12:08:58Z
date_published: 2004-02-24T00:00:00Z
date_updated: 2021-01-12T07:57:08Z
day: '24'
doi: 10.1007/978-3-540-39910-0_16
extern: 1
intvolume: ' 2772'
month: '02'
page: 332 - 358
publication: 'Verification: Theory and Practice'
publication_status: published
publisher: Springer
publist_id: '269'
quality_controlled: 0
status: public
title: Extreme model checking
type: book_chapter
volume: 2772
year: '2004'
...
---
_id: '4525'
abstract:
- lang: eng
text: 'We present a new high-level programming language, called xGiotto, for programming
applications with hard real-time constraints. Like its predecessor, xGiotto is
based on the LET (logical execution time) assumption: the programmer specifies
when the outputs of a task become available, and the compiler checks if the specification
can be implemented on a given platform. However, while the predecessor language
xGiotto was purely time-triggered, xGiotto accommodates also asynchronous events.
Indeed, through a mechanism called event scoping, events are the main structuring
principle of the new language. The xGiotto compiler and run-time system implement
event scoping through a tree-based event filter. The compiler also checks programs
for determinism (absence of race conditions).'
acknowledgement: This research is supported by the AFOSR MURI grant F49620-00-1-0327,
the DARPA SEC grant F33615-C-98-3614, the MARCO GSRC grant 98-DT-660, and the NSF
grants CCR-0208875 and CCR-0225610.
alternative_title:
- LNCS
author:
- first_name: Arkadeb
full_name: Ghosal, Arkadeb
last_name: Ghosal
- first_name: Thomas A
full_name: Thomas Henzinger
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000−0002−2985−7724
- first_name: Christoph
full_name: Kirsch, Christoph M
last_name: Kirsch
- first_name: Marco
full_name: Sanvido, Marco A
last_name: Sanvido
citation:
ama: 'Ghosal A, Henzinger TA, Kirsch C, Sanvido M. Event-driven programming with
logical execution times. In: Vol 2993. Springer; 2004:167-170. doi:10.1007/978-3-540-24743-2_24'
apa: 'Ghosal, A., Henzinger, T. A., Kirsch, C., & Sanvido, M. (2004). Event-driven
programming with logical execution times (Vol. 2993, pp. 167–170). Presented at
the HSCC: Hybrid Systems - Computation and Control, Springer. https://doi.org/10.1007/978-3-540-24743-2_24'
chicago: Ghosal, Arkadeb, Thomas A Henzinger, Christoph Kirsch, and Marco Sanvido.
“Event-Driven Programming with Logical Execution Times,” 2993:167–70. Springer,
2004. https://doi.org/10.1007/978-3-540-24743-2_24.
ieee: 'A. Ghosal, T. A. Henzinger, C. Kirsch, and M. Sanvido, “Event-driven programming
with logical execution times,” presented at the HSCC: Hybrid Systems - Computation
and Control, 2004, vol. 2993, pp. 167–170.'
ista: 'Ghosal A, Henzinger TA, Kirsch C, Sanvido M. 2004. Event-driven programming
with logical execution times. HSCC: Hybrid Systems - Computation and Control,
LNCS, vol. 2993, 167–170.'
mla: Ghosal, Arkadeb, et al. Event-Driven Programming with Logical Execution
Times. Vol. 2993, Springer, 2004, pp. 167–70, doi:10.1007/978-3-540-24743-2_24.
short: A. Ghosal, T.A. Henzinger, C. Kirsch, M. Sanvido, in:, Springer, 2004, pp.
167–170.
conference:
name: 'HSCC: Hybrid Systems - Computation and Control'
date_created: 2018-12-11T12:09:18Z
date_published: 2004-03-12T00:00:00Z
date_updated: 2021-01-12T07:59:26Z
day: '12'
doi: 10.1007/978-3-540-24743-2_24
extern: 1
intvolume: ' 2993'
month: '03'
page: 167 - 170
publication_status: published
publisher: Springer
publist_id: '200'
quality_controlled: 0
status: public
title: Event-driven programming with logical execution times
type: conference
volume: 2993
year: '2004'
...
---
_id: '4555'
abstract:
- lang: eng
text: Strategies in repeated games can be classified as to whether or not they use
memory and/or randomization. We consider Markov decision processes and 2-player
graph games, both of the deterministic and probabilistic varieties. We characterize
when memory and/or randomization are required for winning with respect to various
classes of w-regular objectives, noting particularly when the use of memory can
be traded for the use of randomization. In particular, we show that Markov decision
processes allow randomized memoryless optimal strategies for all M?ller objectives.
Furthermore, we show that 2-player probabilistic graph games allow randomized
memoryless strategies for winning with probability 1 those M?ller objectives which
are upward-closed. Upward-closure means that if a set α of infinitely repeating
vertices is winning, then all supersets of α are also winning.
author:
- first_name: Krishnendu
full_name: Krishnendu Chatterjee
id: 2E5DCA20-F248-11E8-B48F-1D18A9856A87
last_name: Chatterjee
orcid: 0000-0002-4561-241X
- first_name: Luca
full_name: de Alfaro, Luca
last_name: De Alfaro
- first_name: Thomas A
full_name: Thomas Henzinger
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000−0002−2985−7724
citation:
ama: 'Chatterjee K, De Alfaro L, Henzinger TA. Trading memory for randomness. In:
IEEE; 2004:206-217. doi:10.1109/QEST.2004.10051'
apa: 'Chatterjee, K., De Alfaro, L., & Henzinger, T. A. (2004). Trading memory
for randomness (pp. 206–217). Presented at the QEST: Quantitative Evaluation of
Systems, IEEE. https://doi.org/10.1109/QEST.2004.10051'
chicago: Chatterjee, Krishnendu, Luca De Alfaro, and Thomas A Henzinger. “Trading
Memory for Randomness,” 206–17. IEEE, 2004. https://doi.org/10.1109/QEST.2004.10051.
ieee: 'K. Chatterjee, L. De Alfaro, and T. A. Henzinger, “Trading memory for randomness,”
presented at the QEST: Quantitative Evaluation of Systems, 2004, pp. 206–217.'
ista: 'Chatterjee K, De Alfaro L, Henzinger TA. 2004. Trading memory for randomness.
QEST: Quantitative Evaluation of Systems, 206–217.'
mla: Chatterjee, Krishnendu, et al. Trading Memory for Randomness. IEEE,
2004, pp. 206–17, doi:10.1109/QEST.2004.10051.
short: K. Chatterjee, L. De Alfaro, T.A. Henzinger, in:, IEEE, 2004, pp. 206–217.
conference:
name: 'QEST: Quantitative Evaluation of Systems'
date_created: 2018-12-11T12:09:27Z
date_published: 2004-09-30T00:00:00Z
date_updated: 2021-01-12T07:59:40Z
day: '30'
doi: 10.1109/QEST.2004.10051
extern: 1
month: '09'
page: 206 - 217
publication_status: published
publisher: IEEE
publist_id: '155'
quality_controlled: 0
status: public
title: Trading memory for randomness
type: conference
year: '2004'
...
---
_id: '4556'
abstract:
- lang: eng
text: We study the problem of determining stack boundedness and the exact maximum
stack size for three classes of interrupt-driven programs. Interrupt-driven programs
are used in many real-time applications that require responsive interrupt handling.
In order to ensure responsiveness, programmers often enable interrupt processing
in the body of lower-priority interrupt handlers. In such programs a programming
error can allow interrupt handlers to be interrupted in a cyclic fashion to lead
to an unbounded stack, causing the system to crash. For a restricted class of
interrupt-driven programs, we show that there is a polynomial-time procedure to
check stack boundedness, while determining the exact maximum stack size is PSPACE-complete.
For a larger class of programs, the two problems are both PSPACE-complete, and
for the largest class of programs we consider, the two problems are PSPACE-hard
and can be solved in exponential time. While the complexities are high, our algorithms
are exponential only in the number of handlers, and polynomial in the size of
the program.
author:
- first_name: Krishnendu
full_name: Krishnendu Chatterjee
id: 2E5DCA20-F248-11E8-B48F-1D18A9856A87
last_name: Chatterjee
orcid: 0000-0002-4561-241X
- first_name: Di
full_name: Ma, Di
last_name: Ma
- first_name: Ritankar
full_name: Majumdar, Ritankar S
last_name: Majumdar
- first_name: Tian
full_name: Zhao, Tian
last_name: Zhao
- first_name: Thomas A
full_name: Thomas Henzinger
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000−0002−2985−7724
- first_name: Jens
full_name: Palsberg, Jens
last_name: Palsberg
citation:
ama: Chatterjee K, Ma D, Majumdar R, Zhao T, Henzinger TA, Palsberg J. Stack size
analysis for interrupt-driven programs. Information and Computation. 2004;194(2):144-174.
doi:10.1016/j.ic.2004.06.001
apa: Chatterjee, K., Ma, D., Majumdar, R., Zhao, T., Henzinger, T. A., & Palsberg,
J. (2004). Stack size analysis for interrupt-driven programs. Information and
Computation. Elsevier. https://doi.org/10.1016/j.ic.2004.06.001
chicago: Chatterjee, Krishnendu, Di Ma, Ritankar Majumdar, Tian Zhao, Thomas A Henzinger,
and Jens Palsberg. “Stack Size Analysis for Interrupt-Driven Programs.” Information
and Computation. Elsevier, 2004. https://doi.org/10.1016/j.ic.2004.06.001.
ieee: K. Chatterjee, D. Ma, R. Majumdar, T. Zhao, T. A. Henzinger, and J. Palsberg,
“Stack size analysis for interrupt-driven programs,” Information and Computation,
vol. 194, no. 2. Elsevier, pp. 144–174, 2004.
ista: Chatterjee K, Ma D, Majumdar R, Zhao T, Henzinger TA, Palsberg J. 2004. Stack
size analysis for interrupt-driven programs. Information and Computation. 194(2),
144–174.
mla: Chatterjee, Krishnendu, et al. “Stack Size Analysis for Interrupt-Driven Programs.”
Information and Computation, vol. 194, no. 2, Elsevier, 2004, pp. 144–74,
doi:10.1016/j.ic.2004.06.001.
short: K. Chatterjee, D. Ma, R. Majumdar, T. Zhao, T.A. Henzinger, J. Palsberg,
Information and Computation 194 (2004) 144–174.
date_created: 2018-12-11T12:09:28Z
date_published: 2004-08-11T00:00:00Z
date_updated: 2021-01-12T07:59:40Z
day: '11'
doi: 10.1016/j.ic.2004.06.001
extern: 1
intvolume: ' 194'
issue: '2'
month: '08'
page: 144 - 174
publication: Information and Computation
publication_status: published
publisher: Elsevier
publist_id: '156'
quality_controlled: 0
status: public
title: Stack size analysis for interrupt-driven programs
type: journal_article
volume: 194
year: '2004'
...
---
_id: '4558'
abstract:
- lang: eng
text: We study perfect-information stochastic parity games. These are two-player
nonterminating games which are played on a graph with turn-based probabilistic
transitions. A play results in an infinite path and the conflicting goals of the
two players are ω-regular path properties, formalized as parity winning conditions.
The qualitative solution of such a game amounts to computing the set of vertices
from which a player has a strategy to win with probability 1 (or with positive
probability). The quantitative solution amounts to computing the value of the
game in every vertex, i.e., the highest probability with which a player can guarantee
satisfaction of his own objective in a play that starts from the vertex.For the
important special case of one-player stochastic parity games (parity Markov decision
processes) we give polynomial-time algorithms both for the qualitative and the
quantitative solution. The running time of the qualitative solution is O(d · m3/2)
for graphs with m edges and d priorities. The quantitative solution is based on
a linear-programming formulation.For the two-player case, we establish the existence
of optimal pure memoryless strategies. This has several important ramifications.
First, it implies that the values of the games are rational. This is in contrast
to the concurrent stochastic parity games of de Alfaro et al.; there, values are
in general algebraic numbers, optimal strategies do not exist, and ε-optimal strategies
have to be mixed and with infinite memory. Second, the existence of optimal pure
memoryless strategies together with the polynomial-time solution forone-player
case implies that the quantitative two-player stochastic parity game problem is
in NP ∩ co-NP. This generalizes a result of Condon for stochastic games with reachability
objectives. It also constitutes an exponential improvement over the best previous
algorithm, which is based on a doubly exponential procedure of de Alfaro and Majumdar
for concurrent stochastic parity games and provides only ε-approximations of the
values.
author:
- first_name: Krishnendu
full_name: Krishnendu Chatterjee
id: 2E5DCA20-F248-11E8-B48F-1D18A9856A87
last_name: Chatterjee
orcid: 0000-0002-4561-241X
- first_name: Marcin
full_name: Jurdziński, Marcin
last_name: Jurdziński
- first_name: Thomas A
full_name: Thomas Henzinger
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000−0002−2985−7724
citation:
ama: 'Chatterjee K, Jurdziński M, Henzinger TA. Quantitative stochastic parity games.
In: SIAM; 2004:121-130.'
apa: 'Chatterjee, K., Jurdziński, M., & Henzinger, T. A. (2004). Quantitative
stochastic parity games (pp. 121–130). Presented at the SODA: Symposium on Discrete
Algorithms, SIAM.'
chicago: Chatterjee, Krishnendu, Marcin Jurdziński, and Thomas A Henzinger. “Quantitative
Stochastic Parity Games,” 121–30. SIAM, 2004.
ieee: 'K. Chatterjee, M. Jurdziński, and T. A. Henzinger, “Quantitative stochastic
parity games,” presented at the SODA: Symposium on Discrete Algorithms, 2004,
pp. 121–130.'
ista: 'Chatterjee K, Jurdziński M, Henzinger TA. 2004. Quantitative stochastic parity
games. SODA: Symposium on Discrete Algorithms, 121–130.'
mla: Chatterjee, Krishnendu, et al. Quantitative Stochastic Parity Games.
SIAM, 2004, pp. 121–30.
short: K. Chatterjee, M. Jurdziński, T.A. Henzinger, in:, SIAM, 2004, pp. 121–130.
conference:
name: 'SODA: Symposium on Discrete Algorithms'
date_created: 2018-12-11T12:09:28Z
date_published: 2004-01-01T00:00:00Z
date_updated: 2021-01-12T07:59:41Z
day: '01'
extern: 1
month: '01'
page: 121 - 130
publication_status: published
publisher: SIAM
publist_id: '153'
quality_controlled: 0
status: public
title: Quantitative stochastic parity games
type: conference
year: '2004'
...
---
_id: '4577'
abstract:
- lang: eng
text: While model checking has been successful in uncovering subtle bugs in code,
its adoption in software engineering practice has been hampered by the absence
of a simple interface to the programmer in an integrated development environment.
We describe an integration of the software model checker BLAST into the Eclipse
development environment. We provide a verification interface for practical solutions
for some typical program analysis problems - assertion checking, reachability
analysis, dead code analysis, and test generation - directly on the source code.
The analysis is completely automatic, and assumes no knowledge of model checking
or formal notation. Moreover, the interface supports incremental program verification
to support incremental design and evolution of code.
acknowledgement: This research was supported in part by the NSF grants CCR-0085949,
CCR-0234690, and ITR-0326577.
author:
- first_name: Dirk
full_name: Beyer, Dirk
last_name: Beyer
- first_name: Thomas A
full_name: Thomas Henzinger
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000−0002−2985−7724
- first_name: Ranjit
full_name: Jhala, Ranjit
last_name: Jhala
- first_name: Ritankar
full_name: Majumdar, Ritankar S
last_name: Majumdar
citation:
ama: 'Beyer D, Henzinger TA, Jhala R, Majumdar R. An eclipse plug-in for model checking.
In: IEEE; 2004:251-255. doi:10.1109/WPC.2004.1311069 '
apa: 'Beyer, D., Henzinger, T. A., Jhala, R., & Majumdar, R. (2004). An eclipse
plug-in for model checking (pp. 251–255). Presented at the IWPC: Program Comprehension,
IEEE. https://doi.org/10.1109/WPC.2004.1311069
'
chicago: Beyer, Dirk, Thomas A Henzinger, Ranjit Jhala, and Ritankar Majumdar. “An
Eclipse Plug-in for Model Checking,” 251–55. IEEE, 2004. https://doi.org/10.1109/WPC.2004.1311069 .
ieee: 'D. Beyer, T. A. Henzinger, R. Jhala, and R. Majumdar, “An eclipse plug-in
for model checking,” presented at the IWPC: Program Comprehension, 2004, pp. 251–255.'
ista: 'Beyer D, Henzinger TA, Jhala R, Majumdar R. 2004. An eclipse plug-in for
model checking. IWPC: Program Comprehension, 251–255.'
mla: Beyer, Dirk, et al. An Eclipse Plug-in for Model Checking. IEEE, 2004,
pp. 251–55, doi:10.1109/WPC.2004.1311069
.
short: D. Beyer, T.A. Henzinger, R. Jhala, R. Majumdar, in:, IEEE, 2004, pp. 251–255.
conference:
name: 'IWPC: Program Comprehension'
date_created: 2018-12-11T12:09:34Z
date_published: 2004-07-12T00:00:00Z
date_updated: 2021-01-12T07:59:50Z
day: '12'
doi: '10.1109/WPC.2004.1311069 '
extern: 1
month: '07'
page: 251 - 255
publication_status: published
publisher: IEEE
publist_id: '129'
quality_controlled: 0
status: public
title: An eclipse plug-in for model checking
type: conference
year: '2004'
...
---
_id: '4578'
abstract:
- lang: eng
text: 'BLAST is an automatic verification tool for checking temporal safety properties
of C programs. Blast is based on lazy predicate abstraction driven by interpolation-based
predicate discovery. In this paper, we present the Blast specification language.
The language specifies program properties at two levels of precision. At the lower
level, monitor automata are used to specify temporal safety properties of program
executions (traces). At the higher level, relational reachability queries over
program locations are used to combine lower-level trace properties. The two-level
specification language can be used to break down a verification task into several
independent calls of the model-checking engine. In this way, each call to the
model checker may have to analyze only part of the program, or part of the specification,
and may thus succeed in a reduction of the number of predicates needed for the
analysis. In addition, the two-level specification language provides a means for
structuring and maintaining specifications. '
acknowledgement: This research was supported in part by the NSF grants CCR-0085949,
CCR-0234690, and ITR-0326577.
alternative_title:
- LNCS
author:
- first_name: Dirk
full_name: Beyer, Dirk
last_name: Beyer
- first_name: Adam
full_name: Chlipala, Adam J
last_name: Chlipala
- first_name: Thomas A
full_name: Thomas Henzinger
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000−0002−2985−7724
- first_name: Ranjit
full_name: Jhala, Ranjit
last_name: Jhala
- first_name: Ritankar
full_name: Majumdar, Ritankar S
last_name: Majumdar
citation:
ama: 'Beyer D, Chlipala A, Henzinger TA, Jhala R, Majumdar R. The BLAST query language
for software verification. In: Vol 3148. Springer; 2004:2-18. doi:10.1007/978-3-540-27864-1_2'
apa: 'Beyer, D., Chlipala, A., Henzinger, T. A., Jhala, R., & Majumdar, R. (2004).
The BLAST query language for software verification (Vol. 3148, pp. 2–18). Presented
at the SAS: Static Analysis Symposium, Springer. https://doi.org/10.1007/978-3-540-27864-1_2'
chicago: Beyer, Dirk, Adam Chlipala, Thomas A Henzinger, Ranjit Jhala, and Ritankar
Majumdar. “The BLAST Query Language for Software Verification,” 3148:2–18. Springer,
2004. https://doi.org/10.1007/978-3-540-27864-1_2.
ieee: 'D. Beyer, A. Chlipala, T. A. Henzinger, R. Jhala, and R. Majumdar, “The BLAST
query language for software verification,” presented at the SAS: Static Analysis
Symposium, 2004, vol. 3148, pp. 2–18.'
ista: 'Beyer D, Chlipala A, Henzinger TA, Jhala R, Majumdar R. 2004. The BLAST query
language for software verification. SAS: Static Analysis Symposium, LNCS, vol.
3148, 2–18.'
mla: Beyer, Dirk, et al. The BLAST Query Language for Software Verification.
Vol. 3148, Springer, 2004, pp. 2–18, doi:10.1007/978-3-540-27864-1_2.
short: D. Beyer, A. Chlipala, T.A. Henzinger, R. Jhala, R. Majumdar, in:, Springer,
2004, pp. 2–18.
conference:
name: 'SAS: Static Analysis Symposium'
date_created: 2018-12-11T12:09:34Z
date_published: 2004-08-17T00:00:00Z
date_updated: 2021-01-12T07:59:50Z
day: '17'
doi: 10.1007/978-3-540-27864-1_2
extern: 1
intvolume: ' 3148'
month: '08'
page: 2 - 18
publication_status: published
publisher: Springer
publist_id: '130'
quality_controlled: 0
status: public
title: The BLAST query language for software verification
type: conference
volume: 3148
year: '2004'
...
---
_id: '4581'
abstract:
- lang: eng
text: We have extended the software model checker BLAST to automatically generate
test suites that guarantee full coverage with respect to a given predicate. More
precisely, given a C program and a target predicate p, BLAST determines the set
L of program locations which program execution can reach with p true, and automatically
generates a set of test vectors that exhibit the truth of p at all locations in
L. We have used BLAST to generate test suites and to detect dead code in C programs
with up to 30 K lines of code. The analysis and test vector generation is fully
automatic (no user intervention) and exact (no false positives).
author:
- first_name: Dirk
full_name: Beyer, Dirk
last_name: Beyer
- first_name: Adam
full_name: Chlipala, Adam J
last_name: Chlipala
- first_name: Thomas A
full_name: Thomas Henzinger
id: 40876CD8-F248-11E8-B48F-1D18A9856A87
last_name: Henzinger
orcid: 0000−0002−2985−7724
- first_name: Ranjit
full_name: Jhala, Ranjit
last_name: Jhala
- first_name: Ritankar
full_name: Majumdar, Ritankar S
last_name: Majumdar
citation:
ama: 'Beyer D, Chlipala A, Henzinger TA, Jhala R, Majumdar R. Generating tests from
counterexamples. In: IEEE; 2004:326-335. doi:10.1109/ICSE.2004.1317455'
apa: 'Beyer, D., Chlipala, A., Henzinger, T. A., Jhala, R., & Majumdar, R. (2004).
Generating tests from counterexamples (pp. 326–335). Presented at the ICSE: Software
Engineering, IEEE. https://doi.org/10.1109/ICSE.2004.1317455'
chicago: Beyer, Dirk, Adam Chlipala, Thomas A Henzinger, Ranjit Jhala, and Ritankar
Majumdar. “Generating Tests from Counterexamples,” 326–35. IEEE, 2004. https://doi.org/10.1109/ICSE.2004.1317455.
ieee: 'D. Beyer, A. Chlipala, T. A. Henzinger, R. Jhala, and R. Majumdar, “Generating
tests from counterexamples,” presented at the ICSE: Software Engineering, 2004,
pp. 326–335.'
ista: 'Beyer D, Chlipala A, Henzinger TA, Jhala R, Majumdar R. 2004. Generating
tests from counterexamples. ICSE: Software Engineering, 326–335.'
mla: Beyer, Dirk, et al. Generating Tests from Counterexamples. IEEE, 2004,
pp. 326–35, doi:10.1109/ICSE.2004.1317455.
short: D. Beyer, A. Chlipala, T.A. Henzinger, R. Jhala, R. Majumdar, in:, IEEE,
2004, pp. 326–335.
conference:
name: 'ICSE: Software Engineering'
date_created: 2018-12-11T12:09:35Z
date_published: 2004-07-26T00:00:00Z
date_updated: 2021-01-12T07:59:52Z
day: '26'
doi: 10.1109/ICSE.2004.1317455
extern: 1
month: '07'
page: 326 - 335
publication_status: published
publisher: IEEE
publist_id: '128'
quality_controlled: 0
status: public
title: Generating tests from counterexamples
type: conference
year: '2004'
...