## 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.