Concept Trees: Hierarchical Abstractions

• Concept Trees are hierarchical structures that organize concepts through relationships like prerequisite dependencies, semantic refinement, and entailment.
• They are applied in diverse domains such as action recognition, competency-based education, machine learning interpretability, and semi-structured knowledge storage.
• By compressing complex data into interpretable hierarchies, Concept Trees enhance diagnostic clarity, explanation, and reasoning while addressing domain-specific challenges.

Concept Trees are structured representations in which concepts are organized by relations such as prerequisite dependence, semantic refinement, entailment, or discriminative relevance. In the literature, the term denotes several technically distinct formalisms rather than a single canonical model. It has been used for hierarchical action vocabularies learned from image–description pairs (Gao et al., 2016), directed acyclic graphs of “intuitive ideas/notional machines” coupled to Skill Trees in competency-based education (Bijl, 23 Apr 2025), surrogate decision trees whose nodes are constrained by groups of related variables or inferred semantic concepts (Renard et al., 2019, Chyung et al., 2019), normalized knowledge structures in a Concept Base built from semi-structured data [(Greer, 2014); (Greer, 2016)], and recent mechanisms for tracing conceptual divergence in deep models or for neurosymbolic reasoning in vision-language systems (Tian et al., 26 Sep 2025, Sinha et al., 13 Oct 2025).

1. Major meanings of the term

Setting	Node semantics	Structural form
Action recognition (Gao et al., 2016)	Verb or verb–object action concepts with associated images	4-layer hierarchy
Competency-based education (Bijl, 23 Apr 2025)	Concepts as ideas or definitions one can visualize and grasp intuitively	Directed acyclic graph
Interpretable surrogates (Renard et al., 2019, Chyung et al., 2019)	Variable groups or inferred human-understandable concepts	Decision tree surrogate
Concept Base knowledge storage [(Greer, 2014); (Greer, 2016)]	Cohesive concepts with counts, links, and optional descriptors	Tree structure with inter-tree links
Deep-model analysis and VLM reasoning (Tian et al., 26 Sep 2025, Sinha et al., 13 Oct 2025)	Emergent internal concepts or caption-conditioned verifiable sub-concepts	Hierarchical branching tree or rooted DAG

Across these uses, a Concept Tree usually serves one of three functions. It can be a knowledge organization device, as in Concept Base systems and educational course design. It can be an interpretability scaffold, as in surrogate trees for tabular models, CNNs, and Transformer analyses. It can also be a reasoning substrate, as in compositional caption–image verification. The shared intuition is hierarchical structuring, but the formal edge semantics differ substantially: edges may encode direct prerequisite relations, parent-to-child refinement, semantic entailment, or decision-tree branching.

A common misconception is that every Concept Tree is literally a tree in the graph-theoretic sense. That is false in several formulations. The educational Concept Tree is explicitly a DAG rather than a strict tree, and COCO-Tree is a rooted, directed, acyclic graph (Bijl, 23 Apr 2025, Sinha et al., 13 Oct 2025). Conversely, the Concept Base literature emphasizes tree normalization and treats inter-tree links as preferable to internal backlinks (Greer, 2016).

2. Concept Trees in competency-based education

In competency-based computer science education, a Concept Tree is defined as a conceptual counterpart to the Skill Tree. A concept is “an idea or definition (or combination of) that one can visualize and have an intuitive grasp of,” whereas a skill is something a student is expected to be able to do. The formal definition is explicit: “A Concept Tree (CT) is a Directed Acyclic Graph where the nodes are concepts and the edges denote prerequisite relations between the concepts: one concept is a subconcept of another concept” (Bijl, 23 Apr 2025).

This formulation imposes several modeling constraints. First, the graph is acyclic, and nodes may have multiple incoming edges. Second, only direct necessity is represented: “Subconcepts of subconcepts are not subconcepts.” Third, concepts may not require skills, and redundancy is controlled through “No single-use concepts” and “No equivalent concepts.” The framework therefore distinguishes conceptual understanding from executable competence while maintaining a dependency structure precise enough for sequencing and diagnosis.

The coupling to Skill Trees is semantic and edge-based. The paper states that “Skills often require concepts” and that the joint structure may be called a “Concept/Skill Tree,” although in practice it is still often referred to as a Skill Tree. Course planning then uses both graphs. “Course contents” are all skills and concepts required for learning goals but not already required by prerequisites; concepts are never learning goals themselves and exist to support skill execution. Ordering guidelines include reversed depth-first traversal of the prerequisite DAG, “Skills before concepts,” and “Larger subtrees before smaller subtrees.” Grouping into instructional blocks proceeds by selecting a main skill goal and including the untreated prerequisite skills and concepts that lead to it (Bijl, 23 Apr 2025).

The application to a university database course makes the framework operational rather than merely taxonomic. The joint trees covered roughly fifty concepts and a hundred skills, exposed loose ends, revealed a missing prerequisite for SQL triggers, identified minor mixing in Datalog instruction, and showed mismatches between exercises and taught skills. Student interviews reported reduced confusion and stress and less study time required to reach the desired skill level, although grades were not significantly affected (Bijl, 23 Apr 2025).

This use of Concept Trees is didactic rather than classificatory. It treats concepts as notional machines that scaffold performance, not as final assessment targets. A plausible implication is that the framework’s main contribution lies in prerequisite diagnosis and course-level orchestration rather than in concept testing per se.

3. Action Concept Trees in visual action learning

In computer vision, the Action Concept Tree (ACT) is a hierarchical organization of action concepts discovered from image–description pairs. Each node stores a semantic label and a set of associated images. Leaf nodes correspond to specific verb–object phrases such as “ride bike” or “throw frisbee,” while internal nodes represent generalized actions formed by merging related child nodes. The object part of an internal-node label is named using the lowest common hypernym from WordNet; the verb part is inherited if child verbs are identical, otherwise it is replaced by “interact with” (Gao et al., 2016).

ACT construction begins with image–description pairs filtered to human actions from the Visual Genome Action dataset. The training split contains 52,931 image–description pairs, and the test split contains 4,689 images across 45 action categories. Verb–Object pairs are extracted from captions, their “visualness” is verified, and action-concept similarities are computed from multi-modal representations combining text and associated images. Hierarchical clustering then proceeds through H-ACD: initial NN-Clustering with parameter $C=4$, recursive refinement within clusters until no finer clusters are found, and tree construction through parent–child relations generated during recursion. The resulting ACT is a 4-layer tree with over 100 leaf action nodes. Illustrative branches include “ride motorcycle,” “ride bicycle,” and “ride bike” under “ride wheeled vehicle,” and “catch frisbee,” “hold frisbee,” “play frisbee,” and “throw frisbee” under “interact with frisbee” (Gao et al., 2016).

The ACT is tightly coupled to the Action Semantic Alignment (ASA) model. ASA uses a VGG-16 image encoder, a text encoder consisting of 500-dimensional skip-gram word embeddings and an LSTM with hidden size 1000, and an alignment network of two $1\times1$ convolutional layers with ReLU. Its alignment score is

$s(I, T) = ASA(I, T) = cs.$

Stage 1 trains image–description alignment with

$$loss_{1} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,i})) + \sum_{j=0, j\neq i}^{N} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$

with $\alpha_c = 1$ and $\alpha_w = 0.01$. Stage 2 fine-tunes ASA for action classification using category names as text queries,

$$loss_{2} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,t_i})) + \sum_{j=0, j\neq t_i}^{M} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$

and predicts by

$prediction(I_i) = \arg\max_j cs_{i,j}.$

The ACT supplies weakly labeled images for target categories through category-to-node matching,

$$S(c_i, n_j) = \frac{1}{m} \sum_{k=1}^{m} ASA(I_{jk}, c_i).$$

The principal motivation for ACT is vocabulary flexibility. Test-time categories need not appear verbatim during training, because target labels can be matched to exact nodes, semantically related nodes, or generalized parents. This supports synonymy and paraphrase handling and provides a granularity back-off mechanism when exact training labels are sparse. Experimentally, the full model ASA (Stage 1+2, w/ ACT) achieved mAP 28.5, Recall@1 31.3, and Recall@5 63.2 on VGA, compared with 26.8, 29.6, and 60.4 for ASA (Stage 1+2, w/o ACT). On PASCAL VOC 2012 action classification, ASA+ACT reached mAP 55.2 versus 54.3 for ACD. The paper also reports failure cases, especially overly vague parent names such as “interact with physical entity” and errors involving subtle human–object distinctions such as “hold sandwich” versus “hold banana” (Gao et al., 2016).

4. Concept Trees as interpretable surrogates

A different usage appears in interpretable machine learning, where Concept Trees are surrogate decision trees trained to mimic black-box predictors while forcing the explanation to operate at the level of semantically grouped variables or inferred concepts. In the tabular setting, each concept is a group of dependent variables, either expert-defined or discovered automatically via Pearson correlation. Concepts form a partition of the feature index set, and at each tree node the candidate split is learned using only the variables belonging to a single concept; the concept with the best information gain is chosen. The paper keeps TREPAN’s m-of-n rule form but constrains literals to one concept per node (Renard et al., 2019).

For automatically discovered concepts, the grouping uses a dependence measure $\rho$ and threshold $1\times1$0, with experiments using Pearson correlation and $1\times1$1. The within-concept condition is

$1\times1$2

The surrogate is then trained on the black-box predictions rather than ground truth, and fidelity is the proportion of test instances on which surrogate and black-box agree. On FRED-MD, a macroeconomic dataset with 134 variables, Concept Trees preserved accuracy and fidelity while improving human-readability relative to TREPAN when m-of-n rules were nontrivial. For example, at 3-of-3 nodes, Concept Tree (Expert) achieved accuracy $1\times1$3 and fidelity $1\times1$4, while TREPAN achieved $1\times1$5 and $1\times1$6 (Renard et al., 2019).

In CNN interpretability, the term denotes a concept-based decision tree whose internal nodes test the presence or absence of concepts inferred from hidden-layer activations. Concepts are human-understandable attributes such as colors, materials, scenes, or object parts. The pipeline first trains binary linear concept classifiers on hidden activations extracted from a pretrained ResNet-50 using BRODEN, a densely labeled image dataset with over 60,000 images and 1,189 concept labels; concepts with fewer than 1,000 examples are discarded, leaving about 200 concepts. A classifier $1\times1$7 for each concept $1\times1$8 produces binary concept indicators

$1\times1$9

which are then used as features for a CART surrogate trained to predict the CNN’s class output (Chyung et al., 2019).

The tree’s fidelity to the CNN is

$s(I, T) = ASA(I, T) = cs.$0

Layer choice is critical: conv4_x yielded the highest average concept-classifier accuracy, 0.844, and the largest number of usable concepts. Fidelity increased sharply with tree depth and then saturated beyond about 10 levels. On Mini Natural Images, a shallow tree with max depth 5 and min sample size 20 achieved fidelity 0.9134, close to deeper but less interpretable trees. This formulation makes concept interactions explicit at the path level, such as “wheel” present versus “eyebrow” present, while preserving a global summary of the CNN’s behavior (Chyung et al., 2019).

Taken together, these surrogate-based Concept Trees do not primarily organize knowledge for storage or pedagogy. They regularize explanation spaces. In one case, the regularizer is concept coherence among correlated variables; in the other, it is semantic binarization of hidden activations.

5. Concept Trees in Concept Bases and semi-structured knowledge

In the Concept Base literature, Concept Trees are knowledge structures that grow from semi-structured sources such as text documents when consistent sequences of concepts are presented. A tree starts with a base node and extends with branches of related nodes; ideally, each tree represents a single cohesive concept. The surrounding database is called a Concept Base and is presented as an architecture that sits “between the highly distributed neural architectures and the distributed information systems” [(Greer, 2014); (Greer, 2016)].

A central normalization principle is the counting rule: every child node’s occurrence count must be the same or less than the parent’s,

$s(I, T) = ASA(I, T) = cs.$1

The earlier formulation treats Concept Trees as dynamic structures that can grow, prune, merge, or re-join as statistical feedback dictates, with the construction process intended to maintain generality and some degree of optimization or normalization. The later formulation makes the normalization logic more explicit: if backlinks arise within a tree, the affected part is split into a separate tree and the backlink becomes an inter-tree link, because state changes should occur across trees rather than within them [(Greer, 2014); (Greer, 2016)].

The 2016 extension adds context. Static tree structure is carried by nouns and verbs, while descriptors—adjectives for nouns and adverbs for verbs—provide a separate, dynamic context layer attached to nodes. Descriptor nodes store occurrence counts and optional weight values for reinforcement. The paper gives examples such as “soft 10 (0.8)” for positive reinforcement and “wet 10 (-0.2)” for negative reinforcement, computed by occurrence multiplied by weight. Context is updated during search, whereas structural node counts are updated during path selection or structural change. The representation of concept-context tuples is illustrated as

$s(I, T) = ASA(I, T) = cs.$2

The paper also proposes using the linking structure of the licas system as a basis for context links and defines auxiliary expressions such as $s(I, T) = ASA(I, T) = cs.$3 for tree shape and $s(I, T) = ASA(I, T) = cs.$4 for join decisions (Greer, 2016).

Text-building experiments provide concrete evidence about the induced structure. In 75 parsed documents, splitting due to the counting rule occurred only 3 times. There were 82 trees from 75 documents, 234 nodes appeared in more than 1 tree, and 686 nodes appeared in only 1 tree. Of the 234 overlapped nodes, 52 were at bases, and 39 of those were linked from other tree branches. Most trees had depth 2, depth 3 occurred less often, and deeper trees were possible when parsing whole sentences. The paper argues that these observations suggest that tree structure could be inherent in natural language (Greer, 2016).

The same line of work defines two query languages. One is clause-like and can fill missing slots in a query from retrieved knowledge, as in recovering “blue” for trousers from the sentence “Jack wore a white shirt and blue trousers.” The other searches for paths under a maximum path length and can augment a query using descriptor-derived knowledge. These mechanisms position Concept Trees as an indexed, navigable, and context-sensitive knowledge store rather than as an explanatory surrogate or didactic dependency graph (Greer, 2016).

6. Concept Trees for internal model analysis and compositional reasoning

Recent work extends the term into deep-model interpretability and neurosymbolic vision-language reasoning. In MindCraft, Concept Trees model how concepts form, diverge, and stabilize inside deep models under counterfactual interventions. The method traces the difference between an original sequence $s(I, T) = ASA(I, T) = cs.$5 and a counterfactual $s(I, T) = ASA(I, T) = cs.$6 through the model’s layers, focusing on last-token value representations. For each layer, MindCraft computes an SVD of the self-attention value transform,

$s(I, T) = ASA(I, T) = cs.$7

and defines a spectral signature

$s(I, T) = ASA(I, T) = cs.$8

After top-$s(I, T) = ASA(I, T) = cs.$9 filtering, conceptual separation is measured by

$$loss_{1} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,i})) + \sum_{j=0, j\neq i}^{N} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$0

and the first branching layer is

$$loss_{1} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,i})) + \sum_{j=0, j\neq i}^{N} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$1

The reported empirical pattern is branch-and-stabilize: similarity is high in early layers, drops sharply in mid-layers, and stabilizes later. With default $$loss_{1} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,i})) + \sum_{j=0, j\neq i}^{N} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$2 and $$loss_{1} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,i})) + \sum_{j=0, j\neq i}^{N} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$3, the framework recovers semantic hierarchies across medical diagnosis, physics reasoning, political decision-making, and other scenarios. It also reports weak correlation between input-embedding distance and branching layer, with overall Pearson $$loss_{1} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,i})) + \sum_{j=0, j\neq i}^{N} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$4 and Spearman $$loss_{1} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,i})) + \sum_{j=0, j\neq i}^{N} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$5 across scenarios (Tian et al., 26 Sep 2025).

COCO-Tree uses a different recent meaning. Here the Concept Tree is a caption-rooted neurosymbolic DAG for compositional image–text reasoning. It is defined as

$$loss_{1} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,i})) + \sum_{j=0, j\neq i}^{N} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$6

where $$loss_{1} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,i})) + \sum_{j=0, j\neq i}^{N} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$7 is a set of concept nodes, $$loss_{1} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,i})) + \sum_{j=0, j\neq i}^{N} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$8 encodes hierarchical semantic entailment, and each node carries a composite relevance score

$$loss_{1} = \sum_{i=0}^{N} \left[ \alpha_c \log(1 + \exp(-cs_{i,i})) + \sum_{j=0, j\neq i}^{N} \alpha_w \log(1 + \exp(cs_{i,j})) \right],$$9

Linguistic entailment and visual grounding are both obtained from binary “Yes/No” queries to an LLM and a VLM. Tree construction has three steps: Semantic Morphological Decomposition, which partitions the caption into $\alpha_c = 1$0 disentangled entities; Recursive Concept Exploration, which expands each node with $\alpha_c = 1$1 binary, verifiable children up to depth $\alpha_c = 1$2; and composite scoring. Reasoning proceeds by greedy search or beam search over paths, with the beam update

$\alpha_c = 1$3

The selected path score is fused with the base VLM score as

$\alpha_c = 1$4

Using defaults $\alpha_c = 1$5, $\alpha_c = 1$6, $\alpha_c = 1$7, and typically $\alpha_c = 1$8, COCO-Tree improves compositional benchmarks by 5–10% on average. Specific group-score gains include LLaVA-1.5-7B on Winoground from 29.25 to 35.25, on EqBench from 21.75 to 37.50, and on ColorSwap from 74.00 to 87.66 (Sinha et al., 13 Oct 2025).

These two recent directions differ in ontology but converge in function. MindCraft treats the tree as a map of latent conceptual divergence inside a model. COCO-Tree treats it as an explicit reasoning scaffold outside the base VLM. In both cases, the hierarchy is used to expose where conceptual distinctions emerge and how they drive decisions.

7. Cross-cutting properties, limitations, and misconceptions

Several structural regularities recur across the literature. First, Concept Trees nearly always compress a larger raw space into a smaller, more interpretable structure: captions into verb–object hierarchies, skills into notional prerequisites, correlated variables into concept-constrained splits, raw text into normalized knowledge trees, hidden activations into semantic decision paths, or captions into verifiable compositional sub-concepts. Second, edge semantics are always stronger than mere association. They encode direct necessity, finer-grained specialization, semantic entailment, or branch-inducing separation. Third, many formulations explicitly separate a stable backbone from a more flexible or data-driven overlay: ACT combines a fixed hierarchy with ASA alignment; educational CTs pair concepts with skills; Concept Bases separate static trees from descriptor context; COCO-Tree fuses symbolic search with neural scores (Gao et al., 2016, Bijl, 23 Apr 2025, Greer, 2016, Sinha et al., 13 Oct 2025).

The limitations are equally domain-specific. ACT is vulnerable to parsing and naming noise, vague WordNet hypernyms such as “physical entity,” caption ambiguity, dependence on similarity computation and NN-clustering quality, and domain shift between weakly labeled source data and target distributions (Gao et al., 2016). Educational Concept Trees face a measurement problem: improved structure did not noticeably change exam grades, and alternative outcomes such as stress, well-being, and study-time efficiency are difficult to measure objectively (Bijl, 23 Apr 2025). Correlation-based surrogate Concept Trees are sensitive to the threshold $\alpha_c = 1$9, do not handle overlapping concepts, and may lose cross-concept interactions when one-concept-per-node or one-concept-per-path restrictions are enforced (Renard et al., 2019). CNN concept trees depend on the availability of dense concept labels and on a hidden layer whose activations linearly separate many concepts (Chyung et al., 2019). Concept Base systems can fragment under splits, and their normalization logic does not by itself solve ambiguity in semi-structured sources (Greer, 2016). MindCraft requires informative linear structure and can be expensive because per-layer SVD is $\alpha_w = 0.01$0, while COCO-Tree remains exposed to LLM/VLM hallucinations and to inference-time growth in tree size and beam-search cost (Tian et al., 26 Sep 2025, Sinha et al., 13 Oct 2025).

A second common misconception is that “concept” has a stable meaning across these papers. It does not. Depending on the formulation, a concept may be a verb–object action phrase, an idea or definition that can be visualized, a group of dependent variables, a binary semantic attribute in images, a cohesive knowledge unit with descriptors, a spectral direction of representational divergence, or a short verifiable caption fragment. This suggests that Concept Trees are best understood as a family of hierarchical abstraction mechanisms rather than as a single unified formal object.

The term therefore names a methodological pattern more than a universal data structure. Its persistent attraction comes from the same tension across domains: raw data, latent states, or curricula are too flat or too entangled for direct use, and a hierarchy of concepts promises better organization, diagnosis, explanation, or reasoning.