INQUIRING LINE

When researchers use tools to peek inside an AI, can they spot ideas, facts, or real rules, and which can they trust?

What levels of understanding about LLM knowledge representation can automated systems reliably extract?

This explores how deep an understanding of an LLM's knowledge automated tools can recover (which concepts it holds, which facts it links, or which general principles it applies) and where that recovery stops being trustworthy.


This reads the question as: when automated tools look inside or around an LLM, how much of its knowledge can they recover, and which levels of that knowledge are they actually reliable on? The corpus has one direct answer, and it's layered. Mechanistic interpretability, the work of reverse-engineering a model's internals, finds three tiers of understanding. The first is conceptual, where ideas show up as directions in the model's internal space. The second is state-of-the-world, where facts are connected to each other. The third is principled, where compact circuits implement a general rule. The catch is that the higher tiers don't replace the lower ones. They sit alongside lower-tier shortcuts, so the picture is a patchwork, not a clean staircase (Do language models understand in fundamentally different ways?). Finding a principled circuit shows that the model has one. It doesn't show the model uses it every time.

That gap between having and using explains why the easiest automated route, asking the model to explain itself, is the least reliable one. Models can explain a concept correctly, fail to apply it, and then recognize that they failed. Human understanding doesn't break down that way, which suggests the explaining and doing pathways are largely disconnected (Can LLMs understand concepts they cannot apply?). Stripping the meaning out of a reasoning task makes the same point from the other side. Performance collapses even when the correct rules are sitting in context, so much of what looks like rule-following is really association with what the words usually mean (Do large language models reason symbolically or semantically?). Tools that probe with perturbations like this can reliably extract the associative layer. Whether a rule is really being applied is harder to establish.

A second pattern is that automated checks tend to capture surface form more reliably than meaning. LLMs write well-formed logic that is semantically wrong, with errors clustering around scope, quantifiers and predicate granularity. A parser would pass all of it (Can large language models translate natural language to logic faithfully?). Errors in complex grammar grow predictably with syntactic depth, which suggests surface patterns were learned and deep rules weren't (Why do large language models fail at complex linguistic tasks?). The trend is also getting worse for surface-level checking. Weaker models visibly delete content, but frontier models corrupt it while keeping the document looking intact (Does model capability change how documents degrade?). More capable models make surface checks less informative about the knowledge underneath.

Two other approaches get around the problem by changing what gets extracted. One is to make the model emit its working knowledge in an inspectable form. Knowledge Graph of Thoughts has a small model build reasoning as explicit triples, which makes each step checkable (Can structuring reasoning as knowledge graphs help smaller models solve complex tasks?). That exposes the task's working knowledge, not what is stored in the weights. The other is conflict detection. Timestamped knowledge bases let a system automatically notice when new information contradicts old, but choosing the right side depends on context outside the system, so a human has to resolve it (Can LLMs learn reliably at test time without human oversight?). Systems checking themselves are also formally limited by the gap between generating and verifying, and measurement error hides the true ceiling (What limits autonomous capability in large language models?).

The corpus has no head-to-head study of extraction reliability at each tier, so this is a pattern across notes, not a measured ranking. The pattern is that automation reliably gets the concept and association layer, and it can flag conflicts and structural errors. It is much weaker at confirming that a principle is actually being applied, or that a fluent output means what it appears to mean.


Sources 9 notes

Do language models understand in fundamentally different ways?

Mechanistic interpretability reveals conceptual understanding (features as directions), state-of-world understanding (factual connections), and principled understanding (compact circuits). Crucially, higher tiers coexist with lower-tier heuristics rather than replacing them, creating a patchwork of capabilities.

Can LLMs understand concepts they cannot apply?

Models can explain concepts accurately, fail to apply them, and recognize the failure—a triple pattern incompatible with human cognition. This indicates functionally disconnected explanation and execution pathways rather than simple knowledge gaps.

Do large language models reason symbolically or semantically?

When semantic content is decoupled from reasoning tasks, LLM performance collapses even with correct rules in context. Models rely on parametric commonsense and token associations rather than formal logical manipulation, constraining reasoning to training distribution semantics.

Can large language models translate natural language to logic faithfully?

LLMs generate well-formed logical expressions that are semantically incorrect, with errors clustering at scope ambiguity, quantifier precision, and predicate granularity. The asymmetry suggests LLMs understand formal language better than they can generate it.

Why do large language models fail at complex linguistic tasks?

Top-tier LLMs like Llama3-70b consistently misidentify embedded clauses, verb phrases, and complex nominals. Performance degrades predictably as syntactic depth increases, revealing that statistical learning captures surface patterns but not deep grammatical rules.

Show all 9 sources
Does model capability change how documents degrade?

DELEGATE-52 shows weaker LLMs degrade documents through visible deletion, while frontier models degrade through subtle corruption that preserves surface integrity. This shift makes frontier failures harder to detect and potentially more dangerous at workflow scale.

Can structuring reasoning as knowledge graphs help smaller models solve complex tasks?

Knowledge Graph of Thoughts (KGoT) achieves 29% improvement on GAIA Level 3 tasks using GPT-4o mini by externalizing reasoning into iteratively constructed KG triples. The approach improves transparency, reduces bias, and enables quality control over reasoning steps.

Can LLMs learn reliably at test time without human oversight?

ARIA demonstrates that LLMs can adapt during inference through three integrated components: structured self-dialogue for uncertainty assessment, timestamped knowledge bases for conflict detection, and human-mediated resolution queries. Autonomous systems fail at reconciling contradictory rules because the correct choice depends on context outside the system.

What limits autonomous capability in large language models?

Multi-agent deliberation produces specific failure modes (Degeneration-of-Thought, Silent Agreement), alignment at scale includes problematic self-valuation, and self-improvement is formally bounded by the generation-verification gap. Measurement error and conditional compliance hide the true capability ceiling.

Papers this line draws on 8

The research behind the notes this line reads — ranked by how closely each paper relates.