{"id":15383,"date":"2026-04-24T12:45:21","date_gmt":"2026-04-24T10:45:21","guid":{"rendered":"https:\/\/www.iese.fraunhofer.de\/blog\/?p=15383"},"modified":"2026-04-27T09:58:51","modified_gmt":"2026-04-27T07:58:51","slug":"drambench-autoformalizing-dram-specifications","status":"publish","type":"post","link":"https:\/\/www.iese.fraunhofer.de\/blog\/drambench-autoformalizing-dram-specifications\/","title":{"rendered":"DRAMBench: Autoformalizing DRAM Specifications with Timed Petri Nets"},"content":{"rendered":"<p class=\"lead\">Chip design verification is dominated by manual interpretation of complex DRAM standards. With DRAMPyML and DRAMBench, Fraunhofer IESE and Normal Computing introduce timed Petri net models and an open benchmark to autoformalize memory specifications. This post shows how AI can bridge the gap between natural language specs and formal verification artifacts.<\/p>\n<div class=\"info-box\">\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignleft wp-image-15384 size-thumbnail\" src=\"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/jan-ernst-normalcomputing-150x150.jpg\" alt=\"Jan Ernst, Normal Computing\" width=\"150\" height=\"150\" srcset=\"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/jan-ernst-normalcomputing-150x150.jpg 150w, https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/jan-ernst-normalcomputing-32x32.jpg 32w, https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/jan-ernst-normalcomputing-50x50.jpg 50w, https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/jan-ernst-normalcomputing-64x64.jpg 64w, https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/jan-ernst-normalcomputing-96x96.jpg 96w, https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/jan-ernst-normalcomputing-128x128.jpg 128w, https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/jan-ernst-normalcomputing-65x65.jpg 65w, https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/jan-ernst-normalcomputing.jpg 320w\" sizes=\"auto, (max-width: 150px) 100vw, 150px\" \/><br \/>\n<strong>Co-Author<\/strong><br \/>\nDr. Jan Ole Ernst<\/p>\n<p><a href=\"mailto:jan@normalcomputing.com; anfrage@iese.fraunhofer.de\">Send email<\/a><\/p>\n<p>&nbsp;<\/p>\n<p>Dr. Jan Ole Ernst is a Research Scientist at Normal Computing with a background in physics and machine learning. Currently, he works on AI for chip design &amp; verification and novel computing architectures.<\/p>\n<\/div>\n<p>Chip design verification is one of the most critical and labor-intensive steps in the semiconductor industry, estimated to take up to 70% of the verification effort. Before a chip can be manufactured, engineers must ensure that the design implementation exactly matches its specification and is free of functional errors &#8211; because a bug found after fabrication can mean months of delay and millions for costly respins. Today, this verification process demands extensive manual effort: engineers read through hundreds of pages of natural language specifications and painstakingly translate them into formal, testable representations, a process that is slow, error-prone, and does not scale well as specifications grow in complexity. At Fraunhofer IESE, together with Normal Computing, we believe that AI and formal methods can fundamentally change this situation. To help make this vision concrete, we are releasing DRAMBench \u2013 an open benchmark and formal modelling framework for memory chips \u2013 as well as DRAMPyML, our Python-based framework for timed Petri net models of DRAM protocols.<\/p>\n<h2>The Problem: Specifications Are Written for Humans, Not Machines<\/h2>\n<p>Industry standards bodies like JEDEC publish detailed specifications for memory chips such as DDR, LPDDR, GDDR, and HBM. These documents define how such chips work: which commands a memory chip must support, the legal orderings of those commands, and the precise timing constraints between them. A single DRAM standard can contain hundreds of timing parameters and complex state-dependent rules governing how commands interact across banks, ranks, and channels.<br \/>\nToday, translating these specifications into something a verification tool can consume is almost entirely manual. Verification engineers read the spec, interpret its intent, and encode it into SystemVerilog assertions, stimulus sequences and other artifacts. This translation step is where spec misinterpretations enter the design and where schedules tend to slip. While AI has made progress in isolated design verification tasks, current approaches typically focus on narrow problems rather than full end-to-end specification compliance of modern chip designs, failing to capture the complexity of real-world verification workflows.<\/p>\n<h2>Our Approach: Timed Petri Nets as a Formal Target<\/h2>\n<p>Rather than jumping directly from natural language to low-level verification artifacts, we introduce an intermediate formal representation based on timed Petri nets. Petri nets are a well-established mathematical formalism for modeling concurrent systems &#8211; they capture states, transitions, and the constraints governing when transitions may fire. By extending them with timing, we can faithfully represent the temporal requirements that are central to DRAM protocols.<\/p>\n<p>Our framework, DRAMPyML, models each DRAM standard as a timed Petri net where:<\/p>\n<ul>\n<li><strong>Places<\/strong> represent device states (idle, active, precharging, refreshing)<\/li>\n<li><strong>Transitions<\/strong> represent commands (ACT, RD, WR, PRE, REF, and many more)<\/li>\n<li><strong>Arcs<\/strong> encode the structural and timing relationships between them &#8211; including inhibitor arcs for mutual exclusion, reset arcs for state resets, and timed arcs that enforce minimum delays like tRCD, tRAS, and tRP.<\/li>\n<\/ul>\n<p>The result is a compact, executable, and mathematically precise model of a DRAM protocol. From this single representation, we can derive SystemVerilog assertions, generate valid command sequences for stimulus and perform formal analysis. The Petri net serves as a single source of truth from which downstream verification artifacts flow.<\/p>\n<h2>DRAMBench: A Benchmark for Hardware Autoformalization<\/h2>\n<p>To evaluate how well AI models can perform this translation &#8211; from natural language specification to formal Petri net &#8211; we are releasing DRAMBench. It includes ground truth Petri net models for a broad range of JEDEC DRAM standards: DDR2 through DDR4, LPDDR2 through LPDDR4, GDDR5 and GDDR6, and HBM2.<br \/>\nDRAMBench is designed to be a living benchmark. As new DRAM generations emerge, previously withheld standards are released into the benchmark, and newer ones take their place. This keeps DRAMBench rigorous over time by preventing training data contamination while ensuring the dataset grows with the industry.<br \/>\nTo evaluate how closely an AI-generated model matches the ground truth, the benchmark compares legal command sequences. Given two Petri nets, we enumerate their legal k-step command sequences and compute the Jaccard index over the overlap. This gives a single, interpretable similarity score that captures structural and behavioral correctness. Timing correctness is evaluated separately through a dedicated timing constraint recall metric, measuring what fraction of the specification&#8217;s timing requirements the generated model recovers.<\/p>\n<h2>A Call to Two Communities<\/h2>\n<p>DRAMBench sits at the intersection of two fields that do not talk to each other enough: machine learning and hardware engineering.<br \/>\nTo the ML community: Hardware specification documents are a rich, underexplored domain for autoformalization research. Unlike mathematical theorem proving, where significant benchmark infrastructure already exists, hardware specs present unique challenges &#8211; ambiguous natural language, implicit domain knowledge, complex timing semantics, and hierarchical structure. DRAMBench provides a concrete, well-defined task with quantitative evaluation metrics. We hope it serves as a stepping stone toward broader hardware autoformalization benchmarks. We would welcome an alternative autoformalization approach that does not rely on Petri Nets as intermediate artifacts.<br \/>\nTo the hardware community: The cost of manual specification interpretation grows with each generation. The jump from DDR4 to DDR5 alone nearly quadrupled the page count of the JEDEC spec. Each new DRAM generation adds commands, timing parameters, and architectural features. The jump from DDR4 to DDR5 alone introduced significant new complexity. Formal models like timed Petri nets offer a more compact and interpretable way to capture protocol behavior than verbose verification collateral. And if AI can help generate these models, the verification bottleneck loosens considerably [3].<\/p>\n<h2>Beyond Memory: A Vision for All Chip Specifications<\/h2>\n<p>While we demonstrate our approach on DRAM protocols, the underlying idea is not limited to memory. Any hardware specification that defines states, commands, and timing constraints is a candidate for the same treatment. Communication protocols, bus interfaces, and controllers all fit this pattern. Timed Petri nets are general enough to capture a wide range of protocol behaviors, and the autoformalization pipeline we describe is architecture-agnostic.<br \/>\nOur hope is that this work contributes to a future where chip releases are accompanied not just by PDF datasheets, but by formal models: compact, executable, and machine-readable representations that verification teams can use directly. A formal model shipping alongside a specification would dramatically reduce the time from spec release to verified implementation. It would make verification more accessible to smaller teams and create a foundation for AI-assisted verification tools that can reason about specs end-to-end.<\/p>\n<h2>Get Involved<\/h2>\n<p>DRAMBench and DRAMPyML are open source under the Apache 2.0 license. The framework is Python-based, built on rustworkx for high-performance graph operations, and designed to be easy to extend with new standards, new formal targets or new evaluation metrics. We welcome contributions from both communities &#8211; whether that means adding new DRAM standard models, building autoformalization agents that target DRAMBench, extending the framework to non-memory protocols, or developing new evaluation metrics for formal model comparison. The gap between natural language specifications and formal verification is one of the biggest bottlenecks in chip design. We think closing it is a problem worth solving together.<\/p>\n<div class=\"info-box\">\n<p>If you are interested in research collaborations, joint projects, or evaluating AI-supported formal verification in your development processes, Fraunhofer IESE is happy to collaborate. Together with Normal Computing, we are working to close the gap between natural language specifications and formal verification \u2013 a bottleneck that is central to the future of chip design. <a href=\"mailto: matthias.jung@iese.fraunhofer.de, anfrage@iese.fraunhofer.de\">Contact us!<\/a><\/p>\n<\/div>\n<h3>References<\/h3>\n<p>DRAMPyML and DRAMBench are developed by Fraunhofer IESE and Normal Computing. For more details, see our papers: &#8222;DRAMPyML: A Formal Description of DRAM Protocols with Timed Petri Nets&#8220; (DV-Con Europe 2026), &#8222;A Formal Description of Communication Protocols Using Petri-Nets&#8220; (MBMV 2026), and &#8222;Autoformalizing Memory Device Specifications using Agents&#8220; (ICLR VerifAI Workshop 2026).<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Chip design verification is dominated by manual interpretation of complex DRAM standards. With DRAMPyML and DRAMBench, Fraunhofer IESE and Normal Computing introduce timed Petri net models and an open benchmark to autoformalize memory specifications. This post shows how AI can&#8230;<\/p>\n","protected":false},"author":70,"featured_media":15407,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[239,177],"tags":[296,233],"coauthors":[272],"class_list":["post-15383","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-autonomes-fahren","category-kuenstliche-intelligenz","tag-machine-learning","tag-software-engineering"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.5 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>DRAMBench: Autoformalizing DRAM Specifications with Timed Petri Nets - Blog des Fraunhofer IESE<\/title>\n<meta name=\"description\" content=\"DRAMBenAI automation for chip design: DRAMBench uses Petri nets for precise verification of memory specifications.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"DRAMBench: Autoformalizing DRAM Specifications with Timed Petri Nets - Blog des Fraunhofer IESE\" \/>\n<meta property=\"og:description\" content=\"DRAMBenAI automation for chip design: DRAMBench uses Petri nets for precise verification of memory specifications.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench\" \/>\n<meta property=\"og:site_name\" content=\"Fraunhofer IESE\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/FraunhoferIESE\/\" \/>\n<meta property=\"article:published_time\" content=\"2026-04-24T10:45:21+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-04-27T07:58:51+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/drambench2-fhgenie-zimageturbo.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1024\" \/>\n\t<meta property=\"og:image:height\" content=\"538\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Dr. Matthias Jung\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@FraunhoferIESE\" \/>\n<meta name=\"twitter:site\" content=\"@FraunhoferIESE\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Dr. Matthias Jung\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"7\u00a0Minuten\" \/>\n\t<meta name=\"twitter:label3\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data3\" content=\"Dr. Matthias Jung\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.normalcomputing.com\\\/blog\\\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/drambench-autoformalizing-dram-specifications\\\/\"},\"author\":{\"name\":\"Dr. Matthias Jung\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#\\\/schema\\\/person\\\/991ad89ac74176607d8191f9bee38bbb\"},\"headline\":\"DRAMBench: Autoformalizing DRAM Specifications with Timed Petri Nets\",\"datePublished\":\"2026-04-24T10:45:21+00:00\",\"dateModified\":\"2026-04-27T07:58:51+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/drambench-autoformalizing-dram-specifications\\\/\"},\"wordCount\":1340,\"publisher\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.normalcomputing.com\\\/blog\\\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/03\\\/drambench2-fhgenie-zimageturbo.jpg\",\"keywords\":[\"Machine Learning\",\"Software Engineering\"],\"articleSection\":[\"Autonomes Fahren\",\"K\u00fcnstliche Intelligenz\"],\"inLanguage\":\"de\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/drambench-autoformalizing-dram-specifications\\\/\",\"url\":\"https:\\\/\\\/www.normalcomputing.com\\\/blog\\\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench\",\"name\":\"DRAMBench: Autoformalizing DRAM Specifications with Timed Petri Nets - Blog des Fraunhofer IESE\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.normalcomputing.com\\\/blog\\\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.normalcomputing.com\\\/blog\\\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/03\\\/drambench2-fhgenie-zimageturbo.jpg\",\"datePublished\":\"2026-04-24T10:45:21+00:00\",\"dateModified\":\"2026-04-27T07:58:51+00:00\",\"description\":\"DRAMBenAI automation for chip design: DRAMBench uses Petri nets for precise verification of memory specifications.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.normalcomputing.com\\\/blog\\\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.normalcomputing.com\\\/blog\\\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/www.normalcomputing.com\\\/blog\\\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#primaryimage\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/03\\\/drambench2-fhgenie-zimageturbo.jpg\",\"contentUrl\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/03\\\/drambench2-fhgenie-zimageturbo.jpg\",\"width\":1024,\"height\":538,\"caption\":\"DRAM Bench\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.normalcomputing.com\\\/blog\\\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Startseite\",\"item\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"DRAMBench: Autoformalizing DRAM Specifications with Timed Petri Nets\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/\",\"name\":\"Fraunhofer IESE\",\"description\":\"Blog des Fraunhofer-Institut f\u00fcr Experimentelles Software Engineering\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#organization\",\"name\":\"Fraunhofer IESE\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2016\\\/08\\\/fhg_iese_logo.png\",\"contentUrl\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2016\\\/08\\\/fhg_iese_logo.png\",\"width\":183,\"height\":50,\"caption\":\"Fraunhofer IESE\"},\"image\":{\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/FraunhoferIESE\\\/\",\"https:\\\/\\\/x.com\\\/FraunhoferIESE\",\"https:\\\/\\\/www.linkedin.com\\\/company\\\/fraunhoferiese\\\/\",\"https:\\\/\\\/www.youtube.com\\\/c\\\/FraunhoferIESE\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/#\\\/schema\\\/person\\\/991ad89ac74176607d8191f9bee38bbb\",\"name\":\"Dr. Matthias Jung\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2020\\\/07\\\/jung_matthias_5D3_9901_web-96x96.jpg1c28318c1faf5c1bc7d60275b2a0c2f2\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2020\\\/07\\\/jung_matthias_5D3_9901_web-96x96.jpg\",\"contentUrl\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/wp-content\\\/uploads\\\/2020\\\/07\\\/jung_matthias_5D3_9901_web-96x96.jpg\",\"caption\":\"Dr. Matthias Jung\"},\"description\":\"Dr. Matthias Jung erhielt 2011 und 2017 den Diplom- bzw. Doktorgrad in Elektrotechnik von der Technischen Universit\u00e4t Kaiserslautern. Von 2011 bis 2017 war er als wissenschaftlicher Mitarbeiter am Lehrstuhl f\u00fcr Entwurf mikroelektronischer Systeme im Fachbereich Elektrotechnik und Informationstechnik der Technischen Universit\u00e4t Kaiserslautern t\u00e4tig. Seit 2017 ist er im Bereich Embedded Systems des Fraunhofer-Instituts f\u00fcr Experimentelles Software Engineering in Kaiserslautern als Senior Engineer und Projektleiter t\u00e4tig. Seine Forschungsschwerpunkte sind Embedded System Hard- und Software Engineering, autonome Systeme, Speichersysteme mit Schwerpunkt auf DRAMs, sowie virtuelle Prototypen.\",\"url\":\"https:\\\/\\\/www.iese.fraunhofer.de\\\/blog\\\/author\\\/matthias-jung\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"DRAMBench: Autoformalizing DRAM Specifications with Timed Petri Nets - Blog des Fraunhofer IESE","description":"DRAMBenAI automation for chip design: DRAMBench uses Petri nets for precise verification of memory specifications.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench","og_locale":"de_DE","og_type":"article","og_title":"DRAMBench: Autoformalizing DRAM Specifications with Timed Petri Nets - Blog des Fraunhofer IESE","og_description":"DRAMBenAI automation for chip design: DRAMBench uses Petri nets for precise verification of memory specifications.","og_url":"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench","og_site_name":"Fraunhofer IESE","article_publisher":"https:\/\/www.facebook.com\/FraunhoferIESE\/","article_published_time":"2026-04-24T10:45:21+00:00","article_modified_time":"2026-04-27T07:58:51+00:00","og_image":[{"width":1024,"height":538,"url":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/drambench2-fhgenie-zimageturbo.jpg","type":"image\/jpeg"}],"author":"Dr. Matthias Jung","twitter_card":"summary_large_image","twitter_creator":"@FraunhoferIESE","twitter_site":"@FraunhoferIESE","twitter_misc":{"Verfasst von":"Dr. Matthias Jung","Gesch\u00e4tzte Lesezeit":"7\u00a0Minuten","Written by":"Dr. Matthias Jung"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#article","isPartOf":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/drambench-autoformalizing-dram-specifications\/"},"author":{"name":"Dr. Matthias Jung","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#\/schema\/person\/991ad89ac74176607d8191f9bee38bbb"},"headline":"DRAMBench: Autoformalizing DRAM Specifications with Timed Petri Nets","datePublished":"2026-04-24T10:45:21+00:00","dateModified":"2026-04-27T07:58:51+00:00","mainEntityOfPage":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/drambench-autoformalizing-dram-specifications\/"},"wordCount":1340,"publisher":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#organization"},"image":{"@id":"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#primaryimage"},"thumbnailUrl":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/drambench2-fhgenie-zimageturbo.jpg","keywords":["Machine Learning","Software Engineering"],"articleSection":["Autonomes Fahren","K\u00fcnstliche Intelligenz"],"inLanguage":"de"},{"@type":"WebPage","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/drambench-autoformalizing-dram-specifications\/","url":"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench","name":"DRAMBench: Autoformalizing DRAM Specifications with Timed Petri Nets - Blog des Fraunhofer IESE","isPartOf":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#primaryimage"},"image":{"@id":"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#primaryimage"},"thumbnailUrl":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/drambench2-fhgenie-zimageturbo.jpg","datePublished":"2026-04-24T10:45:21+00:00","dateModified":"2026-04-27T07:58:51+00:00","description":"DRAMBenAI automation for chip design: DRAMBench uses Petri nets for precise verification of memory specifications.","breadcrumb":{"@id":"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#primaryimage","url":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/drambench2-fhgenie-zimageturbo.jpg","contentUrl":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/drambench2-fhgenie-zimageturbo.jpg","width":1024,"height":538,"caption":"DRAM Bench"},{"@type":"BreadcrumbList","@id":"https:\/\/www.normalcomputing.com\/blog\/from-specifications-to-formal-models-autoformalizing-memory-chips-with-drambench#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Startseite","item":"https:\/\/www.iese.fraunhofer.de\/blog\/"},{"@type":"ListItem","position":2,"name":"DRAMBench: Autoformalizing DRAM Specifications with Timed Petri Nets"}]},{"@type":"WebSite","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#website","url":"https:\/\/www.iese.fraunhofer.de\/blog\/","name":"Fraunhofer IESE","description":"Blog des Fraunhofer-Institut f\u00fcr Experimentelles Software Engineering","publisher":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.iese.fraunhofer.de\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#organization","name":"Fraunhofer IESE","url":"https:\/\/www.iese.fraunhofer.de\/blog\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2016\/08\/fhg_iese_logo.png","contentUrl":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2016\/08\/fhg_iese_logo.png","width":183,"height":50,"caption":"Fraunhofer IESE"},"image":{"@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/FraunhoferIESE\/","https:\/\/x.com\/FraunhoferIESE","https:\/\/www.linkedin.com\/company\/fraunhoferiese\/","https:\/\/www.youtube.com\/c\/FraunhoferIESE"]},{"@type":"Person","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/#\/schema\/person\/991ad89ac74176607d8191f9bee38bbb","name":"Dr. Matthias Jung","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2020\/07\/jung_matthias_5D3_9901_web-96x96.jpg1c28318c1faf5c1bc7d60275b2a0c2f2","url":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2020\/07\/jung_matthias_5D3_9901_web-96x96.jpg","contentUrl":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2020\/07\/jung_matthias_5D3_9901_web-96x96.jpg","caption":"Dr. Matthias Jung"},"description":"Dr. Matthias Jung erhielt 2011 und 2017 den Diplom- bzw. Doktorgrad in Elektrotechnik von der Technischen Universit\u00e4t Kaiserslautern. Von 2011 bis 2017 war er als wissenschaftlicher Mitarbeiter am Lehrstuhl f\u00fcr Entwurf mikroelektronischer Systeme im Fachbereich Elektrotechnik und Informationstechnik der Technischen Universit\u00e4t Kaiserslautern t\u00e4tig. Seit 2017 ist er im Bereich Embedded Systems des Fraunhofer-Instituts f\u00fcr Experimentelles Software Engineering in Kaiserslautern als Senior Engineer und Projektleiter t\u00e4tig. Seine Forschungsschwerpunkte sind Embedded System Hard- und Software Engineering, autonome Systeme, Speichersysteme mit Schwerpunkt auf DRAMs, sowie virtuelle Prototypen.","url":"https:\/\/www.iese.fraunhofer.de\/blog\/author\/matthias-jung\/"}]}},"jetpack_featured_media_url":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-content\/uploads\/2026\/03\/drambench2-fhgenie-zimageturbo.jpg","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/posts\/15383","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/users\/70"}],"replies":[{"embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/comments?post=15383"}],"version-history":[{"count":5,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/posts\/15383\/revisions"}],"predecessor-version":[{"id":15419,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/posts\/15383\/revisions\/15419"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/media\/15407"}],"wp:attachment":[{"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/media?parent=15383"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/categories?post=15383"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/tags?post=15383"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.iese.fraunhofer.de\/blog\/wp-json\/wp\/v2\/coauthors?post=15383"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}