An inheritance-based technique for building simulation proofs incrementally

This paper presents a technique for incrementally constructing safety specifications, abstract algorithm descriptions, and simulation proofs showing that algorithms meet their specifications. The technique for building specifications (and algorithms) allows a child specification (or algorithm) to in...

Full description

Saved in:
Bibliographic Details
Published in:Proceedings / International Conference on Software Engineering pp. 478 - 487
Main Authors: Keidar, Idit, Khazan, Roger, Lynch, Nancy, Shvartsman, Alex
Format: Conference Proceeding Journal Article
Language:English
Published: New York, NY, USA ACM 2000
IEEE
Series:ACM Conferences
Subjects:
Computational modeling
Computer science
Computer simulation
Computing methodologies > Modeling and simulation
Context modeling
General and reference > Cross-computing tools and techniques > Verification
Large-scale systems
Object oriented modeling
Power system modeling
Safety
Software and its engineering > Software creation and management > Software development process management
Software and its engineering > Software creation and management > Software verification and validation > Formal software verification
Software and its engineering > Software creation and management > Software verification and validation > Software defect analysis > Software testing and debugging
Software and its engineering > Software organization and properties > Software functional properties > Formal methods > Software verification
Software engineering
Software systems
Theory of computation > Semantics and reasoning > Program reasoning > Program verification
interface extension
refinement
system modeling/verification
specialization by inheritance
simulation
ISBN:1581132069, 9781581132069
ISSN:0270-5257
Online Access:Get full text
Tags: Add Tag
No Tags, Be the first to tag this record!
Abstract This paper presents a technique for incrementally constructing safety specifications, abstract algorithm descriptions, and simulation proofs showing that algorithms meet their specifications. The technique for building specifications (and algorithms) allows a child specification (or algorithm) to inherit from its parent by two forms of incremental modification: (a) interface extension, where new forms of interaction are added to the parent's interface, and (b) specialization (subtyping), where new data, restrictions, and effects are added to the parent's behavior description. The combination of interface extension and specialization constitutes a powerful and expressive incremental modification mechanism for describing changes that do not override the behavior of the parent, although it may introduce new behavior. Consider the case when incremental modification is applied to both a parent specification S and a parent algorithm A. A proof that the child algorithm A′ implements the child specification S′ can be built incrementally upon simulation proof that algorithm A implements specification S. The new work required involves reasoning about the modifications, but does not require repetition of the reasoning in the original simulation proof. The paper presents the technique mathematically, in terms of automata. The technique has already been used to model and validate a full-fledged group communication system (see [26]); the methodology and results of that experiment are summarized in this paper.
AbstractList This paper presents a technique for incrementally constructing safety specifications, abstract algorithm descriptions, and simulation proofs showing that algorithms meet their specifications. The technique for building specifications (and algorithms) allows a child specification (or algorithm) to inherit from its parent by two forms of incremental modification: (a) interface extension, where new forms of interaction are added to the parent's interface, and (b) specialization (subtyping), where new data, restrictions, and effects are added to the parent's behavior description. The combination of interface extension and specialization constitutes a powerful and expressive incremental modification mechanism for describing changes that do not override the behavior of the parent, although it may introduce new behavior. Consider the case when incremental modification is applied to both a parent specification S and a parent algorithm A. A proof that the child algorithm A′ implements the child specification S′ can be built incrementally upon simulation proof that algorithm A implements specification S. The new work required involves reasoning about the modifications, but does not require repetition of the reasoning in the original simulation proof. The paper presents the technique mathematically, in terms of automata. The technique has already been used to model and validate a full-fledged group communication system (see [26]); the methodology and results of that experiment are summarized in this paper.
The paper presents a technique for incrementally constructing safety specifications, abstract algorithm descriptions, and simulation proofs showing that algorithms meet their specifications. The technique for building specifications (and algorithms) allows a child specification (or algorithm) to inherit from its parent by two forms of incremental modification: (a) interface extension, where new forms of interaction are added to the parent's interface, and (b) specialization (subtyping), where new data, restrictions, and effects are added to the parent's behavior description. The combination of interface extension and specialization constitutes a powerful and expressive incremental modification mechanism for describing changes that do not override the behavior of the parent, although it may introduce new behavior. Consider the case when incremental modification is applied to both a parent specification S and a parent algorithm A. A proof that the child algorithm A' implements the child specification S' can be built incrementally upon a simulation proof that algorithm A implements specification S. The new work required involves reasoning about the modifications, but does not require repetition of the reasoning in the original simulation proof. The paper presents the technique mathematically, in terms of automata. The technique has already been used to model and validate a full-fledged group communication system (I. Keidar and R. Khazan, 1999); the methodology and results of that experiment are summarized.
A technique is introduced for incrementally constructing safety specifications, abstract algorithm descriptions, and simulation proofs showing that algorithms meet their specifications. The technique is presented mathematically, in terms of automata.
This paper presents a technique for incrementally constructing safety specifications, abstract algorithm descriptions, and simulation proofs showing that algorithms meet their specifications.The technique for building specifications (and algorithms) allows a child specification (or algorithm) to inherit from its parent by two forms of incremental modification: (a) interface extension, where new forms of interaction are added to the parent's interface, and (b) specialization (subtyping), where new data, restrictions, and effects are added to the parent's behavior description. The combination of interface extension and specialization constitutes a powerful and expressive incremental modification mechanism for describing changes that do not override the behavior of the parent, although it may introduce new behavior.Consider the case when incremental modification is applied to both a parent specification S and a parent algorithm A. A proof that the child algorithm A' implements the child specification S' can be built incrementally upon simulation proof that algorithm A implements specification S. The new work required involves reasoning about the modifications, but does not require repetition of the reasoning in the original simulation proof.The paper presents the technique mathematically, in terms of automata. The technique has already been used to model and validate a full-fledged group communication system (see [26]); the methodology and results of that experiment are summarized in this paper.
Author Shvartsman, Alex
Khazan, Roger
Keidar, Idit
Lynch, Nancy
Author_xml – sequence: 1
  givenname: Idit
  surname: Keidar
  fullname: Keidar, Idit
  organization: MIT Lab for Computer Science, 545 Technology Sq., Room 367, Cambridge, MA
– sequence: 2
  givenname: Roger
  surname: Khazan
  fullname: Khazan, Roger
  organization: MIT Lab for Computer Science, 545 Technology Sq., Room 367, Cambridge, MA
– sequence: 3
  givenname: Nancy
  surname: Lynch
  fullname: Lynch, Nancy
  organization: MIT Lab for Computer Science, 545 Technology Sq., Room 367, Cambridge, MA
– sequence: 4
  givenname: Alex
  surname: Shvartsman
  fullname: Shvartsman, Alex
  organization: University of Connecticut, Computer Science and Engineering Dept., Storrs, CT
BookMark eNqFkL1PwzAQxS1RJNrSkYUpExMp_ohjZ6wqvkQlFpgtOzlTQ2KXOBn632MUJMbqhje83909vQWa-eABoSuC14QU_I4xQSReJ2FcnqEF4ZIQRnFZzdAcU4FzTrm4QKsYPzHGyZO44nP0svGZ83vo3aB9DbnREZpsgHrv3fcImQ19ZkbXNs5_ZNF1Y6sHF3x26EOwMa3WPXTgB922x0t0bnUbYfWnS_T-cP-2fcp3r4_P280u15SXMpe0NI2oGgHW1g3FrDAECk0bQjSpwFBZcVyDYIKnabA1mJuCVJZzBoJqtkQ3090UImWMg-pcrKFttYcwRsUIE6Io6EmQihJXjPIEXk-gAwB16F2n-6OSAhdMJvN2MnXdKRPCV1QEq9_W1dS6mlpXpndg_5-ewNkPm8GBHg
ContentType Conference Proceeding
Journal Article
Copyright 2000 ACM
Copyright_xml – notice: 2000 ACM
DBID 6IE
6IH
CBEJK
RIE
RIO
7SC
8FD
JQ2
L7M
L~C
L~D
DOI 10.1145/337180.337358
DatabaseName IEEE Electronic Library (IEL) Conference Proceedings
IEEE Proceedings Order Plan (POP) 1998-present by volume
IEEE Xplore All Conference Proceedings
IEEE Electronic Library (IEL)
IEEE Proceedings Order Plans (POP) 1998-present
Computer and Information Systems Abstracts
Technology Research Database
ProQuest Computer Science Collection
Advanced Technologies Database with Aerospace
Computer and Information Systems Abstracts – Academic
Computer and Information Systems Abstracts Professional
DatabaseTitle Computer and Information Systems Abstracts
Technology Research Database
Computer and Information Systems Abstracts – Academic
Advanced Technologies Database with Aerospace
ProQuest Computer Science Collection
Computer and Information Systems Abstracts Professional
DatabaseTitleList

Computer and Information Systems Abstracts
Computer and Information Systems Abstracts
Database_xml – sequence: 1
  dbid: RIE
  name: IEEE Electronic Library (IEL)
  url: https://ieeexplore.ieee.org/
  sourceTypes: Publisher
DeliveryMethod fulltext_linktorsrc
Discipline Computer Science
EndPage 487
ExternalDocumentID 870438
Genre Conference Paper
GroupedDBID 6IE
6IH
6IK
6IL
AAJGR
AAVQY
ACM
ADPZR
ALMA_UNASSIGNED_HOLDINGS
APO
BEFXN
BFFAM
BGNUA
BKEBE
BPEOZ
CBEJK
GUFHI
IERZE
OCL
RIE
RIL
RIO
-~X
.4S
.DC
123
23M
29O
5VS
6IF
6IM
6IN
8US
AAWTH
ABLEC
ADZIZ
AFFNX
ARCSS
AVWKF
CHZPO
EDO
FEDTE
I-F
I07
IEGSK
IJVOP
IPLJI
M43
RNS
XOL
7SC
8FD
JQ2
L7M
L~C
L~D
LHSKQ
ID FETCH-LOGICAL-a2568-826bd79d7effcd2034b1e4a2d11a19eb28950ce7375757d0fb05b419f553e72a3
IEDL.DBID RIE
ISBN 1581132069
9781581132069
ISSN 0270-5257
IngestDate Fri Jul 11 16:19:57 EDT 2025
Thu Sep 04 17:02:29 EDT 2025
Tue Aug 26 18:07:06 EDT 2025
Wed Jan 31 06:51:30 EST 2024
IsDoiOpenAccess false
IsOpenAccess true
IsPeerReviewed false
IsScholarly true
Keywords interface extension
refinement
system modeling/verification
specialization by inheritance
simulation
Language English
License Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from Permissions@acm.org
LinkModel DirectLink
MeetingName ICSE00: 22nd International Conference on Software Engineering
MergedId FETCHMERGED-LOGICAL-a2568-826bd79d7effcd2034b1e4a2d11a19eb28950ce7375757d0fb05b419f553e72a3
Notes SourceType-Scholarly Journals-2
ObjectType-Feature-2
ObjectType-Conference Paper-1
content type line 23
SourceType-Conference Papers & Proceedings-1
ObjectType-Article-3
content type line 25
OpenAccessLink https://dl.acm.org/doi/pdf/10.1145/337180.337358
PQID 27609325
PQPubID 23500
PageCount 10
ParticipantIDs proquest_miscellaneous_31377442
ieee_primary_870438
acm_books_10_1145_337180_337358_brief
proquest_miscellaneous_27609325
acm_books_10_1145_337180_337358
PublicationCentury 2000
PublicationDate 2000-00-00
PublicationDateYYYYMMDD 2000-01-01
PublicationDate_xml – year: 2000
  text: 2000-00-00
PublicationDecade 2000
PublicationPlace New York, NY, USA
PublicationPlace_xml – name: New York, NY, USA
PublicationSeriesTitle ACM Conferences
PublicationTitle Proceedings / International Conference on Software Engineering
PublicationTitleAbbrev ICSE
PublicationYear 2000
Publisher ACM
IEEE
Publisher_xml – name: ACM
– name: IEEE
SSID ssj0001138095
ssj0006499
Score 1.6147193
Snippet This paper presents a technique for incrementally constructing safety specifications, abstract algorithm descriptions, and simulation proofs showing that...
The paper presents a technique for incrementally constructing safety specifications, abstract algorithm descriptions, and simulation proofs showing that...
A technique is introduced for incrementally constructing safety specifications, abstract algorithm descriptions, and simulation proofs showing that algorithms...
SourceID proquest
ieee
acm
SourceType Aggregation Database
Publisher
StartPage 478
SubjectTerms Computational modeling
Computer science
Computer simulation
Computing methodologies -- Modeling and simulation
Context modeling
General and reference -- Cross-computing tools and techniques -- Verification
Large-scale systems
Object oriented modeling
Power system modeling
Safety
Software and its engineering -- Software creation and management -- Software development process management
Software and its engineering -- Software creation and management -- Software verification and validation -- Formal software verification
Software and its engineering -- Software creation and management -- Software verification and validation -- Software defect analysis -- Software testing and debugging
Software and its engineering -- Software organization and properties -- Software functional properties -- Formal methods -- Software verification
Software engineering
Software systems
Theory of computation -- Semantics and reasoning -- Program reasoning -- Program verification
Title An inheritance-based technique for building simulation proofs incrementally
URI https://ieeexplore.ieee.org/document/870438
https://www.proquest.com/docview/27609325
https://www.proquest.com/docview/31377442
hasFullText 1
inHoldings 1
isFullTextHit
isPrint
link http://cvtisr.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMwlV1LS8QwEA66ePDka8X1mYMe47ZN0qRHEUVQZA8K3kKaTGBhtyv7EPz3Ttru7kFFvLWQDmEyyXwz6XxDyKXNrc187liqAzAhMsXKnAcGCF9BC-FFqElcn9Tzs357KwYtz3ZdCwMA9c9ncB0f67t8P3GLmCrro20JrjfJplJ5U6q1TqekXCfFGvnmom4diUFXwiLhZ6zpkjq2VU_yoqV6Wr0vuTeF7HOOhzVGslxxWbOvunHbd-XbYV17oPudf819l3TXlXx0sPJRe2QDqn2ys2zlQNudfUAebyo6rGIt4DyaAYvOzdMVwStFaEvLtoM2nQ3HbdMvinNFL4qfuibPaEejzy55vb97uX1gbZ8FZhHwaIYRRulV4RWE4HyWcFGmIHAJ09SmBYbeupCJA8UVYjvlk1AmshRpEaTkoDLLD0mnmlRwRKgIjltvM5cLQCDmLR4IzmsUkfpCSdkjF6hREwOImWlqoqVpdG4anffI1R8jTDkdQuiR_ahk896QcphGvyh_uUgG90m8_LAVTBYzk6k8Qawqfx_BI_kiWuvxj5JPyHZThR-zL6ekM58u4IxsuY_5cDY9r43xC9SL1UM
linkProvider IEEE
linkToHtml http://cvtisr.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMwlV1LT9wwEB4VWglOPApi2wI-tEdDEtuxc6yqIhDbFQcqcbMceyytBFm0DyT-PeMku3toEeKWSM7IGo89D2e-D-C7K50rQul5biJyKQvN61JEjhS-opEyyNiCuA71aGTu7qqbHme77YVBxPbnMzxLj-1dfpj4RSqVnZNtSWE24GMizuqbtdYFlVyYrFrHvqVsySMp7cp4gvxMXV3KJGL1rKx6sKfV-xJ9U6pzIei4plxWaKFa_FX_0DOv_HNctz7oYudds9-Fg3UvH7tZeak9-IDNPuwsyRxYv7c_w_XPho2b1A04T4bAk3sLbAXxyii4ZXXPoc1m44ee9ovRXMmP0qe-qzS6-_vnA_h78fv21yXvmRa4o5DHcMox6qCroDFGH4pMyDpHSYuY5y6vKPk2lco8aqEputMhi3WmaplXUSmBunDiEDabSYNHwGT0wgVX-FIihWLB0ZHggyEReai0UgM4JY3alELMbNcVrWync9vpfAA_3hhh6-kY4wD2k5LtYwfLYTv9kvzlIlnaKen6wzU4WcxsocuMolX1-giR4BfJXr_8V_IpbF3e_hna4dXo-itsdz35qRbzDTbn0wUewyf_NB_PpietYb4AIYfYjA
openUrl ctx_ver=Z39.88-2004&ctx_enc=info%3Aofi%2Fenc%3AUTF-8&rfr_id=info%3Asid%2Fsummon.serialssolutions.com&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rft.genre=proceeding&rft.title=Proceedings+of+the+22nd+international+conference+on+Software+engineering&rft.atitle=An+inheritance-based+technique+for+building+simulation+proofs+incrementally&rft.au=Keidar%2C+Idit&rft.au=Khazan%2C+Roger&rft.au=Lynch%2C+Nancy&rft.au=Shvartsman%2C+Alex&rft.series=ACM+Conferences&rft.date=2000-01-01&rft.pub=ACM&rft.isbn=1581132069&rft.spage=478&rft.epage=487&rft_id=info:doi/10.1145%2F337180.337358
thumbnail_l http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/lc.gif&issn=0270-5257&client=summon
thumbnail_m http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/mc.gif&issn=0270-5257&client=summon
thumbnail_s http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/sc.gif&issn=0270-5257&client=summon