## Logical Formula Diagram: Type Theory Axioms ### Overview The image presents a structured diagram of logical formulas and type theory axioms, organized into labeled sections. Each section contains a set of logical expressions separated by pipes (`|`), representing inference rules or type constraints. The diagram uses formal logic notation with symbols like ⊆ (subset), ⊨ (entails), → (implies), and ∧ (and). ### Components/Axes - **Main Header**: Contains two formulas: - `Φ ⊨ V ⊆ V' : A ⊆ A' and Φ ⊨ Ψ ⊨ M ⊆ M' : B ⊆ B'` - Represents type constraints and entailments between variables and types. - **Six Labeled Sections**: 1. **TmDynRefl**: Reflexivity rule for types. - `Γ ⊆ Γ | Δ ⊆ Δ ⊨ E ⊆ E : T ⊆ T` 2. **TmDynTrans**: Transitivity rule for types. - `Γ ⊆ Γ' | Δ ⊆ Δ' ⊨ E ⊆ E' : T ⊆ T'` - `Γ' ⊆ Γ'' | Δ' ⊆ Δ'' ⊨ E' ⊆ E'' : T' ⊆ T''` - `Γ ⊆ Γ'' | Δ ⊆ Δ'' ⊨ E ⊆ E'' : T ⊆ T''` 3. **TmDynVar**: Variable substitution in types. - `Φ, x ⊆ x' : A ⊆ A', Φ ⊨ x ⊆ x' : A ⊆ A'` 4. **TmDynValSubst**: Value substitution in types. - `Φ ⊨ V ⊆ V' : A ⊆ A'` - `Φ, x ⊆ x' : A ⊆ A', Φ | Ψ ⊨ E ⊆ E' : T ⊆ T'` - `Φ | Ψ ⊨ E[V/x] ⊆ E'[V'/x'] : T ⊆ T'` 5. **TmDynStkSubst**: Stacked substitution in types. - `Φ | Ψ ⊨ M₁ ⊆ M₁' : B₁ ⊆ B₁'` - `Φ | ● ⊆ ● : B₁ ⊆ B₁' ⊨ M₂ ⊆ M₂' : B₂ ⊆ B₂'` - `Φ | Ψ ⊨ M₂[M₁/●] ⊆ M₂'[M₁'/●] : B₂ ⊆ B₂'` 6. **TmDynHole**: Hole context in types. - `Φ | ● ⊆ ● : B ⊆ B' ⊨ ● ⊆ ● : B ⊆ B'` ### Detailed Analysis - **Symbols and Notation**: - `Γ, Δ, E, T`: Contexts, domains, expressions, and types. - `Φ, Ψ`: Type constraints or proofs. - `⊆`: Type inclusion (e.g., `A ⊆ A'` means type `A` is a subset of `A'`). - `⊨`: Entailment (e.g., `Φ ⊨ V ⊆ V'` means `Φ` proves `V ⊆ V'`). - `→`: Type implication (e.g., `T → T'`). - `●`: Placeholder for substitution variables. - **Formula Structure**: - Each section combines multiple logical expressions separated by `|`, indicating alternative or combined rules. - Subscripts (e.g., `M₁`, `M₁'`) denote variable instances or substitutions. ### Key Observations 1. **Reflexivity and Transitivity**: The `TmDynRefl` and `TmDynTrans` sections formalize reflexivity and transitivity properties for type constraints. 2. **Substitution Rules**: `TmDynVar`, `TmDynValSubst`, and `TmDynStkSubst` define variable and value substitution mechanisms, critical for type checking in programming languages. 3. **Hole Context**: `TmDynHole` introduces a placeholder (`●`) for incomplete or deferred type information, common in dependent type systems. ### Interpretation This diagram formalizes rules for a type system, likely in a dependently typed programming language or proof assistant. The axioms govern how types, variables, and substitutions interact, ensuring consistency and correctness. For example: - **TmDynRefl** ensures reflexivity (`T ⊆ T`), a foundational property for equality. - **TmDynTrans** allows chaining type constraints (e.g., `T ⊆ T'` and `T' ⊆ T''` imply `T ⊆ T''`). - **TmDynValSubst** and **TmDynStkSubst** enable substitution of values and stack frames, essential for function application and recursion. - **TmDynHole** introduces a mechanism to handle incomplete types, enabling gradual typing or partial proofs. The diagram emphasizes structural recursion and substitution, key to ensuring type safety in complex systems. The use of `●` as a placeholder suggests a focus on meta-level reasoning, common in formal verification or type theory research.