Proving Skipping Refinement with ACL2s

Proving Skipping Refinement with ACL2s

We describe three case studies illustrating the use of ACL2s to prove the correctness of optimized reactive systems using skipping refinement. Reasoning about reactive systems using refinement involves defining an abstract, high-level specification system and a concrete, low-level system. Next, one...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Veröffentlicht in:arXiv.org 2015-09
Hauptverfasser: Jain, Mitesh, Manolios, Panagiotis
Format: Artikel
Sprache:eng
Schlagworte:
Compilers
Computer Science - Logic in Computer Science
Computer Science - Programming Languages
Specifications
Online-Zugang:Volltext
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page
container_issue
container_start_page
container_title arXiv.org
container_volume
creator Jain, Mitesh
Manolios, Panagiotis
description We describe three case studies illustrating the use of ACL2s to prove the correctness of optimized reactive systems using skipping refinement. Reasoning about reactive systems using refinement involves defining an abstract, high-level specification system and a concrete, low-level system. Next, one shows that the behaviors of the implementation system are allowed by the specification system. Skipping refinement allows us to reason about implementation systems that can "skip" specification states due to optimizations that allow the implementation system to take several specification steps at once. Skipping refinement also allows implementation systems to, i.e., to take several steps before completing a specification step. We show how ACL2s can be used to prove skipping refinement theorems by modeling and proving the correctness of three systems: a JVM-inspired stack machine, a simple memory controller, and a scalar to vector compiler transformation.
doi_str_mv 10.48550/arxiv.1509.06085
format Article
fullrecord <record><control><sourceid>proquest_arxiv</sourceid><recordid>TN_cdi_arxiv_primary_1509_06085</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>2083148221</sourcerecordid><originalsourceid>FETCH-LOGICAL-a521-2fac570568e63f61dad2cab62d0e6b58d8dc80720d751b22bfae2e23bcfa38e23</originalsourceid><addsrcrecordid>eNotj1FLwzAUhYMgOOZ-gE8WBN9ab2560_g4ijqh4Jh7L2mTaKZra9pN_fd2m0_nezgczsfYFYckVURwp8OP3yec4D4BCYrO2ASF4LFKES_YrO83AIAyQyIxYbfL0O598xa9fviuO8DKOt_YrW2G6NsP79E8L7C_ZOdOf_Z29p9Ttn58WOeLuHh5es7nRawJeYxO15QBSWWlcJIbbbDWlUQDVlakjDK1ggzBZMQrxMppixZFVTst1AhTdn2aPUqUXfBbHX7Lg0x5lBkbN6dGF9qvne2HctPuQjN-KhGU4KlC5OIPIGBLSA</addsrcrecordid><sourcetype>Open Access Repository</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype><pqid>2083148221</pqid></control><display><type>article</type><title>Proving Skipping Refinement with ACL2s</title><source>arXiv.org</source><source>Free E- Journals</source><creator>Jain, Mitesh ; Manolios, Panagiotis</creator><creatorcontrib>Jain, Mitesh ; Manolios, Panagiotis</creatorcontrib><description>We describe three case studies illustrating the use of ACL2s to prove the correctness of optimized reactive systems using skipping refinement. Reasoning about reactive systems using refinement involves defining an abstract, high-level specification system and a concrete, low-level system. Next, one shows that the behaviors of the implementation system are allowed by the specification system. Skipping refinement allows us to reason about implementation systems that can "skip" specification states due to optimizations that allow the implementation system to take several specification steps at once. Skipping refinement also allows implementation systems to, i.e., to take several steps before completing a specification step. We show how ACL2s can be used to prove skipping refinement theorems by modeling and proving the correctness of three systems: a JVM-inspired stack machine, a simple memory controller, and a scalar to vector compiler transformation.</description><identifier>EISSN: 2331-8422</identifier><identifier>DOI: 10.48550/arxiv.1509.06085</identifier><language>eng</language><publisher>Ithaca: Cornell University Library, arXiv.org</publisher><subject>Compilers ; Computer Science - Logic in Computer Science ; Computer Science - Programming Languages ; Specifications</subject><ispartof>arXiv.org, 2015-09</ispartof><rights>2015. This work is published under http://arxiv.org/licenses/nonexclusive-distrib/1.0/ (the “License”). Notwithstanding the ProQuest Terms and Conditions, you may use this content in accordance with the terms of the License.</rights><rights>http://arxiv.org/licenses/nonexclusive-distrib/1.0</rights><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>228,230,776,780,881,27904</link.rule.ids><backlink>$$Uhttps://doi.org/10.48550/arXiv.1509.06085$$DView paper in arXiv$$Hfree_for_read</backlink><backlink>$$Uhttps://doi.org/10.4204/EPTCS.192.9$$DView published paper (Access to full text may be restricted)$$Hfree_for_read</backlink></links><search><creatorcontrib>Jain, Mitesh</creatorcontrib><creatorcontrib>Manolios, Panagiotis</creatorcontrib><title>Proving Skipping Refinement with ACL2s</title><title>arXiv.org</title><description>We describe three case studies illustrating the use of ACL2s to prove the correctness of optimized reactive systems using skipping refinement. Reasoning about reactive systems using refinement involves defining an abstract, high-level specification system and a concrete, low-level system. Next, one shows that the behaviors of the implementation system are allowed by the specification system. Skipping refinement allows us to reason about implementation systems that can "skip" specification states due to optimizations that allow the implementation system to take several specification steps at once. Skipping refinement also allows implementation systems to, i.e., to take several steps before completing a specification step. We show how ACL2s can be used to prove skipping refinement theorems by modeling and proving the correctness of three systems: a JVM-inspired stack machine, a simple memory controller, and a scalar to vector compiler transformation.</description><subject>Compilers</subject><subject>Computer Science - Logic in Computer Science</subject><subject>Computer Science - Programming Languages</subject><subject>Specifications</subject><issn>2331-8422</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2015</creationdate><recordtype>article</recordtype><sourceid>BENPR</sourceid><sourceid>GOX</sourceid><recordid>eNotj1FLwzAUhYMgOOZ-gE8WBN9ab2560_g4ijqh4Jh7L2mTaKZra9pN_fd2m0_nezgczsfYFYckVURwp8OP3yec4D4BCYrO2ASF4LFKES_YrO83AIAyQyIxYbfL0O598xa9fviuO8DKOt_YrW2G6NsP79E8L7C_ZOdOf_Z29p9Ttn58WOeLuHh5es7nRawJeYxO15QBSWWlcJIbbbDWlUQDVlakjDK1ggzBZMQrxMppixZFVTst1AhTdn2aPUqUXfBbHX7Lg0x5lBkbN6dGF9qvne2HctPuQjN-KhGU4KlC5OIPIGBLSA</recordid><startdate>20150921</startdate><enddate>20150921</enddate><creator>Jain, Mitesh</creator><creator>Manolios, Panagiotis</creator><general>Cornell University Library, arXiv.org</general><scope>8FE</scope><scope>8FG</scope><scope>ABJCF</scope><scope>ABUWG</scope><scope>AFKRA</scope><scope>AZQEC</scope><scope>BENPR</scope><scope>BGLVJ</scope><scope>CCPQU</scope><scope>DWQXO</scope><scope>HCIFZ</scope><scope>L6V</scope><scope>M7S</scope><scope>PIMPY</scope><scope>PQEST</scope><scope>PQQKQ</scope><scope>PQUKI</scope><scope>PTHSS</scope><scope>AKY</scope><scope>GOX</scope></search><sort><creationdate>20150921</creationdate><title>Proving Skipping Refinement with ACL2s</title><author>Jain, Mitesh ; Manolios, Panagiotis</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-a521-2fac570568e63f61dad2cab62d0e6b58d8dc80720d751b22bfae2e23bcfa38e23</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2015</creationdate><topic>Compilers</topic><topic>Computer Science - Logic in Computer Science</topic><topic>Computer Science - Programming Languages</topic><topic>Specifications</topic><toplevel>online_resources</toplevel><creatorcontrib>Jain, Mitesh</creatorcontrib><creatorcontrib>Manolios, Panagiotis</creatorcontrib><collection>ProQuest SciTech Collection</collection><collection>ProQuest Technology Collection</collection><collection>Materials Science &amp; Engineering Collection</collection><collection>ProQuest Central (Alumni Edition)</collection><collection>ProQuest Central UK/Ireland</collection><collection>ProQuest Central Essentials</collection><collection>ProQuest Central</collection><collection>Technology Collection</collection><collection>ProQuest One Community College</collection><collection>ProQuest Central Korea</collection><collection>SciTech Premium Collection</collection><collection>ProQuest Engineering Collection</collection><collection>Engineering Database</collection><collection>Publicly Available Content Database</collection><collection>ProQuest One Academic Eastern Edition (DO NOT USE)</collection><collection>ProQuest One Academic</collection><collection>ProQuest One Academic UKI Edition</collection><collection>Engineering Collection</collection><collection>arXiv Computer Science</collection><collection>arXiv.org</collection><jtitle>arXiv.org</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Jain, Mitesh</au><au>Manolios, Panagiotis</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Proving Skipping Refinement with ACL2s</atitle><jtitle>arXiv.org</jtitle><date>2015-09-21</date><risdate>2015</risdate><eissn>2331-8422</eissn><abstract>We describe three case studies illustrating the use of ACL2s to prove the correctness of optimized reactive systems using skipping refinement. Reasoning about reactive systems using refinement involves defining an abstract, high-level specification system and a concrete, low-level system. Next, one shows that the behaviors of the implementation system are allowed by the specification system. Skipping refinement allows us to reason about implementation systems that can "skip" specification states due to optimizations that allow the implementation system to take several specification steps at once. Skipping refinement also allows implementation systems to, i.e., to take several steps before completing a specification step. We show how ACL2s can be used to prove skipping refinement theorems by modeling and proving the correctness of three systems: a JVM-inspired stack machine, a simple memory controller, and a scalar to vector compiler transformation.</abstract><cop>Ithaca</cop><pub>Cornell University Library, arXiv.org</pub><doi>10.48550/arxiv.1509.06085</doi><oa>free_for_read</oa></addata></record>
fulltext fulltext
identifier EISSN: 2331-8422
ispartof arXiv.org, 2015-09
issn 2331-8422
language eng
recordid cdi_arxiv_primary_1509_06085
source arXiv.org; Free E- Journals
subjects Compilers
Computer Science - Logic in Computer Science
Computer Science - Programming Languages
Specifications
title Proving Skipping Refinement with ACL2s
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-27T16%3A52%3A44IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_arxiv&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Proving%20Skipping%20Refinement%20with%20ACL2s&rft.jtitle=arXiv.org&rft.au=Jain,%20Mitesh&rft.date=2015-09-21&rft.eissn=2331-8422&rft_id=info:doi/10.48550/arxiv.1509.06085&rft_dat=%3Cproquest_arxiv%3E2083148221%3C/proquest_arxiv%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_pqid=2083148221&rft_id=info:pmid/&rfr_iscdi=true