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...
Uloženo v:
| Vydáno v: | Proceedings / International Conference on Software Engineering s. 478 - 487 |
|---|---|
| Hlavní autoři: | , , , |
| Médium: | Konferenční příspěvek Journal Article |
| Jazyk: | angličtina |
| Vydáno: |
New York, NY, USA
ACM
2000
IEEE |
| Edice: | ACM Conferences |
| Témata: |
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
|
| ISBN: | 1581132069, 9781581132069 |
| ISSN: | 0270-5257 |
| On-line přístup: | Získat plný text |
| Tagy: |
Přidat tag
Žádné tagy, Buďte první, kdo vytvoří štítek k tomuto záznamu!
|
| 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 Xplore 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 Xplore Digital Libary (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.614799 |
| 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/eLvHCXMwlV3NS8MwFA9uePCkzonzMwc91qVN0iRHEYcgjB0Udgttk0Bh62TdBP97X9JuO6iItxaSEF5e8j6S9_shdGuTArRWgOfmEghQZJxFkqkkUrDglhpORU4C2YQYj-V0qiYtznaohbHWhsdn9t5_hrt8syjWPlU2BN1iVHZQR4i0KdXapVNiKonaeb4pC9SREHSRyAN--pouLj2tOklVC_W0_d9gbzI-pBQOa4hkqaA8oK8W85Z35dthHSzQ6PBfcz9C_V0lH55sbdQx2rNVDx1uqBxwu7NP0MtDhcvK1wKuvBpE3rgZvAV4xeDa4rxl0MZ1OW9JvzDMFawodC2aPGM2m3320dvo6fXxOWp5FqIMHB4ZQYSRG6GMsM4VJiGU5bFlWWLiOIsVhN5ScVJYQQX4dsIQlxOes1g5Duspkoyeom61qOwZwjaHEVJGnJGGpSl0ZNRZ5uCUgDgnIwN0AxLVPoCodVMTzXUjc93IfIDu_mih82Vp3QD1vJD1ewPKoRv5wvibRdKwT_zlR1bZxbrWiUgJ-Kr89xbUgy8ylpz_OPIFOmiq8H325RJ1V8u1vUL7xceqrJfXQRm_AHSr1AE |
| linkProvider | IEEE |
| linkToHtml | http://cvtisr.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMwlV1LS8QwEB50FfTka8X1tTnosZo2SZMcRRRFXfagsLfQNgksaFf2IfjvnbTd3YOKeGshCWEyyTyS-T6AM5cUqLUSPTefYICi4ixSXCeRxgV3zAomc1qRTcheTw0Gut_gbFe1MM656vGZuwif1V2-HRWzkCq7RN3iTK3CWiDOaoq1lgmVmCmql75vyivySAy7aBQgP0NVl1CBWJ2mugF7WvzP0Te5uGQMj2uMZZlkosJfLd4a5pVvx3Vlg263_jX7bWgva_lIf2GldmDFlbuwNSdzIM3e3oOHq5IMy1ANOA2KEAXzZskC4pWgc0vyhkObTIZvDe0XwbmiHcWuRZ1pzF5fP9vwcnvzfH0XNUwLUYYuj4owxsit1FY67wubUMbz2PEssXGcxRqDb6UFLZxkEr07aanPqch5rL3AFZVJxvahVY5KdwDE5ThCyqm3yvI0xY6cecc9nhMY6WS0A12UqAkhxMTUVdHC1DI3tcw7cP5HC5OPh853YDcI2bzXsBymli-OP18kgzslXH9kpRvNJiaRKUVvVfzeggX4Rc6Twx9H7sLG3fPTo3m87z0cwWZdkx9yMcfQmo5n7gTWi4_pcDI-rRTzC7BE10o |
| 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+I&rft.au=Khazan%2C+Roger&rft.au=Lynch%2C+Nancy&rft.date=2000-01-01&rft.isbn=9781581132069&rft.spage=478&rft.epage=487&rft_id=info:doi/10.1145%2F337180.337358&rft.externalDBID=NO_FULL_TEXT |
| 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 |