Dependent Linear Type Theory Overview

• Dependent linear type theory is a family of type theories that integrate term dependency with linear resource discipline to balance expressiveness and resource management.
• Various design approaches, including dual-context, stratified, and graded systems, address the tension between allowing types to depend on intuitionistic versus linear variables.
• The theory employs categorical, fibrational, and realizability semantics, underpinning practical applications in quantitative analysis, quantum programming, and resource-safe verification.

Searching arXiv for relevant papers on dependent linear type theory and closely related systems. First, I’ll search for general papers on dependent linear type theory. Dependent linear type theory is the family of type theories that combines dependency with linear or, more generally, substructural resource discipline. Its central difficulty is the tension between two principles: dependent type theories let types depend on terms, while linear type theories restrict structural rules such as weakening and contraction to enforce resource usage; if types are allowed to depend on linear terms without further control, linear resources can be duplicated or discarded inside hypothetical objects, whereas forbidding such dependency limits expressiveness (Fu et al., 2023). The literature resolves this tension in several distinct ways: dual-context systems in which only cartesian variables may occur in types (Vákár, 2014), complete categorical semantics via indexed symmetric monoidal categories with comprehension (Vákár, 2015), diagrammatic and fibrational semantics (Lundfall, 2018, Fu et al., 2020), quantitative systems for complexity and sensitivity (Lago et al., 2011, Lago et al., 2012, Gaboardi, 2013), graded and adjoint formulations (Choudhury, 2023, Hanukaev et al., 2023), two-level stratifications of logics and programs (Fu et al., 2023), foundational substructural semantics using Left-Fibred Double Categories (Aberlé, 2024), impredicative universes and linear equalizers (Speight et al., 9 Feb 2026), and systems with dependent multiplicities (Doré, 11 Jul 2025).

1. Central problem and main design strategies

The design space of dependent linear type theory is structured by one question: whether, and in what sense, types may depend on data governed by linear usage. Early and influential formulations answer this by a dual-context discipline. In ILDTT and related systems, contexts are split into an intuitionistic part and a linear part, and types may depend on intuitionistic variables but not on linear variables (Vákár, 2014). More recent work relaxes or reorganizes that restriction in several directions. The LFDC framework is explicitly motivated by the claim that prior split-context approaches prevent types from depending on linear resources, and it proposes a semantics that allows dependency to range over substructural contexts directly (Aberlé, 2024). TLL adopts a different solution: types can depend on linear programs, but only irrelevantly, because logical reasoning and program execution are stratified into different levels (Fu et al., 2023). The 2025 system of dependent multiplicities changes the locus of dependency again: the multiplicity of some variable can depend on other variables, so usage annotations themselves become dependent objects (Doré, 11 Jul 2025).

Design	Representative systems	Characteristic discipline
Dual-context dependent linear type theory	ILDTT, linear logical frameworks	Types depend on cartesian or intuitionistic variables, not on linear variables
Stratified or two-level systems	TLL	Types can depend on linear programs, but only irrelevantly
Substructural semantics without split dependency	LFDC	Dependency ranges over substructural contexts directly
Quantitative or graded systems	dlPCF, dlPCFV, LDC, Glad	Dependency is combined with indexed modalities or grades
Dependent multiplicity systems	Dependent multiplicities	The number of uses can depend on other variables

This suggests that “dependent linear type theory” is not a single calculus but a research program with several incompatible choices about dependency, structural rules, and operational meaning. Some systems prioritize a clean separation between hypothetical reasoning and resource-sensitive computation, while others try to internalize usage information more directly into dependent typing.

2. Judgments, contexts, and type formers

A persistent syntactic pattern is the separation between a region in which dependency is permitted and a region in which resource usage is tracked. In ILDTT, typing judgments use a dual context $\Delta;\Xi$, where $\Delta$ is intuitionistic and $\Xi$ is linear, and types are formed only in $\Delta;\cdot$ (Vákár, 2015). On this basis the theory supports the multiplicatives $I$, $\otimes$, and $\multimap$, the exponential $!$, and the multiplicative dependent quantifiers $\Sigma_{!x:!A} B$ and $\Pi_{!x:!A} B$, together with extensional identity types $\Delta$0 (Vákár, 2015). These multiplicative dependent quantifiers specialize to familiar linear connectives when the bound variable is not free: $\Delta$1 and $\Delta$2 (Vákár, 2014).

A second syntactic line introduces linear dependent quantifiers over cartesian indices. The diagram model paper presents $\Delta$3 and $\Delta$4 as linear analogues of $\Delta$5 and $\Delta$6, where the dependent type $\Delta$7 is linear but the index $\Delta$8 is cartesian (Lundfall, 2018). The impredicative 2026 system uses the exact symbols $\Delta$9 and $\Xi$0, together with a modality $\Xi$1 from linear to cartesian terms, equalizers on the linear side, and a rule $\Xi$2-inj asserting injectivity of the modality in empty linear context (Speight et al., 9 Feb 2026). In that setting, both cartesian and linear types are only well-formed in cartesian contexts, so the syntax remains dual-context even though the linear fragment is significantly enriched.

Other systems depart more radically from the dual-context presentation. TLL separates a logical judgment $\Xi$3 from a program judgment $\Xi$4, distinguishes unrestricted and linear modalities by the sorts $\Xi$5 and $\Xi$6, and introduces both irrelevant and relevant dependent function spaces, written $\Xi$7 and $\Xi$8 (Fu et al., 2023). LDC uses graded contexts $\Xi$9 and judgments of the form $\Delta;\cdot$0, where the right-hand grade is interpreted as an observer level in dependency analysis or a usage requirement in linearity analysis (Choudhury, 2023). Glad similarly carries an explicit grade vector $\Delta;\cdot$1 and separates graded judgments $\Delta;\cdot$2 from mixed judgments $\Delta;\cdot$3, linked by the modal operators $\Delta;\cdot$4 and $\Delta;\cdot$5 (Hanukaev et al., 2023). The 2025 dependent-multiplicity system internalizes the resource discipline even further by defining a linear type as a pair $\Delta;\cdot$6 and a judgment $\Delta;\cdot$7 as $\Delta;\cdot$8 (Doré, 11 Jul 2025).

3. Categorical, fibrational, and realizability semantics

The standard semantic account for intuitionistic linear dependent type theory is the framework of strict indexed symmetric monoidal categories with comprehension. In that semantics, the multiplicative dependent quantifiers are characterized as adjoints to substitution along comprehension maps, identity types arise as left adjoints to reindexing along diagonals, and the resulting semantics is complete (Vákár, 2015). Beck–Chevalley and Frobenius reciprocity are not external add-ons but the structural laws that make substitution and tensor interaction behave as required by the typing rules (Vákár, 2014).

The diagram model extends the Hofmann–Streicher groupoid model by interpreting cartesian types as families of groupoids and linear types as diagrams $\Delta;\cdot$9 in a symmetric monoidal category $I$0 (Lundfall, 2018). In that model, the linear dependent quantifiers are right and left Kan extensions along the projection $I$1, and under the condition that $I$2 factors through sets the model supports a linear analogue of univalence (Lundfall, 2018). This is one of the first places where linear dependency is treated as a higher-dimensional semantic phenomenon rather than merely a typing discipline.

A different semantic line is fibrational. For quantum programming, the relevant structure is a state-parameter fibration $I$3, where $I$4 is locally cartesian closed, $I$5 is symmetric monoidal closed, each slice $I$6 is fiberwise monoidal closed, and a parameterized-unit functor $I$7 has a right adjoint $I$8, yielding the comonad $I$9 (Fu et al., 2020). This supports dependent linear $\otimes$0- and $\otimes$1-like type formers, a linear–nonlinear adjunction, and a shape operation interpreting “the parameter part” of a type or term (Fu et al., 2020). The categorical semantics of LFDCs generalizes this style of reasoning: context extension is interpreted by monoidal-like structure, linear implication is given by right adjoints to tensor, and dependent $\otimes$2 is a right adjoint to type-level weakening (Aberlé, 2024).

The impredicative 2026 development supplies a realizability model from a linear combinatory algebra. Its category of contexts is the assembly category over the associated cartesian combinatory algebra, its cartesian and linear types are families of assemblies, and the universe $\otimes$3 is modeled as a family of partial equivalence relations (Speight et al., 9 Feb 2026). This model validates a single Tarski-style impredicative universe with dual decoding operations $\otimes$4 and $\otimes$5, equalizer types on the linear side, the modality rules for $\otimes$6, and the injectivity rule $\otimes$7-inj (Speight et al., 9 Feb 2026). The semantic message is that dependent linear type theory can be based either on comprehension-style categorical semantics or on realizability semantics, and the choice directly shapes which type formers are available.

4. Quantitative and operational interpretations

One major strand of dependent linear type theory is quantitative. In dlPCF, linear dependent types are used to capture both the extensional behavior of PCF programs and intensional properties, notably the complexity of evaluating them with Krivine’s Machine (Lago et al., 2011). Its indexed modality $\otimes$8 behaves like a bounded linear-logic exponential, and the rule for recursion uses forest cardinalities to count the global number of recursive uses of a function variable (Lago et al., 2011). Soundness is paired with relative completeness: with a universal equational program $\otimes$9, the system can derive all true statements expressible in the index language about outputs and evaluation cost, although type checking is then undecidable in general (Lago et al., 2011).

The call-by-value analogue dlPCFV transfers the same paradigm to Plotkin’s PCF and the CEK machine (Lago et al., 2012). The underlying call-by-value translation places the bounded modality on function values rather than arguments, and typing judgments carry a weight $\multimap$0 that bounds the number of costly duplicating steps in CEK evaluation (Lago et al., 2012). This system is again sound and relatively complete, now for call-by-value evaluation rather than Krivine-style call-by-name (Lago et al., 2012). The 2013 tutorial paper presents these developments as a general pattern: linear types describe properties of functions, indexed types describe control-flow-sensitive invariants, and modalities such as $\multimap$1 or $\multimap$2 make the quantitative dimension explicit for sensitivity and complexity analysis (Gaboardi, 2013).

Graded systems broaden the quantitative perspective. LDC unifies linearity analysis and dependency analysis by using graded contexts and a grade to the right of the turnstile, so that the same syntax can support a comonadic interpretation for usage and a monadic interpretation for dependency (Choudhury, 2023). In its dependent form over an arbitrary Pure Type System, it supports graded $\multimap$3- and $\multimap$4-types, substitution, preservation, progress, and a heap semantics with a heap soundness theorem (Choudhury, 2023). The paper “Polynomial Time and Dependent Types” takes a different route through Quantitative Type Theory: it separates an erased fragment $\multimap$5, where one has the full power of dependent type theory, from a present fragment $\multimap$6, where linear resource constraints and restricted iteration enforce PTIME bounds (Atkey, 2023). Its two systems, Cons-free and LFPL-style with diamonds, are both sound and complete for PTIME via a Dal Lago–Hofmann realisability technique (Atkey, 2023).

TLL adds another operational perspective by proving erasure and heap soundness inside a two-level system (Fu et al., 2023). Proofs and types in programs are computationally irrelevant, erasure replaces all irrelevant subterms and type annotations by $\multimap$7, and the heap-based operational semantics allocates and deallocates linear resources precisely (Fu et al., 2023). The resulting theorems include erasure subject reduction, erasure progress, heap subject reduction, heap progress, and a memory cleanliness corollary saying that if the closed main program has type $\multimap$8 with $\multimap$9, evaluation terminates with a heap satisfying $!$0, so no linear cells remain (Fu et al., 2023). This operational line shows that dependent linear type theory is not only a semantic or proof-theoretic study of dependency under linearity, but also a source of machine-level cost and memory guarantees.

5. Constructions and applications

Resource-safe programming and verification are a recurrent application. TLL presents an inductive linear list type $!$1, a linear append program $!$2, a logical length function $!$3, and a proof $!$4 that the length of append is additive (Fu et al., 2023). It also gives length-indexed linear vectors $!$5 and a dependent append $!$6 whose irrelevant equality proofs are erased at runtime (Fu et al., 2023). The program reflection theorem, $!$7, permits proofs about resource-sensitive programs inside the logical fragment without changing their operational behavior (Fu et al., 2023).

Quantum programming is another explicit target. The quantum paper argues that modern quantum languages must be linearly typed because of the no-cloning property of quantum resources, and must also support families of circuits indexed by classical parameters (Fu et al., 2020). Its dependently typed extension of Proto-Quipper-M introduces first-class boxed circuits $!$8, indexed simple types such as $!$9, and families of circuits defined over parameter fragments (Fu et al., 2020). The same framework provides a shape operation that extracts the duplicable parameter part of quantum data, allowing types to depend on the shape of linear data but not on the full linear data itself (Fu et al., 2020).

Dependent linear type theory has also been used as a logical framework. The LFDC application constructs a linear logical framework $\Sigma_{!x:!A} B$0 for linear sequent calculus, with type families such as $\Sigma_{!x:!A} B$1, $\Sigma_{!x:!A} B$2, $\Sigma_{!x:!A} B$3, and $\Sigma_{!x:!A} B$4, and shows how this representation supports cut admissibility (Aberlé, 2024). The point of the example is that cut elimination needs type families whose parameters are used linearly; split-context frameworks had obstructed this representation, while the LFDC-based system makes it available (Aberlé, 2024).

The impredicative and dependent-multiplicity systems show that the topic is no longer confined to foundational syntax. The impredicative 2026 theory encodes linear lists over a closed linear type $\Sigma_{!x:!A} B$5, refines the Church-style encoding by an equalizer, and proves that the resulting $\Sigma_{!x:!A} B$6 is an initial algebra with the relevant uniqueness principle (Speight et al., 9 Feb 2026). The 2025 dependent-multiplicity theory is implemented in Agda and tracks examples such as dependent folds on $\Sigma_{!x:!A} B$7, composition with zero uses, $\Sigma_{!x:!A} B$8 and $\Sigma_{!x:!A} B$9 tracked by multiplicity $\Pi_{!x:!A} B$0 and $\Pi_{!x:!A} B$1, and $\Pi_{!x:!A} B$2 (Doré, 11 Jul 2025). These constructions indicate that dependent linear type theory has moved from purely structural questions toward reusable programming patterns.

6. Restrictions, controversies, and open directions

A first persistent controversy concerns dependency on linear data. In much of the older literature, only cartesian variables may occur in types, and this restriction is presented as the price of combining dependency with linearity (Vákár, 2014). Later work criticizes that design for blocking important applications and attempts to reintroduce dependence on substructural resources through new semantics (Aberlé, 2024). TLL’s solution is neither unrestricted dependence nor total prohibition, but irrelevance: types can depend on linear programs, but only irrelevantly, because all proofs and types occurring inside programs are fully erasable (Fu et al., 2023). The 2025 dependent-multiplicity system changes the question again by letting usage annotations depend on variables, thereby shifting dependency from object terms to multiplicities (Doré, 11 Jul 2025). A common misconception is therefore that all dependent linear systems make the same choice about dependency; the literature shows the opposite.

A second axis of disagreement concerns extensionality, impredicativity, and the role of modalities. The impredicative 2026 system assumes equality reflection for cartesian identity types, derives linear identity via $\Pi_{!x:!A} B$3, and relies on the injectivity rule $\Pi_{!x:!A} B$4-inj to obtain linear equality reflection and function extensionality for $\Pi_{!x:!A} B$5 (Speight et al., 9 Feb 2026). TLL, by contrast, omits an explicit $\Pi_{!x:!A} B$6 modality or comonad and relies instead on sorts and context constraints; normalization and canonicity are guaranteed at the logical level, while the program level is effectful and not intended to normalize (Fu et al., 2023). The quantum system restricts dependence to the parameter fragment and omits identity types, universes, and general recursion in the core calculus (Fu et al., 2020). These are not minor presentation choices: they determine which proofs are internal, which equations are definitional, and how close the theory can stay to operational resource bounds.

A third issue is algorithmic tractability. dlPCF is relatively complete only when the index theory is universal, and the same universality makes type checking undecidable because semantic assumptions are taken as oracles (Lago et al., 2011). The PTIME systems based on QTT preserve a sharp complexity interpretation, but usage inference and ticket management are non-trivial (Atkey, 2023). Glad proves graded substitution and other core metatheoretic properties, yet leaves decidability and algorithmic typing open, noting that type checking amounts to solving grade inequalities and semiring arithmetic, potentially transported across modes (Hanukaev et al., 2023). By contrast, the LFDC paper proves decidability via substructuralization from a normalizing intuitionistic dependent theory, but it also leaves universes, inductives, coinductives, and an explicit $\Pi_{!x:!A} B$7-modality to future work (Aberlé, 2024).

Open directions follow directly from these trade-offs. TLL identifies richer effects, fuller concurrency, multiparty sessions, cryptographic protocols, and broader libraries using sort-polymorphism and subset types as future work (Fu et al., 2023). The quantum paper points to dynamic lifting, recursion, identity types, and universes (Fu et al., 2020). The impredicative 2026 development shows that linear equalizers, a dual-decoding universe, and modality injectivity are sufficient to recover initial algebras for lists, which suggests further extensions to larger families of linear inductive types (Speight et al., 9 Feb 2026). The field therefore remains divided between foundational minimality, operational precision, and expressive dependent programming, with no single system yet dominating all three criteria.