## Technical Document Extraction: ImandraX Promotional Graphic ### Overview This image is a promotional graphic for "ImandraX," described as an "Automated Reasoning Engine." It is a composite image featuring a dark-themed background with a prominent title section on the left and multiple overlapping code editor windows on the right, showcasing the software's interface and functionality. The primary language is English. The code snippets appear to be in a functional programming language (likely OCaml or a similar ML-family language) used for formal verification. ### Components/Axes The image is divided into two main spatial regions: 1. **Left Panel (Header/Branding):** * **Logo:** A stylized green "X" logo with the text "IMANDRA X" in white. * **Main Title:** "Automated Reasoning Engine" in large, white, sans-serif font. * **Descriptive Text:** A paragraph below the title. * **Call-to-Action Button:** A blue button at the bottom left. 2. **Right Panel (Main Content - Code Windows):** * This area contains multiple overlapping windows simulating a code editor (like VS Code). Each window has a title bar, line numbers, and syntax-highlighted code. * **Primary Code Window (Center-Left):** Titled "Verification Basics." Contains a function definition and proof script. * **Secondary Code Window (Top-Right):** Titled "Re-check/Browse/Inspect/Copy." Contains a lemma and proof steps. * **Tertiary Code Window (Bottom-Right):** Contains a function definition and a counterexample output. * **Overlays:** Several semi-transparent, colored boxes (blue, green, orange) highlight specific sections of code, with accompanying explanatory text boxes. ### Detailed Analysis / Content Details **1. Left Panel Text Extraction:** * **Logo Text:** `IMANDRA X` * **Main Title:** `Automated Reasoning Engine` * **Description Paragraph:** `Formally verified functional programming with first-class counterexamples, highly automated proofs, powerful reasoning tactics and seamless integration of bounded and unbounded verification.` * **Button Text:** `NEW Install ImandraX in VS Code!` **2. Right Panel - Code Window Transcription & Analysis:** **A. Primary Window ("Verification Basics"):** * **Line 233:** Comment: `(* Now that we know the loop works for positive n, let's prove that it works for any n. *)` * **Line 234:** Comment: `(* Re-check/Browse/Inspect/Copy *)` * **Line 235-236:** Function definition start: `let rec loop_correct stack rn s steps =` * **Line 237:** Code: `= s >= 0 ->` * **Line 238:** Code: `&& a = (halted=false; prog=pc+2; stack, rn, ra) ->` * **Line 239:** Code: `run 3 steps` * **Line 240:** Code: `(if halted=false then` * **Line 241:** Code: `{ halted=true; prog=pc+1; stack=rn; ra=ra+sum rn }` * **Line 242:** Code: `else` * **Line 243:** Code: `{ halted=false; prog=pc+2; stack=rn; ra=ra+sum rn }` * **Line 244:** Code: `[@@auto_unroll 100]` * **Highlighted Overlay (Blue Box):** Contains a "Counter model" output. * Text: `Counter model:` * Data: `model { let rn : int = -7739; let ra : int = -10081; let rp : int = 1142; let s : state = { halted = false; prog = 0; stack = [10; 10]; ra = 10; rn = 10 } }` **B. Secondary Window (Top-Right):** * **Line 239:** Comment: `(* Re-check/Browse/Inspect/Copy *)` * **Line 240:** Lemma: `lemma loop_correct stack rn s steps =` * **Line 241:** Code: `s >= 0 ->` * **Line 242:** Code: `&& a = (halted=false; prog=pc+2; stack, rn, ra) ->` * **Line 243:** Code: `run 3 steps` * **Line 244:** Code: `(if halted=false then` * **Line 245:** Code: `{ halted=true; prog=pc+1; stack=rn; ra=ra+sum rn }` * **Line 246:** Code: `else` * **Line 247:** Code: `{ halted=false; prog=pc+2; stack=rn; ra=ra+sum rn }` * **Line 248:** Code: `[@@auto_unroll 100]` * **Line 249:** Code: `[%%auto]` * **Line 250:** Code: `[@@prove]` * **Line 251:** Code: `run` * **Line 252:** Code: `[%%auto]` **C. Tertiary Window (Bottom-Right):** * **Line 239:** Comment: `(* Finally, our main theorem *)` * **Line 240:** Theorem: `theorem run_dfs_color_count_from_empty_board acts =` * **Line 241:** Code: `delete_empty_cols (empty_board ())` * **Line 242:** Code: `List.length (run_dfs acts) =` * **Line 243:** Code: `List.length (acts)` * **Line 244:** Comment: `(* We prove this by induction on the list of actions! *)` * **Line 245:** Code: `[%%induct acts]` * **Line 246:** Code: `let rec run_dfs_color_count_from_empty_board acts =` * **Line 247:** Code: `match acts with` * **Line 248:** Code: `| [] -> true` * **Line 249:** Code: `| act :: acts ->` * **Line 250:** Code: `run_dfs_color_count_from_empty_board acts` * **Highlighted Overlay (Green Box):** Contains a "Found an instance" output. * Text: `Found an instance:` * Data: `model { let acts : action list = [Action { x = 0; y = 0; color = Red }; Action { x = 0; y = 0; color = Blue }; Action { x = 0; y = 0; color = Green }] }` ### Key Observations 1. **Multi-Layered Information:** The image presents information in layers: the high-level marketing message (left), the raw code (editor windows), and explanatory annotations (colored overlays). 2. **Verification Workflow:** The code snippets illustrate a formal verification workflow: defining a function (`loop`), stating a property (`lemma loop_correct`), encountering a counterexample (the blue "Counter model" box), and finally proving a main theorem (`theorem run_dfs_color_count_from_empty_board`). 3. **Integration Focus:** The call-to-action button explicitly mentions integration with VS Code, positioning ImandraX as a developer tool. 4. **Visual Hierarchy:** The large title and descriptive text on the left establish the product's purpose, while the complex code on the right serves as evidence of its technical depth and capability. ### Interpretation This image is a technical marketing asset designed to communicate the value proposition of ImandraX to a specialized audience—software engineers and researchers in formal methods, verification, and reliable systems. * **What it demonstrates:** It showcases ImandraX as a tool that bridges high-level automated reasoning with practical, integrated development. The code isn't just pseudocode; it's presented in a realistic editor environment, suggesting a seamless user experience. The progression from a basic function to a counterexample and then to a proven theorem visually narrates the tool's core capability: finding bugs (via counterexamples) and then helping to prove correctness. * **Relationship between elements:** The left panel states the promise ("formally verified functional programming..."), and the right panel provides the proof-of-concept. The overlapping windows and annotations mimic the active, investigative process of a developer using the tool to reason about code. * **Notable patterns:** The use of specific, technical jargon ("first-class counterexamples," "bounded and unbounded verification," "auto_unroll," "induct") acts as a filter, immediately engaging the target expert audience while signaling the tool's sophistication. The "NEW" tag on the VS Code button highlights a recent feature aimed at improving accessibility and adoption. * **Underlying message:** The image argues that ImandraX is not just a theoretical prover but a practical, powerful, and integrated development environment for creating provably correct software. It emphasizes automation (`[@@auto_unroll]`, `[%%auto]`) and the ability to handle complex, real-world programming constructs.