Loading…

Rapid Prototyping Formal Systems in MMT: 5 Case Studies

Logical frameworks are meta-formalisms in which the syntax and semantics of object logics and related formal systems can be defined. This allows object logics to inherit implementations from the framework including, e.g., parser, type checker, or module system. But if the desired object logic falls...

Full description

Saved in:
Bibliographic Details
Main Authors: Müller, Dennis, Rabe, Florian
Format: Conference Proceeding
Language:English
Citations: Items that this one cites
Online Access:Get full text
Tags: Add Tag
No Tags, Be the first to tag this record!
cited_by
cites cdi_FETCH-LOGICAL-c257t-433a7a8ee120f57ed2a533d1fdc6931ea33aa71c3a6da792df238fe4855a0f853
container_end_page 54
container_issue Proc. LFMTP 2019
container_start_page 40
container_title
container_volume 307
creator Müller, Dennis
Rabe, Florian
description Logical frameworks are meta-formalisms in which the syntax and semantics of object logics and related formal systems can be defined. This allows object logics to inherit implementations from the framework including, e.g., parser, type checker, or module system. But if the desired object logic falls outside the comfort zone of the logical framework, these definitions may become cumbersome or infeasible. Therefore, the MMT system abstracts even further than previous frameworks: it assumes no type system or logic at all and allows its kernel algorithms to be customized by almost arbitrary sets of rules. In particular, this allows implementing standard logical frameworks like LF in MMT. But it does so without chaining users to one particular meta-formalism: users can flexibly adapt MMT whenever the object logic demands it. In this paper, we present a series of case studies that do just that, defining increasingly complex object logics in MMT. We use elegant declarative logic definitions wherever possible, but inject entirely new rules into the kernel when necessary. Our experience shows that the MMT approach allows deriving prototype implementations of very diverse formal systems very easily and quickly.
doi_str_mv 10.4204/EPTCS.307.5
format conference_proceeding
fullrecord <record><control><sourceid>doaj_cross</sourceid><recordid>TN_cdi_doaj_primary_oai_doaj_org_article_6e505529ba344f0ab6cf803af30a3be9</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><doaj_id>oai_doaj_org_article_6e505529ba344f0ab6cf803af30a3be9</doaj_id><sourcerecordid>oai_doaj_org_article_6e505529ba344f0ab6cf803af30a3be9</sourcerecordid><originalsourceid>FETCH-LOGICAL-c257t-433a7a8ee120f57ed2a533d1fdc6931ea33aa71c3a6da792df238fe4855a0f853</originalsourceid><addsrcrecordid>eNpNkMFKAzEURYMoWGpX_kD2MjXJSyYz7mRotdBisXUdXidJSWmbkoyL_r1jFfFt7uNeOItDyD1nYymYfJws181qDEyP1RUZCKZVIXjFrv_9t2SU8471B7WQdTkg-h1PwdJlil3szqdw3NJpTAfc09U5d-6QaTjSxWL9RBVtMDu66j5tcPmO3HjcZzf6zSH5mE7WzWsxf3uZNc_zohVKd4UEQI2Vc1wwr7SzAhWA5d62ZQ3cYb-j5i1gaVHXwnoBlXeyUgqZrxQMyeyHayPuzCmFA6aziRjMpYhpazB1od07UzrFlBL1BkFKz3BTtr5igB4YwsbVPevhh9WmmHNy_o_HmflWaC4KTa_QKPgCPQBiIQ</addsrcrecordid><sourcetype>Open Website</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype></control><display><type>conference_proceeding</type><title>Rapid Prototyping Formal Systems in MMT: 5 Case Studies</title><source>ROAD: Directory of Open Access Scholarly Resources</source><creator>Müller, Dennis ; Rabe, Florian</creator><creatorcontrib>Müller, Dennis ; Rabe, Florian</creatorcontrib><description>Logical frameworks are meta-formalisms in which the syntax and semantics of object logics and related formal systems can be defined. This allows object logics to inherit implementations from the framework including, e.g., parser, type checker, or module system. But if the desired object logic falls outside the comfort zone of the logical framework, these definitions may become cumbersome or infeasible. Therefore, the MMT system abstracts even further than previous frameworks: it assumes no type system or logic at all and allows its kernel algorithms to be customized by almost arbitrary sets of rules. In particular, this allows implementing standard logical frameworks like LF in MMT. But it does so without chaining users to one particular meta-formalism: users can flexibly adapt MMT whenever the object logic demands it. In this paper, we present a series of case studies that do just that, defining increasingly complex object logics in MMT. We use elegant declarative logic definitions wherever possible, but inject entirely new rules into the kernel when necessary. Our experience shows that the MMT approach allows deriving prototype implementations of very diverse formal systems very easily and quickly.</description><identifier>ISSN: 2075-2180</identifier><identifier>EISSN: 2075-2180</identifier><identifier>DOI: 10.4204/EPTCS.307.5</identifier><language>eng</language><publisher>Open Publishing Association</publisher><ispartof>Electronic proceedings in theoretical computer science, 2019, Vol.307 (Proc. LFMTP 2019), p.40-54</ispartof><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed><cites>FETCH-LOGICAL-c257t-433a7a8ee120f57ed2a533d1fdc6931ea33aa71c3a6da792df238fe4855a0f853</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>314,780,784,27924,27925</link.rule.ids></links><search><creatorcontrib>Müller, Dennis</creatorcontrib><creatorcontrib>Rabe, Florian</creatorcontrib><title>Rapid Prototyping Formal Systems in MMT: 5 Case Studies</title><title>Electronic proceedings in theoretical computer science</title><description>Logical frameworks are meta-formalisms in which the syntax and semantics of object logics and related formal systems can be defined. This allows object logics to inherit implementations from the framework including, e.g., parser, type checker, or module system. But if the desired object logic falls outside the comfort zone of the logical framework, these definitions may become cumbersome or infeasible. Therefore, the MMT system abstracts even further than previous frameworks: it assumes no type system or logic at all and allows its kernel algorithms to be customized by almost arbitrary sets of rules. In particular, this allows implementing standard logical frameworks like LF in MMT. But it does so without chaining users to one particular meta-formalism: users can flexibly adapt MMT whenever the object logic demands it. In this paper, we present a series of case studies that do just that, defining increasingly complex object logics in MMT. We use elegant declarative logic definitions wherever possible, but inject entirely new rules into the kernel when necessary. Our experience shows that the MMT approach allows deriving prototype implementations of very diverse formal systems very easily and quickly.</description><issn>2075-2180</issn><issn>2075-2180</issn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>2019</creationdate><recordtype>conference_proceeding</recordtype><sourceid>DOA</sourceid><recordid>eNpNkMFKAzEURYMoWGpX_kD2MjXJSyYz7mRotdBisXUdXidJSWmbkoyL_r1jFfFt7uNeOItDyD1nYymYfJws181qDEyP1RUZCKZVIXjFrv_9t2SU8471B7WQdTkg-h1PwdJlil3szqdw3NJpTAfc09U5d-6QaTjSxWL9RBVtMDu66j5tcPmO3HjcZzf6zSH5mE7WzWsxf3uZNc_zohVKd4UEQI2Vc1wwr7SzAhWA5d62ZQ3cYb-j5i1gaVHXwnoBlXeyUgqZrxQMyeyHayPuzCmFA6aziRjMpYhpazB1od07UzrFlBL1BkFKz3BTtr5igB4YwsbVPevhh9WmmHNy_o_HmflWaC4KTa_QKPgCPQBiIQ</recordid><startdate>20191012</startdate><enddate>20191012</enddate><creator>Müller, Dennis</creator><creator>Rabe, Florian</creator><general>Open Publishing Association</general><scope>AAYXX</scope><scope>CITATION</scope><scope>DOA</scope></search><sort><creationdate>20191012</creationdate><title>Rapid Prototyping Formal Systems in MMT: 5 Case Studies</title><author>Müller, Dennis ; Rabe, Florian</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c257t-433a7a8ee120f57ed2a533d1fdc6931ea33aa71c3a6da792df238fe4855a0f853</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>2019</creationdate><toplevel>online_resources</toplevel><creatorcontrib>Müller, Dennis</creatorcontrib><creatorcontrib>Rabe, Florian</creatorcontrib><collection>CrossRef</collection><collection>DOAJ Directory of Open Access Journals</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Müller, Dennis</au><au>Rabe, Florian</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>Rapid Prototyping Formal Systems in MMT: 5 Case Studies</atitle><btitle>Electronic proceedings in theoretical computer science</btitle><date>2019-10-12</date><risdate>2019</risdate><volume>307</volume><issue>Proc. LFMTP 2019</issue><spage>40</spage><epage>54</epage><pages>40-54</pages><issn>2075-2180</issn><eissn>2075-2180</eissn><abstract>Logical frameworks are meta-formalisms in which the syntax and semantics of object logics and related formal systems can be defined. This allows object logics to inherit implementations from the framework including, e.g., parser, type checker, or module system. But if the desired object logic falls outside the comfort zone of the logical framework, these definitions may become cumbersome or infeasible. Therefore, the MMT system abstracts even further than previous frameworks: it assumes no type system or logic at all and allows its kernel algorithms to be customized by almost arbitrary sets of rules. In particular, this allows implementing standard logical frameworks like LF in MMT. But it does so without chaining users to one particular meta-formalism: users can flexibly adapt MMT whenever the object logic demands it. In this paper, we present a series of case studies that do just that, defining increasingly complex object logics in MMT. We use elegant declarative logic definitions wherever possible, but inject entirely new rules into the kernel when necessary. Our experience shows that the MMT approach allows deriving prototype implementations of very diverse formal systems very easily and quickly.</abstract><pub>Open Publishing Association</pub><doi>10.4204/EPTCS.307.5</doi><tpages>15</tpages><oa>free_for_read</oa></addata></record>
fulltext fulltext
identifier ISSN: 2075-2180
ispartof Electronic proceedings in theoretical computer science, 2019, Vol.307 (Proc. LFMTP 2019), p.40-54
issn 2075-2180
2075-2180
language eng
recordid cdi_doaj_primary_oai_doaj_org_article_6e505529ba344f0ab6cf803af30a3be9
source ROAD: Directory of Open Access Scholarly Resources
title Rapid Prototyping Formal Systems in MMT: 5 Case Studies
url http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-28T11%3A42%3A28IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-doaj_cross&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=Rapid%20Prototyping%20Formal%20Systems%20in%20MMT:%205%20Case%20Studies&rft.btitle=Electronic%20proceedings%20in%20theoretical%20computer%20science&rft.au=M%C3%BCller,%20Dennis&rft.date=2019-10-12&rft.volume=307&rft.issue=Proc.%20LFMTP%202019&rft.spage=40&rft.epage=54&rft.pages=40-54&rft.issn=2075-2180&rft.eissn=2075-2180&rft_id=info:doi/10.4204/EPTCS.307.5&rft_dat=%3Cdoaj_cross%3Eoai_doaj_org_article_6e505529ba344f0ab6cf803af30a3be9%3C/doaj_cross%3E%3Cgrp_id%3Ecdi_FETCH-LOGICAL-c257t-433a7a8ee120f57ed2a533d1fdc6931ea33aa71c3a6da792df238fe4855a0f853%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true