\n ## Mathematical Definitions: Formal Logical/Type-Theoretic Rules ### Overview The image displays a dense, two-column list of formal mathematical definitions or inference rules, likely from the fields of type theory, logic, or programming language semantics. The content consists of symbolic expressions defining relationships between types, terms, and operations. The notation is highly specialized, using symbols common in these fields (e.g., turnstiles `⊣`, brackets `[[ ]]`, lambdas `λ`, binders `bind`, and case expressions). ### Components/Axes This is not a chart or diagram with axes. It is a textual list of formal definitions. The primary components are: * **Left Column:** A series of premises or typing judgments, typically of the form `x : T ⊢ [[ ... ]]` or `• : T ⊢ [[ ... ]]`. * **Right Column:** The corresponding definition or computational rule, often starting with `=`. * **Symbols:** The notation includes: * Type/Form constructors: `A`, `B`, `G`, `U`, `F`, `?`, `1`, `+`, `×`, `→`, `&`, `⊤`, `⊥`. * Term variables: `x`, `y`, `f`, `π`, `π'`. * Judgment symbols: `⊣` (turnstile), `[[ ]]` (interpretation brackets), `←` (binding), `↦` (mapping). * Keywords: `absurd`, `bind`, `case`, `split`, `thunk`, `force`, `ret`. * Greek letters: `ρ` (rho), `λ` (lambda), `π` (pi). * Subscripts: `up`, `dn`. ### Detailed Analysis / Content Details The image contains the following transcribed definitions, presented in the order they appear from top to bottom, left to right within each line. **Line 1:** * Left: `x : [[A]] ⊢ [[⟨A' ↣ A⟩]] : [[A]]` * Right: `• : [[B']] ⊢ [[B ↣ B']] : [[B]]` **Line 2:** * Left: `x : 0 ⊢ [[⟨A ↣ 0⟩]]` * Right: `= absurd x` **Line 3:** * Left: `• : A ⊢ [[⟨F0 ↣ FA⟩]]` * Right: `= bind x ← •; U` **Line 4:** * Left: `x : [?] ⊢ [[⟨? ↣ ?⟩]]` * Right: `= x` **Line 5:** * Left: `• : F? ⊢ [[⟨F? ↣ F?⟩]]` * Right: `= •` **Line 6:** * Left: `x : [[G]] ⊢ [[⟨G ↣ G⟩]]` * Right: `= ρ_up(G)` **Line 7:** * Left: `• : F? ⊢ [[⟨FG ↣ F?⟩]]` * Right: `= ρ_dn(G)` **Line 8:** * Left: `x : [[A]] ⊢ [[⟨? ↣ A⟩]]` * Right: `= [[⟨? ↣ [A]⟩]][[[[A] ↣ A]]/x]` **Line 9:** * Left: `• : F? ⊢ [[⟨A ↣ ?⟩]]` * Right: `= [[⟨A ↣ [A]⟩]][[[[A] ↣ ?]]]` **Line 10:** * Left: `x : [[A₁]] + [[A₂]] ⊢ [[⟨A₁' + A₂' ↣ A₁ + A₂⟩]]` * Right: `= case x` `{ x₁. [[⟨A₁' ↣ A₁⟩]][x₁/x]` `| x₂. [[⟨A₂' ↣ A₂⟩]][x₂/x] }` **Line 11:** * Left: `• : [[A₁]] + [[A₂]] ⊢ [[⟨F(A₁ + A₂) ↣ F(A₁' + A₂')⟩]]` * Right: `= bind x' ← •; case x'` `{ x₁'. bind x₁ ← ([[FA₁ ↣ FA₁']]ret x₁'); ret x₁` `| x₂'. bind x₂ ← ([[FA₂ ↣ FA₂']]ret x₂'); ret x₂ }` **Line 12:** * Left: `x : 1 ⊢ [[⟨1 ↣ 1⟩]]` * Right: `= x` **Line 13:** * Left: `• : F1 ⊢ [[⟨F1 ↣ F1⟩]]` * Right: `= x` **Line 14:** * Left: `x : [[A₁]] × [[A₂]] ⊢ [[⟨A₁' × A₂' ↣ A₁ × A₂⟩]]` * Right: `= split x to (x₁, x₂).` `([[⟨A₁' ↣ A₁⟩]][x₁], [[⟨A₂' ↣ A₂⟩]][x₂])` **Line 15:** * Left: `• : [[A₁]] × [[A₂]] ⊢ [[⟨F(A₁ × A₂) ↣ F(A₁' × A₂')⟩]]` * Right: `= bind x' ← •; split x' to (x₁', x₂').` `bind x₁ ← ([[FA₁ ↣ FA₁']]ret x₁'); ret x₁` `bind x₂ ← ([[FA₂ ↣ FA₂']]ret x₂'); ret (x₁, x₂)` **Line 16:** * Left: `x : UF[[A]] ⊢ [[⟨UFA' ↣ UFA⟩]]` * Right: `= thunk (bind y ← force x; ret ([[A' ↣ A]])[y/x])` **Line 17:** * Left: `• : B ⊢ [[⟨⊤ ↣ B⟩]]` * Right: `= {}` **Line 18:** * Left: `x : U⊤ ⊢ [[⟨UB ↣ U⊤⟩]]` * Right: `= thunk U` **Line 19:** * Left: `• : U⊥ ⊢ [[⟨U⊥ ↣ U⊥⟩]]` * Right: `= •` **Line 20:** * Left: `x : U? ⊢ [[⟨U? ↣ U?⟩]]` * Right: `= x` **Line 21:** * Left: `• : UG ⊢ [[⟨U? ↣ UG⟩]]` * Right: `= ρ_dn(G)` **Line 22:** * Left: `x : UG ⊢ [[⟨UG ↣ U?⟩]]` * Right: `= ρ_up(G)` **Line 23:** * Left: `• : U? ⊢ [[⟨UB ↣ U?⟩]]` * Right: `= [[⟨B ↣ [B]⟩]][[[[B] ↣ ?]]]` **Line 24:** * Left: `x : U? ⊢ [[⟨U? ↣ UB⟩]]` * Right: `= [[⟨U? ↣ U[B]⟩]][[[[U[B] ↣ UB]]]` **Line 25:** * Left: `• : [[B₁']] & [[B₂']] ⊢ [[⟨B₁ & B₂ ↣ B₁' & B₂'⟩]]` * Right: `= { π ↦ [[⟨B₁ ↣ B₁']]π•` `| π' ↦ [[⟨B₂ ↣ B₂']]π'• }` **Line 26:** * Left: `x : U([[B₁]] & [[B₂]]) ⊢ [[⟨U(B₁' & B₂') ↣ U(B₁ & B₂)⟩]]` * Right: `= thunk` `{ π ↦ force [[⟨B₁' ↣ B₁⟩]](thunk π force x)` `| π' ↦ force [[⟨B₂' ↣ B₂⟩]](thunk π' force x) }` **Line 27:** * Left: `• ⊢ [[⟨A → B ↣ A' → B'⟩]]` * Right: `= λx : A. [[⟨B ↣ B']] ([[⟨A' ↣ A⟩]]x)` **Line 28:** * Left: `f : U([[A]] → [[B]]) ⊢ [[⟨U(A' → B') ↣ U(A → B)⟩]]` * Right: `= thunk λx' : A'.` `bind x ← ([[FA ↣ FA']]ret x'); ret x'` `force [[⟨UB' ↣ UB⟩]]thunk (force f) x'` **Line 29:** * Left: `• : FUB' ⊢ [[⟨FUB ↣ FUB'⟩]]` * Right: `= bind x' ← •; [[⟨B ↣ B']]force x'` ### Key Observations 1. **Structural Pattern:** Most definitions follow a pattern: a typing judgment on the left (often with a term `x` or a "hole" `•`) defines an interpretation `[[...]]` on the right. 2. **Recursive Definitions:** Many rules are recursive, referencing the interpretation function `[[...]]` within its own definition (e.g., Lines 8, 9, 10, 14). 3. **Computational Content:** The right-hand sides contain explicit computational constructs (`bind`, `case`, `split`, `thunk`, `force`, `ret`), suggesting these definitions describe an evaluation semantics or a translation into a computational calculus. 4. **Duality:** Several rules appear in pairs, suggesting a duality (e.g., `ρ_up`/`ρ_dn` in Lines 6/7 and 21/22; rules for `+` and `×`; rules for `&` and `→`). 5. **Special Cases:** Rules for base types like `0` (absurd), `1` (unit), `?` (unknown), and `⊤`/`⊥` (top/bottom) are provided. ### Interpretation This image presents a formal, syntactic definition of a **type-directed interpretation or translation**. The notation `[[A]]` likely denotes the "interpretation" or "semantic domain" of a type `A`. The rules define how to interpret a typing judgment `x : A ⊢ [[...]]` into a term or computation in a target language. * **What it demonstrates:** The rules systematically cover type constructors (`+`, `×`, `→`, `&`, `U`, `F`), showing how to interpret a term inhabiting a compound type by decomposing it into interpretations of its components. The presence of `U` (likely a "thunk" or "delayed computation" modality) and `F` (likely a "computation" or "effect" modality) points towards a system modeling effects, laziness, or staged computation. * **Relationships:** The left column establishes the *context* (a variable of a certain type), and the right column provides the *implementation* of the interpretation for that specific type structure. The rules are compositional. * **Notable Anomalies/Patterns:** The rules for `?` (unknown type) are particularly interesting, as they involve substitutions (`[[...]][/x]`), suggesting a form of type-level substitution or unification is part of the interpretation. The consistent use of `bind` and `ret` for the `F` modality strongly indicates a monadic structure for handling effects. In essence, this is a blueprint for a **compiler or interpreter** that translates terms from one type system into another, more computational one, paying careful attention to the structure of types and the management of effects (via `F`) and delayed computations (via `U`).