Mark R. Tuttle

According to our database, Mark R. Tuttle authored at least 43 papers between 1986 and 2021.

Collaborative distances:

• Dijkstra number of two.
• Erdős number of two.

2021

Code-level model checking in the software development workflow at Amazon Web Services.

Nathan Chong, Byron Cook, Jonathan Eidelman, Konstantinos Kallas, Kareem Khazem, Felipe R. Monteiro, Daniel Schwartz-Narbonne, Serdar Tasiran, Michael Tautschnig, Mark R. Tuttle

Softw. Pract. Exp., 2021

Model checking boot code from AWS data centers.

Byron Cook, Kareem Khazem, Daniel Kroening, Serdar Tasiran, Michael Tautschnig, Mark R. Tuttle

Formal Methods Syst. Des., 2021

2020

Code-level model checking in the software development workflow.

Nathan Chong, Byron Cook, Konstantinos Kallas, Kareem Khazem, Felipe R. Monteiro, Daniel Schwartz-Narbonne, Serdar Tasiran, Michael Tautschnig, Mark R. Tuttle

Proceedings of the ICSE-SEIP 2020: 42nd International Conference on Software Engineering, Software Engineering in Practice, Seoul, South Korea, 27 June, 2020

2015

Symbolic Execution for BIOS Security.

Oleksandr Bazhaniuk, John Loucaides, Lee Rosenbaum, Mark R. Tuttle, Vincent Zimmer

Proceedings of the 9th USENIX Workshop on Offensive Technologies, 2015

2012

Protocol Proof Checking Simplified with SMT.

Mark R. Tuttle, Amit Goel

Proceedings of the 11th IEEE International Symposium on Network Computing and Applications, 2012

SMT-Based System Verification with DVF.

Amit Goel, Sava Krstic, Rebekah Leslie, Mark R. Tuttle

Proceedings of the 10th International Workshop on Satisfiability Modulo Theories, 2012

2011

Many Random Walks Are Faster Than One.

Noga Alon, Chen Avin, Michal Koucký, Gady Kozma, Zvi Lotker, Mark R. Tuttle

Comb. Probab. Comput., 2011

Transforming worst-case optimal solutions for simultaneous tasks into all-case optimal solutions.

Maurice Herlihy, Yoram Moses, Mark R. Tuttle

Proceedings of the 30th Annual ACM Symposium on Principles of Distributed Computing, 2011

2009

Protocol verification using flows: An industrial experience.

John W. O'Leary, Murali Talupur, Mark R. Tuttle

Proceedings of 9th International Conference on Formal Methods in Computer-Aided Design, 2009

2008

Collaborate with Strangers to Find Own Preferences.

Baruch Awerbuch, Yossi Azar, Zvi Lotker, Boaz Patt-Shamir, Mark R. Tuttle

Theory Comput. Syst., 2008

A game of timing and visibility.

Zvi Lotker, Boaz Patt-Shamir, Mark R. Tuttle

Games Econ. Behav., 2008

Model checking transactional memory with spin.

John W. O'Leary, Bratin Saha, Mark R. Tuttle

Proceedings of the Twenty-Seventh Annual ACM Symposium on Principles of Distributed Computing, 2008

Extracting models from design documents with mapster.

David James, Tim Leonard, John W. O'Leary, Murali Talupur, Mark R. Tuttle

Proceedings of the Twenty-Seventh Annual ACM Symposium on Principles of Distributed Computing, 2008

Going with the Flow: Parameterized Verification Using Message Flows.

Murali Talupur, Mark R. Tuttle

Proceedings of the Formal Methods in Computer-Aided Design, 2008

2007

Verifying Correctness of Transactional Memories.

Ariel Cohen, John W. O'Leary, Amir Pnueli, Mark R. Tuttle, Lenore D. Zuck

Proceedings of the Formal Methods in Computer-Aided Design, 7th International Conference, 2007

2006

Publish and perish: definition and analysis of an <i>n</i>-person publication impact game.

Zvi Lotker, Boaz Patt-Shamir, Mark R. Tuttle

Proceedings of the SPAA 2006: Proceedings of the 18th Annual ACM Symposium on Parallelism in Algorithms and Architectures, Cambridge, Massachusetts, USA, July 30, 2006

2005

Timing Games and Shared Memory.

Zvi Lotker, Boaz Patt-Shamir, Mark R. Tuttle

Proceedings of the Distributed Computing, 19th International Conference, 2005

Improved recommendation systems.

Baruch Awerbuch, Boaz Patt-Shamir, David Peleg, Mark R. Tuttle

Proceedings of the Sixteenth Annual ACM-SIAM Symposium on Discrete Algorithms, 2005

Adaptive Collaboration in Peer-to-Peer Systems.

Baruch Awerbuch, Boaz Patt-Shamir, David Peleg, Mark R. Tuttle

Proceedings of the 25th International Conference on Distributed Computing Systems (ICDCS 2005), 2005

2004

An Axiomatic Approach to Computing the Connectivity of Synchronous and Asynchronous Systems.

Maurice Herlihy, Sergio Rajsbaum, Mark R. Tuttle

Proceedings of the Workshops on Geometric and Topological Methods in Concurrency Theory, 2004

Collaboration of untrusting peers with changing interests.

Baruch Awerbuch, Boaz Patt-Shamir, David Peleg, Mark R. Tuttle

Proceedings of the Proceedings 5th ACM Conference on Electronic Commerce (EC-2004), 2004

2003

Checking Cache-Coherence Protocols with TLA⁺.

Rajeev Joshi, Leslie Lamport, John Matthews, Serdar Tasiran, Mark R. Tuttle, Yuan Yu

Formal Methods Syst. Des., 2003

A Theory of Redo Recovery.

David B. Lomet, Mark R. Tuttle

Proceedings of the 2003 ACM SIGMOD International Conference on Management of Data, 2003

2002

Specifying and verifying systems with TLA+.

Leslie Lamport, John Matthews, Mark R. Tuttle, Yuan Yu

Proceedings of the 10th ACM SIGOPS European Workshop, Saint-Emilion, France, July 1, 2002, 2002

2001

A New Synchronous Lower Bound for Set Agreement.

Maurice Herlihy, Sergio Rajsbaum, Mark R. Tuttle

Proceedings of the Distributed Computing, 15th International Conference, 2001

2000

Tight bounds for <i>k</i>-set agreement.

Soma Chaudhuri, Maurice Herlihy, Nancy A. Lynch, Mark R. Tuttle

J. ACM, 2000

An Overview of Synchronous Message-Passing and Topology.

Maurice Herlihy, Sergio Rajsbaum, Mark R. Tuttle

Proceedings of the 2nd Workshop on Geometry and Topology in Concurrency theory, 2000

1999

Wait-Free Implementations in Message-Passing Systems.

Soma Chaudhuri, Maurice Herlihy, Mark R. Tuttle

Theor. Comput. Sci., 1999

Logical Logging to Extend Recovery to New Domains.

David B. Lomet, Mark R. Tuttle

Proceedings of the SIGMOD 1999, 1999

Cache Coherence Verification with TLA+.

Homayoon Akhiani, Damien Doligez, Paul Harter, Leslie Lamport, Joshua Scheid, Mark R. Tuttle, Yuan Yu

Proceedings of the FM'99 - Formal Methods, 1999

1998

Unifying Synchronous and Asynchronous Message-Passing Models.

Maurice Herlihy, Sergio Rajsbaum, Mark R. Tuttle

Proceedings of the Seventeenth Annual ACM Symposium on Principles of Distributed Computing, 1998

1995

Redo Recovery after System Crashes.

David B. Lomet, Mark R. Tuttle

Proceedings of the VLDB'95, 1995

A Tight Lower Bound for Processor Coordination.

Soma Chaudhuri, Maurice Herlihy, Nancy A. Lynch, Mark R. Tuttle

Proceedings of the Responsive Computer Systems: Steps Toward Fault-Tolerant Real-Time Systems, 1995

1994

Fast Increment Registers.

Soma Chaudhuri, Mark R. Tuttle

Proceedings of the Distributed Algorithms, 8th International Workshop, 1994

1993

Knowledge, Probability, and Adversaries.

Joseph Y. Halpern, Mark R. Tuttle

J. ACM, 1993

Common Knowledge and Consistent Simultaneous Coordination.

Gil Neiger, Mark R. Tuttle

Distributed Comput., 1993

A Tight Lower Bound for k-Set Agreement

Soma Chaudhuri, Maurice Herlihy, Nancy A. Lynch, Mark R. Tuttle

Proceedings of the 34th Annual Symposium on Foundations of Computer Science, 1993

1991

A Semantics for a Logic of Authentication (Extended Abstract).

Martín Abadi, Mark R. Tuttle

Proceedings of the Tenth Annual ACM Symposium on Principles of Distributed Computing, 1991

1990

Lower Bounds for Wait-Free Computation in Message-Passing Systems.

Maurice Herlihy, Mark R. Tuttle

Proceedings of the Ninth Annual ACM Symposium on Principles of Distributed Computing, 1990

1988

Programming Simultaneous Actions Using Common Knowledge.

Yoram Moses, Mark R. Tuttle

Algorithmica, 1988

A Knowledge-Based Analysis of Zero Knowledge (Preliminary Report)

Joseph Y. Halpern, Yoram Moses, Mark R. Tuttle

Proceedings of the 20th Annual ACM Symposium on Theory of Computing, 1988

1987

Hierarchical Correctness Proofs for Distributed Algorithms.

Nancy A. Lynch, Mark R. Tuttle

Proceedings of the Sixth Annual ACM Symposium on Principles of Distributed Computing, 1987

1986

Programming Simultaneous Actions Using Common Knowledge: Preliminary Version

Yoram Moses, Mark R. Tuttle

Proceedings of the 27th Annual Symposium on Foundations of Computer Science, 1986