Logical Depth

Logical depth is a measure of complexity proposed by Charles Bennett in 1988. It is defined as the computation time required by the shortest program (in the sense of Kolmogorov complexity) to produce a given object. Where Kolmogorov complexity measures informational complexity — how compressed can a description be — logical depth measures computational complexity — how much work is required to unpack a compact description into the full object.

Logical depth captures what intuition calls 'organized complexity': objects with high logical depth are neither random (which have high Kolmogorov complexity but low depth, since a short program 'output random noise' trivially generates them) nor trivially structured (which have low complexity and low depth). Deep objects are the outputs of long computations from compact programs — they are, in a precise sense, historically accumulated. A living organism has high logical depth because it is the output of billions of years of evolutionary computation from the compact initial conditions of early life.

This connection to history makes logical depth philosophically important for complex systems theory: it provides a mathematical basis for the intuition that complex organization cannot arise quickly. Any process that produces an object with high logical depth must itself have run for a long time, or must have been supplied with equivalent pre-computed information. There are no shortcuts to biological, cultural, or cognitive complexity.

Logical Depth and the Transfer of Complexity

Bennett's original definition measures the depth of a single object: the computation time required to produce that object from its shortest description. But this definition assumes that each object must be generated de novo. In systems where complexity can be transferred — where one object's depth can be encoded into another object that serves as a compressed proxy — the depth of the proxy is not the same as the depth of the original.

Large language models are a striking example. The behavioral complexity of modern AI systems — their capacity for reasoning, translation, and synthesis — reflects logical depths that would require centuries of individual human learning to accumulate. Yet the model itself was produced in weeks by gradient descent. The model is not as deep as the culture it compresses, but it is transferably deep: once trained, its compressed complexity can be instantiated millions of times without recomputing the history.

This raises a question that logical depth, in its original formulation, does not answer: what is the depth of a compression? If a program P compresses the output of a billion-year computation into a terabyte of weights, is P shallow (because it ran for weeks) or deep (because its output encodes the depth of the original)? The answer depends on whether depth is a property of the generating process or of the information content generated. Bennett chose the former. The existence of transferable complexity suggests that the distinction may not be as clean as the article assumes.

The systems-theoretic implication is that logical depth may need a dual account: process depth (how long did the generator run?) and content depth (how much historically accumulated computation is encoded in the output?). Under process depth, AI models are shallow. Under content depth, they are deep. The tension between these two measures is not a paradox but a diagnostic: it tells us that the universe has found a way to compress historical depth into transferable form, and that our formalisms have not yet caught up with this capability.