Paper deep dive
Cognitive Schemas, Laws and Tasks
Antal Jakovác, András Telcs
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 10/11/2026, 2:34:24 AM
Summary
The paper proposes a structural framework for knowledge-based problem solving where cognitive schemas are organized by their information and relational requirements rather than as independent primitives. It introduces a task-schema interface that distinguishes between representation limitations (inconsistency, underdetermination, contextual insufficiency) and solving procedure limitations. The framework utilizes a Knowledge Space containing contexts, concepts, and stabilized laws, allowing schemas to be derived, lifted as concepts, and reused across different tasks and representations.
Entities (9)
Relation Signals (7)
András Telcs → authored → Cognitive Schemas, Laws and Tasks
confidence 99% · Cognitive Schemas, Laws and Tasks Antal Jakovác1 András Telcs1
Antal Jakovác → authored → Cognitive Schemas, Laws and Tasks
confidence 99% · Cognitive Schemas, Laws and Tasks Antal Jakovác1 András Telcs1
Task-Schema Interface → distinguishes → Underdetermination
confidence 95% · The resulting task–schema interface... makes it possible to separate limitations of the representation... we distinguish inconsistency, underdetermination, and contextual insufficiency
Task-Schema Interface → distinguishes → Contextual Insufficiency
confidence 95% · The resulting task–schema interface... makes it possible to separate limitations of the representation... we distinguish inconsistency, underdetermination, and contextual insufficiency
Task-Schema Interface → distinguishes → Inconsistency
confidence 95% · The resulting task–schema interface... makes it possible to separate limitations of the representation... we distinguish inconsistency, underdetermination, and contextual insufficiency
Cognitive Schema → ispartof → Knowledge Space
confidence 90% · The framework provides... a Knowledge Space as a substrate... schemas are organized by the information and relations required for their use
Concept Graph → hosts → Cognitive Schema
confidence 88% · the Concept Graph serves as a host for concepts, schemas, and stabilized laws.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:This paper asks how explicit representations can support reusable cognitive schemas in knowledge-based problem solving. We develop a structural framework in which schemas are organized by the information and relations required for their use, rather than introduced as unrelated primitives. The framework also distinguishes context-dependent relations from more stable structures that can be reused across different representations. Tasks are described through the information available, the unknowns to be determined, and the constraints that admissible solutions must satisfy. This makes it possible to separate limitations of the representation from limitations of the solving procedure. In particular, we distinguish inconsistency, underdetermination, and contextual insufficiency, where the current representation lacks distinctions or relations required by the external task meaning. We also show formally when a reduction of representation preserves the task-relevant solution structure. The resulting task--schema interface offers a structured way to describe representational conditions relevant to problem solving. It supports the reuse and stabilization of derived knowledge while remaining independent of the particular mechanism used to generate candidate solutions. This may provide a useful component for future solver architectures that combine structured knowledge, verification, and learned proposal mechanisms.
Tags
Links
- Source: https://arxiv.org/abs/2610.09495v1
- Canonical: https://arxiv.org/abs/2610.09495v1
Trouble viewing inline? Open PDF directly →
Full Text
73,029 characters extracted from source content.
Expand or collapse full text
Cognitive Schemas, Laws and Tasks Antal Jakovác1 András Telcs1,* 1HUN-REN Wigner Research Centre for Physics, Institute for Particle and Nuclear Physics, Computational Sciences Department, Data and Compute Intensive Sciences Research Group, Budapest, Hungary. E-mail: jakovac.antal@wigner.hun-ren.hu *Corresponding author: András Telcs, telcs.andras@wigner.hun-ren.hu ORCID (András Telcs): 0000-0002-3205-3081 Abstract This paper asks how explicit representations can support reusable cognitive schemas in knowledge-based problem solving. We develop a structural framework in which schemas are organized by the information and relations required for their use, rather than introduced as unrelated primitives. The framework also distinguishes context-dependent relations from more stable structures that can be reused across different representations. Tasks are described through the information available, the unknowns to be determined, and the constraints that admissible solutions must satisfy. This makes it possible to separate limitations of the representation from limitations of the solving procedure. In particular, we distinguish inconsistency, underdetermination, and contextual insufficiency, where the current representation lacks distinctions or relations required by the external task meaning. We also show formally when a reduction of representation preserves the task-relevant solution structure. The resulting task–schema interface offers a structured way to describe representational conditions relevant to problem solving. It supports the reuse and stabilization of derived knowledge while remaining independent of the particular mechanism used to generate candidate solutions. This may provide a useful component for future solver architectures that combine structured knowledge, verification, and learned proposal mechanisms. Keywords: cognitive schemas, structural representation, Knowledge Space, context, task formulation, problem solving 1 Introduction Knowledge representation is a central component of intelligent problem solving: the form in which a task and its objects are represented determines which relations, transformations, and solution procedures are available. This paper develops a structural account of cognitive schemas within the representational framework introduced in [1] and further discussed in [2]. That framework provides finite contexts, invariance relations, representative objects, and a Knowledge Space as a substrate for problem solving. Here we ask which higher-level schemas can be derived from this substrate without introducing additional representational primitives. The main idea is that notions such as equivalence, order, successor, conditional dependence, causal dependence, discrete succession, number-like structure, implication, and logical operations can be represented as derived structural patterns. They are not introduced as independent cognitive faculties or algorithmic modules. Instead, their applicability follows from relations among contexts, representational objects, and admissible transformations. The central contribution is a dependency-structured hierarchy of such schemas together with a formal task–schema interface. The hierarchy identifies the representational conditions required for progressively richer relational and process structures. A task is represented by a context, given elements, unknown placeholders, and constraints. These jointly determine the admissible instantiations of the unknowns and the schemas that can legitimately be applied. Problem solving can therefore be viewed as constrained instantiation under task-compatible representational structure. This formulation also makes it possible to distinguish failures of representation from failures of a solving procedure. We identify three basic forms of ill-posedness: inconsistency, underdetermination, and contextual insufficiency. In each case, the task specification fails to provide the representational conditions required for a unique admissible solution. The contribution lies in the organization of these notions within a common structural framework: contexts are task-relative representational structures, schemas specify conditions of structural applicability, laws capture relations stable across relevant contexts, and task formulation determines which schemas may participate in problem solving. The paper develops this representational layer through the schema hierarchy, the task–schema interface, and explicit conditions for task ill-posedness. 2 Related Work The closest predecessors of the present framework do not form a single research tradition. Schema theory and cognitive architectures begin from organized knowledge and action; rough sets and Formal Concept Analysis from formal distinctions among objects; analogy and program induction from reusable relational structure; and recent work on language models and knowledge graphs from the interaction between linguistic competence and explicit knowledge. These lines address different parts of the representational problem considered here. Classical schema theory treats schemas as organized knowledge structures that guide memory, interpretation, and action [3, 4]. Related developments in artificial intelligence introduced frames, scripts, plans, and goals as structured representations for understanding and problem solving [5, 6]. Cognitive architectures and production-system approaches, including ACT-R, Soar, and problem-space formulations, similarly organize cognition around structured states, operators, goals, productions, and memory [7, 8, 9]. The present work isolates one component of this broader architectural problem: the representational conditions under which particular schemas become applicable to a task. Several formal representation frameworks are especially close to the present setting. Rough set theory uses indiscernibility relations and partitions to study approximation, reducts, and decision rules [10, 11, 12]. Formal Concept Analysis constructs extent–intent concepts and concept lattices from formal contexts [13, 14]; pattern structures extend this construction to richer descriptions [15], while granular computing studies granules as units of abstraction and problem solving [16]. Conceptual graphs and related knowledge-representation formalisms provide graph-based representations of concepts and relations [17, 18]. In the present framework, contexts are task-relative representational partitions, while the Concept Graph serves as a host for concepts, schemas, and stabilized laws. This gives these structures a different role from an FCA concept lattice, a conceptual graph in Sowa’s sense, or a domain ontology. Relational structure is treated in several distinct ways in theories of analogy and abstraction. Structure-mapping theory locates analogical correspondence primarily in relations among objects rather than in matches between isolated attributes [19]. Constraint-based accounts add semantic and pragmatic constraints to the structural requirements of a mapping [20]. Conceptual spaces organize concepts through geometric quality dimensions and similarity [21], whereas compositional approaches study the preservation of structure under more abstract transformations [22]. These approaches therefore provide different formal views of comparison, similarity, and structural organization. A separate computational question is how reusable structures are learned and combined across tasks; this is addressed more directly in program induction and rule learning. Program induction and rule learning make the dependence of rule discovery on an available representational language particularly clear. Inductive logic programming induces logical hypotheses from examples and background knowledge [23, 24], whereas DreamCoder and related approaches learn reusable abstractions that can be composed across tasks [25, 26, 27]. In each case, the space of candidate rules is delimited by the available primitives and admissible forms of composition. The corresponding representational issue is therefore concrete: a schema or relation can be applied only when the task context supplies the distinctions and relational structure required to express it. Modern machine learning locates relational structure and invariance at several distinct levels. Relational inductive biases and graph-based models organize computation around relations among represented objects [28, 29, 30]. Group-equivariant architectures incorporate specified transformation symmetries into the model architecture [31], while invariant risk minimization treats stability across environments as a learning criterion [32]. These examples show that relational structure and invariance may enter through the representation, the architecture, or the learning objective. In the present framework, invariance recognition and representative selection operate on task-relative contexts: they determine which distinctions are preserved under admissible transformations and which may be suppressed. This places the issue at the level of task representation rather than the choice of a particular model class or loss function. Task specification provides another point of contact. In formal methods and program synthesis, admissible solutions are defined relative to explicit specifications and constraints before search is performed [33, 34]. Causal models likewise make variables, structural relations, and admissible interventions explicit [35]. Work on benchmark design and generalization has also shown that apparent learning failures may reflect mismatches between data, representation, and evaluation criteria [36, 37]. The framework likewise makes task structure explicit, while also treating the representational context as part of the task specification. This makes it possible to distinguish inconsistency, underdetermination, and contextual insufficiency from failures of a particular search, learning, or inference procedure. Recent work on integrating large language models with explicit knowledge structures is also relevant to the broader motivation of the framework. A recent TIST special issue identifies three complementary directions: examining the limits of structured knowledge implicitly available in LLMs, using LLMs to construct or enrich explicit knowledge structures, and using such structures to support more grounded retrieval and reasoning [38]. Experiments on public ontologies show that general-purpose pretrained LLMs reproduce exact identifier–label associations only incompletely, with successful recall strongly associated with concept frequency on the Web [39]. These results caution against identifying the implicit representation of a pretrained language model with an explicit and reliably accessible knowledge structure. Conversely, LLMs can assist the construction and extension of explicit structures. GPT-assisted entity typing can enrich entity, type-cluster, and relation representations in an existing knowledge graph [40], while FLAME uses an LLM to propose the placement of new concepts in an existing expert-curated taxonomy [41]. Language models can also provide an interface between external task descriptions and formal structured representations. Meloni et al. study the translation of natural-language scientific questions into executable SPARQL queries over knowledge graphs and show that explicit entity and relation information can substantially assist this translation [42]. These approaches illustrate different ways in which the broad linguistic competence of pretrained models can complement explicit structured knowledge. Of particular relevance to future solver architectures, Zhang et al. combine an LLM with an explicit knowledge graph, meta-knowledge, short- and long-term memory, and a self-correcting mechanism [43]. Experience acquired during interaction is retained and reused across subsequent tasks, providing incremental adaptation outside the fixed pretrained model. This direction is close in motivation to the separation considered here between problem-solving mechanisms and an explicit persistent knowledge structure. The Knowledge Space proposed in our framework is nevertheless different from these knowledge graphs and meta-knowledge stores. Its Concept Graph is not primarily a repository of externally specified entities and factual triples, and its persistent structures are not limited to strategies for querying an existing graph. Instead, the Knowledge Space is intended to contain task-relative concepts, schemas, and stabilized laws that can be constructed and reused across contexts. The present paper provides the representational layer on which such interpretation, proposal, verification, and controlled knowledge-extension mechanisms can be organized. Overall, existing work provides rich accounts of structured knowledge, relations, abstraction, invariance, and formal task specification. The distinctive feature of the present framework is their organization around an explicit task-relative context: contexts determine available distinctions, schemas specify structural applicability, laws capture relational structure stable across admissible context transformations, and task formulation determines which of these structures can participate in problem solving. 3 Cognitive Schemas and Structural Derivation Schemas, Application Frames, and Applicability We use cognitive schema as the general term for reusable structural mappings. A cognitive primitive is itself a schema. Primitive schemas belong to the initial cognitive basis, whereas derived schemas use structures made available by other schemas or by previously stabilized conceptual objects. The schemas developed below are therefore presented in a dependency-compatible order: the prerequisites of a derived schema are introduced before the schema that uses them. The dependency structure need not form a single linear chain. Throughout the paper, C⊆ΩC denotes the underlying class or base domain of a context, C denotes a finite context on C, and c∈c denotes a context cell. When a cell is represented by a distinguished object, we may use that representative in place of the cell when no ambiguity results. A schema S is represented by S=(IS,OS,PS,ΦS),S=(I_S,O_S,P_S, _S), where ISI_S specifies its typed input placeholders, OSO_S its typed output placeholders, PSP_S its structural prerequisites, and ΦS _S the structural mapping associated with the schema. The input and output placeholders have the form IS=(x1:τ1,…,xm:τm),I_S=(x_1: _1,…,x_m: _m), and OS=(y1:σ1,…,yn:σn),O_S=(y_1: _1,…,y_n: _n), where τi _i and σj _j are the required types. The types specify which kinds of objects may occupy the corresponding placeholders. They may refer, for example, to contexts, context cells, concepts, relations, laws, schemas, or other structured objects available in the Knowledge Space. No fixed exhaustive collection of types is required here. The mapping ΦS _S is structural rather than algorithmic. It specifies which output structure becomes available when the input placeholders are instantiated by compatible objects and the prerequisites PSP_S are satisfied. A schema is generally not applied to a context alone. Its application also depends on the objects currently available, the outputs sought, and the relevant local constraints. We represent this information by a schema application frame =(,X,Y,Γ),A=(C,X,Y, _A), where C is the active context, X is the collection of available objects and structures, Y is the collection of output placeholders available to the application, and Γ _A contains the constraints relevant to that application. Elements of Y may correspond to unknowns of the task or to intermediate objects introduced during problem solving. An application frame contains more information than the context but need not contain the complete task. For a task =(,G,U,Γ),T=(C,G,U, ), an application frame selects the part of the task and of the currently available derived structure that is relevant to one prospective schema application. Different schemas may therefore be applied to different application frames within the same task. An instantiation of S in A assigns available objects to the input placeholders of S and associates its output placeholders with compatible elements of Y. We write App(S,,ι)App(S,A, ) when an instantiation ι satisfies the following conditions: 1. every input placeholder xi:τix_i: _i is assigned an object compatible with the required type τi _i; 2. every output placeholder yj:σjy_j: _j is associated with an output of compatible type σj _j; 3. the structural prerequisites PSP_S are satisfied by the instantiated objects in the context C; 4. the instantiation is compatible with the local constraints Γ _A. The schema S is applicable to A if at least one such instantiation exists: App(S,)⟺∃ιApp(S,,ι).App(S,A) ∃ \;App(S,A, ). For an admissible instantiation, ΦS _S determines the corresponding admissible output structure or structures. Applicability therefore depends jointly on type compatibility, the active context, the available objects, and the local constraints. This formulation also gives a precise meaning to dependency between schemas. We write S1⊲S2S_1 S_2 if a structure produced by an admissible application of S1S_1, or the stabilized schema concept corresponding to S1S_1, can satisfy an input placeholder or a structural prerequisite of S2S_2. The relation ⊲ denotes direct structural dependency. Dependency does not by itself imply applicability. If S1⊲S2,S_1 S_2, an application of S1S_1 may provide one of the structures required by S2S_2, but S2S_2 becomes applicable only when its remaining typed inputs, structural prerequisites, and local constraints are also satisfied in the corresponding application frame. In this sense, derivation denotes typed structural construction rather than logical implication between schema names. For example, Sorder⊲SsuccS_order S_succ expresses that an ordered structure can satisfy a prerequisite of the successor schema. Once the remaining applicability conditions are met, the successor schema can use this structure to construct the corresponding minimal-progression relation. More generally, a derived schema is a schema whose admissible application uses structural objects made available by preceding schema applications or by their stabilized conceptual representations, rather than relying only on the initial cognitive basis. Schemas may themselves become objects of representation. When a schema S is sufficiently stable for reuse across a family of applications, it may be lifted into the Concept Graph as a schema concept. We denote this by Lift(S)=cS.Lift(S)=c_S. The schema S and the concept cSc_S have distinct functions. The schema is the structural mapping that can be instantiated and applied, whereas cSc_S represents that schema as a conceptual object. The lifted object may therefore be referred to, compared, generalized, specialized, or used as an input to another schema. The same distinction applies when a schema refers to an ordinary concept. A concept node represents a stable conceptual object, whereas a particular schema application may require a context-relative realization of that concept. Let Inst(c)Inst_A(c) denote the admissible realizations of a concept c in the application frame A. A concept may have one or more associated instantiation schemas. If ScinstS_c^inst is such a schema, an admissible application has the form Scinst(c,)=x,S_c^inst(c,A)=x_A, with x∈Inst(c).x_A _A(c). Thus, when an input placeholder of a schema requires a context-relative object but is associated with a concept c, the corresponding instantiation schema supplies an admissible realization before the main schema is applied. Schematically, c⟶x⟶ΦS(x,…).c x_A _S(x_A,…). This is different from a meta-level application. If an input placeholder explicitly requires a concept or a schema concept, the conceptual object itself may be used as the input. A higher-level schema may therefore operate directly on previously stabilized schemas. For example, if S1S_1 and S2S_2 have been lifted, Lift(S1)=cS1,Lift(S2)=cS2,Lift(S_1)=c_S_1, (S_2)=c_S_2, a higher-level schema H may use these schema concepts as inputs and produce a new schema S3S_3: (cS1,cS2)→S3.(c_S_1,c_S_2) HS_3. If S3S_3 subsequently becomes stable for reuse, it may itself be lifted: S3→LiftcS3.S_3 Liftc_S_3. Consequently, schema construction is not restricted to a fixed hierarchy. Primitive schemas can support derived schemas; stabilized schemas can become conceptual objects; and these schema concepts can participate in the construction of further schemas. This provides a structural basis for an evolving Knowledge Space while preserving the distinction between a schema, its conceptual representation, its context-relative instantiations, and its executable realizations. In the present paper, the role of the Knowledge Space is deliberately limited. Its graph structure provides a persistent organization in which stabilized schemas and laws can be represented as conceptual objects and made available for later schema applications. The constructions developed here use this organization through lifting, instantiation, and reuse of such objects; they do not depend on a particular graph-search, retrieval, or navigation mechanism. Those mechanisms belong to the solver level of the framework. Thus the Knowledge Space is used here as the representational substrate that allows a derived structure to change status: a schema first appears as an applicable structural mapping, may become stabilized as a schema concept, and may then participate as an input to the construction of further schemas. In schematic form, S⟶cS⟶S′S c_S S denotes this transition from constructed structure to reusable conceptual object and subsequently to a component of further structural construction. Equivalence Let C be a context on a base set C⊆ΩC , i.e. a partition of C into disjoint cells. Once C is fixed, elements ω,ω′∈Cω,ω ∈ C are considered equivalent if they belong to the same context cell: ω∼ω′⟺∃c∈ such that ω,ω′∈c.ω _Cω ∃ c such that ω,ω ∈ c. Equivalence is therefore induced by the representational granularity encoded in the context. Identity corresponds to the degenerate case in which all cells are singletons. Refining or coarsening a context modifies the induced equivalence relation. Order and Comparison An order schema introduces a strict asymmetric relation ≺ defined over context cells or their representatives. Formally, ≺⊆× \; \;C×C is a strict partial or strict total order. Order relations operate on equivalence classes rather than on raw states and enable comparison, precedence, containment, or hierarchy without requiring numerical structure. Successor Given an order ≺ , the successor schema refines it by identifying minimal progression. For a,b∈a,b , define succ≺(a,b)succ_ (a,b) if a≺ba b and there is no c∈c such that a≺c≺b.a c b. The successor relation is defined abstractly and applies to any ordered structure. Temporal order provides a canonical instance, but no commitment to physical or metric time is assumed. Time and successor structure. Successor structure need not be temporal. When a temporal coordinate is available, the successor relation may be interpreted as temporal precedence and thereby supports before–after reasoning. However, the framework does not assume metric, physical, or global time. The same structural role may be played by any ordered progression admitting a successor relation, such as process states, refinement chains, or stages of representation. Structural Dependence Structural dependence describes how the admissible realization of one component of an application frame constrains the admissible realizations of another. It is a structural notion defined from the available objects and constraints. It is distinct from truth-functional implication and does not assume a probabilistic interpretation. Let =(,X,Y,Γ)A=(C,X,Y, _A) be an application frame. Let ℑ I_A denote the set of admissible instantiations of this frame, that is, the instantiations that satisfy the relevant type requirements and the constraints Γ _A. Let A and B be two typed components whose realizations are specified by an instantiation ι∈ℑ ∈ I_A. For an admissible value a of A, define the admissible realizations of B conditional on A=aA=a by Adm(B∣A=a)=b:∃ι∈ℑ such that ι(A)=a and ι(B)=b.Adm_A(B A=a)=\b:∃ ∈ I_A such that (A)=a and (B)=b\. We say that B is structurally dependent on A in the application frame A, and write A↝B,A _AB, if there exist two admissible realizations a1a_1 and a2a_2 of A such that Adm(B∣A=a1)≠Adm(B∣A=a2),Adm_A(B A=a_1) _A(B A=a_2), with both sets nonempty. Thus A↝BA _AB means that changing the admissible realization of A changes the admissible possibilities for B under the constraints represented in A. The dependence is therefore relative to the application frame: changing the context, the available structures, or the relevant constraints may change whether the dependence holds. Structural dependence is directional in the sense that the admissible possibilities for B are compared under different realizations of A. The relation need not, however, be asymmetric. It is possible that A↝BA _AB and B↝AB _AA both hold when the constraints couple the two components in both directions. Structural dependence alone therefore does not specify causal direction. At the schema level, the construction may be summarized as Sdep:(application frame,typed components,constraints)⟶structural dependence.S_dep:(application frame,typed components,constraints) dependence. The resulting dependence relation may subsequently serve as an input or structural prerequisite of higher-level schemas. In particular, when successor structure is also available, structural dependence can be refined by an explicit precedence requirement. This gives the restricted causal schema developed in the next subsection. General and Conditional Implication Implication is defined separately from structural dependence. Let C be a context on C⊆ΩC , and let A and B be predicates on C compatible with the distinctions represented by C. A general implication holds over the complete domain of the context: A⇒BA _CB if ∀ω∈C,A(ω)⟹B(ω).∀ω∈ C, A(ω) B(ω). A conditional implication holds only on a specified subset D⊆CD C. We write A⇒DBA _DB if ∀ω∈D,A(ω)⟹B(ω).∀ω∈ D, A(ω) B(ω). Thus structural dependence, A↝B,A _AB, and implication, A⇒DB,A _DB, are different schemas. Structural dependence concerns how admissible realizations vary under the constraints of an application frame, whereas implication concerns preservation of truth over a specified domain. Structural Causal Precedence We introduce here one restricted causal schema constructed from two previously available structures: structural dependence and successor. It captures a class of causal relations in which a directed dependence is compatible with an explicit predecessor structure. The construction is not intended as an exhaustive definition of causality; rather, it provides one causal schema that can be derived from the structural elements available at this level of the framework. Let =(,X,Y,Γ)A=(C,X,Y, _A) be an application frame. Let A and B be Boolean-valued typed components represented in A whose values are well defined on the cells of C. They therefore induce predicates A,B:→⊤,⊥.A,B:C→\ , \. Assume further that A↝BA _AB holds in the sense of structural dependence defined above, and that C is equipped with a successor relation succsucc. We write c≺succ+dc _succ^+d when d is reachable from c by one or more successor steps. Thus there exist context cells c=c0,c1,…,ck=d,k≥1,c=c_0,c_1,…,c_k=d, k≥ 1, such that succ(ci,ci+1)succ(c_i,c_i+1) for every i<ki<k. For a predicate or event-like pattern A, define its occurrence set by Occ(A)=c∈:A(c)=⊤.Occ_C(A)=\c :A(c)= \. We say that A has structural causal precedence over B in A, and write CP(A,B),CP_A(A,B), when: 1. B occurs in the represented configuration, Occ(B)≠∅;Occ_C(B)≠ ; 2. every occurrence of B has a preceding occurrence of A, ∀d∈Occ(B),∃c∈Occ(A) such that c≺succ+d.∀ d _C(B), ∃ c _C(A) such that c _succ^+d. The first condition supplies directed structural dependence, whereas the second constrains that dependence by successor structure. The resulting relation is directional because predecessor and successor positions are distinguished by the context. At the schema level, the construction has the form Structural Dependence+Successor⟶Structural Causal Precedence.Structural Dependence+Successor Causal Precedence. Equivalently, in terms of schema dependency, Sdep⊲Scp,Ssucc⊲Scp.S_dep S_cp, S_succ S_cp. The present construction therefore defines one restricted causal relation: a structurally dependent pattern must precede the pattern that depends on it along the available successor structure. It does not identify all causal relations with precedence. Rather, the framework permits different causal schemas to be constructed when additional representational structure is available. Later extensions may, for example, introduce interventional or counterfactual causal schemas [35], or causal relations defined for deterministic or stochastic processes. Discrete Succession Discrete succession is obtained by repeated application of the successor relation. A finite succession is a sequence of context cells (c0,c1,…,ck)(c_0,c_1,…,c_k) such that succ(ci,ci+1)succ(c_i,c_i+1) for every i<ki<k. Longer successions are obtained by repeated admissible successor extension. No numerical magnitude is assumed at this stage; only repeated successor structure is required. Number-Like Structure The sequence from order to number-like structure provides a simple example of how derived schemas use the outputs of their predecessors. Let C be a context in which an admissible order relation ≺ is available. The successor schema can then be applied to the ordered structure, (,≺)⟼succ≺,(C, ) _ , where succ≺succ_ identifies minimal progression with respect to ≺ . The resulting successor relation satisfies an input requirement of the discrete-succession schema. Given an initial element c0c_0, this schema produces finite successor chains (c0,c1,…,ck),(c_0,c_1,…,c_k), with succ≺(ci,ci+1)succ_ (c_i,c_i+1) for every i<ki<k. At the next level, the particular elements occurring in such a chain can be suppressed while preserving its finite successor structure. Successions with the same successor structure are treated as equivalent, and the resulting equivalence classes provide number-like objects. Numerical sameness is thereby associated with sameness of finite succession structure rather than with the identity of the elements realizing the succession. The construction can be summarized at the schema level as Sorder⊲Ssucc⊲Sdisc⊲Snum.S_order S_succ S_disc S_num. Each occurrence of ⊲ represents a typed structural dependency: the structure produced at one stage supplies an input or prerequisite required by the next schema. The last step also illustrates abstraction, since the resulting object no longer depends on the particular elements used to realize the succession. If such a number-like schema becomes stable and reusable, it may itself be lifted as a schema concept and become available as an input to further schemas. Thus the construction is not intended as an axiomatization of the natural numbers, but as an example of how progressively higher-level structures can be built and subsequently reused within the Knowledge Space. Higher-Order Structural Correspondence The schemas considered so far construct relations and structures within a context. A further step becomes possible when previously available relations or schema concepts are themselves used to identify a common organization across different configurations. The resulting schema operates not only on individual objects but on relational structures formed from them. Consider two finite collections of typed objects X=a,b,c,d,X′=r,p,s,q.X=\a,b,c,d\, X =\r,p,s,q\. The order in which the elements of these sets are displayed has no structural meaning. Suppose that the first configuration contains a binary relation R with R(a,b),R(a,c),R(b,d),R(c,d),R(a,b), R(a,c), R(b,d), R(c,d), while the second contains a possibly different binary relation R′R with R′(p,q),R′(p,r),R′(q,s),R′(r,s).R (p,q), R (p,r), R (q,s), R (r,s). The two configurations have the same relational organization under the correspondence φ:X→X′ :X→ X defined by φ(a)=p,φ(b)=q,φ(c)=r,φ(d)=s. (a)=p, (b)=q, (c)=r, (d)=s. For the participating pairs, R(x,y)⟺R′(φ(x),φ(y)).R(x,y) R ( (x), (y)). The correspondence is therefore determined by preservation of relational structure rather than by the names or displayed order of the objects. This construction can be stated more generally. Let X and X′X be finite collections of typed objects, and let ℛR and ℛ′R be collections of relations represented in the corresponding application frames. A structural correspondence consists of an object mapping φ:X→X′ :X→ X together with, when the participating relations are not identical, a correspondence ψ:ℛ→ℛ′ψ:R between the relevant relations. For each participating relation R∈ℛR , structural preservation requires R(x1,…,xk)⟺ψ(R)(φ(x1),…,φ(xk))R(x_1,…,x_k) ψ(R) ( (x_1),…, (x_k) ) for the tuples involved in the correspondence. The mappings φ and ψ are subject to the type requirements and structural prerequisites of the application frame; they are not induced by an enumeration of the participating objects or relations. The structural correspondence schema may therefore be represented as Scorr:(typed objects,typed relations)⟶structural correspondence.S_corr:(typed objects,typed relations) correspondence. The construction becomes higher-order when the participating relations or structural patterns are outputs of previously available schemas, or when stabilized schemas have already been lifted as schema concepts. Several such concepts may jointly support the construction of a new higher-order schema, (cS1,cS2,…,cSm)⟶SH.(c_S_1,c_S_2,…,c_S_m) S_H. If the resulting schema becomes stable for reuse, it may itself be lifted, SH→LiftcSH.S_H Liftc_S_H. The correspondence therefore preserves an organization among typed objects and relations without requiring the participating objects or relations to be identical across the two configurations. The constructions above illustrate two forms of schema derivation. Compositional derivation occurs when the output of one schema supplies an input or prerequisite of another, whereas higher-order construction may combine several previously available structures. Table 1 summarizes the principal dependencies developed in this section. Table 1: Structural prerequisites and resulting structures for the principal schemas developed in this section. The rows summarize dependencies and do not represent a single linear sequence of schema construction. Schema Required structure Resulting structure Equivalence Context partition Equivalence relation induced by common cell membership Order Typed objects or context cells together with an admissible comparison relation Ordered relational structure Successor Ordered structure Minimal progression relation Structural dependence Application frame, typed components, admissible instantiations, and local constraints Directed dependence of admissible realizations within the application frame General and conditional implication Predicates together with a specified domain of validity Truth-functional implication over the corresponding domain Structural causal precedence Structural dependence together with successor structure and cell-wise occurrence predicates Restricted causal relation combining structural dependence with predecessor structure Discrete succession Successor relation and an initial object Finite or iterated successor chain Number-like structure Finite successor chains and equivalence under preservation of successor structure Equivalence classes of finite successions and their induced structural organization Higher-order structural correspondence Two typed relational configurations together with compatible objects, relations, or previously derived structures Structure-preserving correspondence and a reusable higher-order structural pattern One compositional dependency chain is Sorder⊲Ssucc⊲Sdisc⊲Snum.S_order S_succ S_disc S_num. Higher-order structural correspondence instead combines several available structures and therefore need not have a single predecessor. The constructions considered so far concern the derivation and application of schemas within contexts or application frames. We next consider when a relation can be reused across different contexts and thereby represented as a stable law. 4 Relations and Laws Relations are structured links defined relative to a context. Let C be a context on a base domain C⊆ΩC . A context-relative binary relation has the form R⊆×,R_C ×C, or equivalently R:×→⊤,⊥.R_C:C×C→\ , \. Such a relation is evaluated with respect to the distinctions represented by C. It may therefore depend on the granularity and organization of that context and, by itself, is not yet a law. A relation defined on the underlying domain may induce a context-relative relation when it is invariant with respect to the context cells. Let q:C→q_C:C be the canonical quotient map. Let R:C×C→⊤,⊥.R:C× C→\ , \. The relation R descends to C if it is constant on the fibers of q×q.q_C× q_C. Explicitly, whenever q(ω1)=q(ω1′)q_C( _1)=q_C(ω _1) and q(ω2)=q(ω2′),q_C( _2)=q_C(ω _2), we require R(ω1,ω2)=R(ω1′,ω2′).R( _1, _2)=R(ω _1,ω _2). Under this condition there exists a unique relation R_C such that R=R∘(q×q).R=R_C (q_C× q_C). Representative selection provides an equivalent realization of this context-relative relation. Let ρ:→Cρ:C→ C satisfy q∘ρ=id.q_C ρ=id_C. Then, for every c1,c2∈c_1,c_2 , R(c1,c2)=R(ρ(c1),ρ(c2)).R_C(c_1,c_2)=R (ρ(c_1),ρ(c_2) ). Because R is constant on context cells, this value is independent of the particular representative selection ρ. Representative independence is therefore a well-definedness condition for a context-relative realization, rather than a transformation between contexts. We next consider relations across different contexts. Let ′C be a context on C′C and C a context on C. A transformation p:C′→Cp:C → C is compatible with the contexts if it induces a map π:′→π:C such that q∘p=π∘q′.q_C p=π q_C . Thus objects that are indistinguishable in ′C are mapped to objects that remain indistinguishable in C. Only transformations satisfying this compatibility condition are treated here as admissible context transformations. Given a relation R_C on C, its pullback along π is the relation on ′C defined by (π∗R)(c1′,c2′)=R(π(c1′),π(c2′)).(π^*R_C)(c _1,c _2)=R_C (π(c _1),π(c _2) ). For a refinement, ′C is finer than C and π is the canonical map sending each finer cell to the coarser cell containing it. The pullback therefore gives a canonical realization of a coarser relation on the finer context. The converse direction requires an additional condition. A relation R′R_C on the finer context descends to C only if it is constant on the fibers of π×π.π×π. Thus, whenever π(c1′)=π(d1′)π(c _1)=π(d _1) and π(c2′)=π(d2′),π(c _2)=π(d _2), we require R′(c1′,c2′)=R′(d1′,d2′).R_C (c _1,c _2)=R_C (d _1,d _2). When this condition holds, there exists a unique relation R_C satisfying R′=π∗R.R_C =π^*R_C. Hence refinement naturally supports pullback, whereas coarsening requires descent. A projection between represented domains is admissible only when it induces a well-defined map between the corresponding context cells as specified above. Let ℭ C be a family of compatible contexts together with their admissible context transformations. A law L over ℭ C is a family of context-relative realizations L=(RL)∈ℭL= (R^L_C )_C∈ C such that, for every admissible map π:′→,π:C , the realizations satisfy R′L=π∗RL.R^L_C =π^*R^L_C. The same compatibility equation has two complementary interpretations. From a coarser context to a finer one, it specifies pullback. From a finer context to a coarser one, it can hold only when the finer realization satisfies the required descent condition. The compatibility condition is itself stable under composition. Suppose ′→′→C σC πC are admissible context transformations and R′L=π∗RL,R′L=σ∗R′L.R^L_C =π^*R^L_C, R^L_C =σ^*R^L_C . Then R′L=σ∗(π∗RL)=(π∘σ)∗RL.R^L_C =σ^* (π^*R^L_C )=(π σ)^*R^L_C. Thus the realization of a law does not depend on whether a compatible change of context is performed directly or through intermediate admissible contexts. A law is therefore not identified with any single relation RLR^L_C. It is the stable relational structure represented by the compatible family of its context-relative realizations. The family ℭ C specifies its domain of applicability. When such a law is sufficiently stable for reuse, it may be lifted into the Concept Graph as a conceptual object. Its context-relative relations remain realizations of that law rather than independent lifted relations. A lifted law with explicitly relational content may be represented as a relation concept. 5 Tasks, Contexts, and Schema Applicability Before problem solving can take place, a task must be represented in a context in which its unknowns, admissible distinctions, and constraints can be stated. A task is therefore specified relative to a context rather than identified with an algorithmic objective, loss function, or input sentence. Let C be a finite context. A task is represented by T=(C,G,U,Γ),T=(C,G,U, ), where G contains the given elements or facts, U the unknowns to be instantiated, and Γ the constraints on admissible instantiations. The external presentation of a task may be verbal, symbolic, diagrammatic, data-based, or already formal. Here we assume that this presentation has been converted into T. The questions considered below are then which distinctions and schemas are available in C, and whether the unknowns can be instantiated consistently with Γ . 5.1 Illustrative Examples The following examples illustrate the consequences of applying an appropriate representational transformation once the relevant invariance, dependency, or structural requirement is available. They do not address how such a transformation is discovered. In some cases the external task semantics indicates the relevant invariance without prescribing its representational realization; in others, it specifies that a relevant structure exists without identifying it completely. The general claims concerning schema applicability, structural dependency, and cross-context stability follow from the formal constructions developed above rather than from these examples. Example 1: Permutation-Invariant Structure External task statement. Given a finite sequence of symbols, determine whether the sequence contains at least two identical elements. The order of symbols is irrelevant to the answer. Task specification. Let C1C_1 be the domain of finite sequences x=(x1,…,xn)x=(x_1,…,x_n) over a finite alphabet. Let 1C_1 be the discrete context on C1C_1, so that each sequence is initially represented by a distinct context cell. The task 1=(1,G1,U1,Γ1)T_1=(C_1,G_1,U_1, _1) is defined by: • • Context 1C_1: the discrete context on C1C_1, in which every sequence is represented by a distinct context cell and the sequence representation retains positional order and symbol identity. • Given elements G1G_1: a finite set of labeled examples (x(i),y(i)),\(x^(i),y^(i))\, where x(i)∈C1x^(i)∈ C_1 and y(i)∈0,1y^(i)∈\0,1\. • Unknown U1U_1: a function f:C1→0,1.f:C_1→\0,1\. • Constraints Γ1 _1: consistency with the given examples and invariance under permutations of sequence positions. In the raw context 1C_1, two distinct sequences are represented by distinct singleton cells, even when they differ only by a permutation of positions. Define an equivalence relation on C1C_1 by x∼permx′x _permx if x′x can be obtained from x by a permutation of positions. The corresponding quotient context 1perm=C1/∼permC_1^perm=C_1/ _perm groups permutation-equivalent sequences into the same context cell and therefore suppresses order distinctions that are irrelevant to the task. Let qperm:C1→1permq_perm:C_1 _1^perm denote the canonical quotient map. Permutation invariance means that f is constant on the cells of 1permC_1^perm. Hence there exists a unique function f¯:1perm→0,1 f:C_1^perm→\0,1\ such that f=f¯∘qperm.f= f q_perm. Data-based variant. The same task may be given through labeled observations such as G1=((a,b,c),0),((a,b,a),1),((d,e,f),0).G_1=\((a,b,c),0),((a,b,a),1),((d,e,f),0)\. These observations constrain f only on the displayed sequences. The additional condition in Γ1 _1 specifies permutation invariance, so after passing to 1permC_1^perm the task is represented by f¯:1perm→0,1, f:C_1^perm→\0,1\, which depends only on the permutation class. In this example, the relevant class property is whether some symbol occurs at least twice. Example 2: Abstraction and Generalization by Removing Irrelevant Coordinates External task statement. Given a binary vector of fixed length, determine an output bit that depends only on a small, unknown subset of input coordinates. All remaining coordinates are irrelevant to the correct answer. Task specification. The task 2=(2,G2,U2,Γ2)T_2=(C_2,G_2,U_2, _2) is defined by: • Context 2C_2: binary vectors x=(x1,…,xd)∈0,1d,x=(x_1,…,x_d)∈\0,1\^d, with all coordinates treated symmetrically. • Given elements G2G_2: labeled examples (x(i),y(i))\(x^(i),y^(i))\. • Unknown U2U_2: a function f:2→0,1.f:C_2→\0,1\. • Constraints Γ2 _2: consistency with the given labels. Within the raw context 2C_2, all coordinates are equally represented, so the representation does not identify which coordinates may be ignored without affecting the output. The task states that a relevant subset exists but does not specify its members; discovering that subset is outside the present example. Once the relevant coordinates have been identified, projection suppresses distinctions associated with the remaining coordinates. In the reduced context, admissible laws can be expressed using only the relevant coordinates and may therefore have simpler representations. This realizes abstraction by removing task-irrelevant distinctions and supports generalization when the same reduced description applies across related task instances. Example 3: Relational Composition under Contextual Constraints External task statement. Given three objects A,B,CA,B,C and the statements “B is next to A” and “C is next to B”, determine whether “A is next to C” holds. The task refers to objects and a binary relation next to. No metric distance, global geometry, or transitivity assumptions are specified. The meaning of next to is restricted to the task context. Task specification. The task 3=(3,G3,U3,Γ3)T_3=(C_3,G_3,U_3, _3) is specified as follows. The context consists of finite configurations of objects equipped with a binary relation Next(⋅,⋅)Next(·,·). The context distinguishes adjacency relations but does not encode distance, order, or spatial embedding. The given elements are the relational facts Next(B,A),Next(C,B).Next(B,A), (C,B). The unknown is the truth value of the relation Next(A,C).Next(A,C). Constraints Γ3 _3. No constraints beyond consistency with the given relations are imposed. In particular, no assumptions about transitivity or symmetry of NextNext are included in the task specification. Within the given context, adjacency is treated as a local relation. The task context does not determine whether adjacency is transitive or symmetric, and therefore does not uniquely determine the value of Next(A,C).Next(A,C). The original task is consequently underdetermined. Introducing relation composition or path structure does not by itself resolve this adjacency question. Such an extension may instead define a different relation, for example indirect connectivity or reachability, whose truth conditions are not the same as those of NextNext. A reformulated task could instead ask whether A and C are connected through intermediate objects. Such a question may become decidable once an appropriate path or composition schema is available, but the conclusion then concerns a new relation rather than the original adjacency predicate. Consequently, adding constraints may resolve underdetermination of Next(A,C)Next(A,C), whereas introducing a new relational schema constitutes a reformulation of the task. 5.2 Solution preservation under representational reduction. Let ′=(′,G′,U′,Γ′)T =(C ,G ,U , ) be a task represented in a context ′C , and let π:′→π:C be a surjective admissible context transformation that suppresses distinctions not required by the task. Let ∼π _π denote the corresponding equivalence on admissible assignments: two assignments are equivalent when they differ only in distinctions identified by π. Assume that satisfaction of the task constraints is invariant under this equivalence, so that u1′∼πu2′⟹(u1′⊧′Γ′⟺u2′⊧′Γ′).u _1 _πu _2 (u _1 _C u _2 _C ). The constraints therefore induce a well-defined task =(,G,U,Γ)T=(C,G,U, ) on the quotient representation. Proposition 1. Under the conditions above, the solutions of the reduced task are in one-to-one correspondence with the equivalence classes of solutions of the original task: Sol()≅Sol(′)/∼π.Sol(T) (T )/ _π. Proof. Constraint invariance implies that either every assignment in a ∼π _π-class satisfies Γ′ or none does. Satisfaction therefore depends only on the equivalence class. Each solution class of ′T consequently determines exactly one solution of the quotient task T, and every solution of T is obtained from such a class. ∎ Two consequences are immediate. First, a task with no admissible solution cannot acquire one merely by suppressing distinctions in a solution-preserving representation. Second, several solutions that differ only in distinctions suppressed by π become a single solution in the reduced context, whereas solutions belonging to different ∼π _π-classes remain distinct. Representational reduction can therefore remove apparent underdetermination caused solely by irrelevant distinctions without changing the task-relevant solution structure. 6 Ill-Posedness of Tasks The task representation makes it possible to distinguish different forms of ill-posedness at the level of task formulation. Internal inconsistency and underdetermination are properties of the formalized task, whereas contextual insufficiency additionally concerns the adequacy of that representation relative to the external task meaning. Type I: Internal inconsistency. A task is internally inconsistent if no admissible instantiation of the unknowns satisfies the constraints in the given context. Formally, there is no assignment u∈Uu∈ U such that u⊧CΓ.u _C . Inconsistency may arise from contradictory constraints, incompatible givens, or a mismatch between the assumed schema and the available context. Type I: Underdetermination. A task is underdetermined if several mutually incompatible instantiations of the unknowns satisfy the constraints in the same context. Thus there exist distinct admissible assignments u1,u2∈Uu_1,u_2∈ U such that u1⊧CΓ,u2⊧CΓ,u_1 _C , u_2 _C , while u1u_1 and u2u_2 are not equivalent with respect to the distinctions relevant to the task. Resolving underdetermination requires additional constraints, additional data, a more specific context, or an evaluation criterion. Type I: Contextual insufficiency. A task representation is contextually insufficient when the external task semantics requires distinctions, relations, schemas, or laws that cannot be expressed in the current context C. In this case, the external task may be meaningful, but its current formal representation =(,G,U,Γ)T=(C,G,U, ) does not contain the representational structure required to formulate the intended question or its admissible solution adequately. Examples include tasks that require metric distance when only adjacency is represented, transitivity when only a local relation is available, or temporal order when no successor structure is represented. Unlike inconsistency and underdetermination, contextual insufficiency is not diagnosed from the formal task tuple alone. It is identified relative to the external task meaning from which the formal representation was constructed. A more explicit treatment in terms of richer reference contexts and representational projections can be introduced in later work. Resolving contextual insufficiency requires a change of representation, for example by refinement, coarsening, projection, extension, or reformulation, depending on the missing structure. Granularity mismatch, scope ambiguity, and schema mismatch can be treated as refinements of the three cases above. Internal inconsistency and underdetermination can be diagnosed from the formal task representation, whereas contextual insufficiency additionally requires comparison with the external task semantics. Once both the task representation and its relation to the external task meaning are explicit, these mismatches can be classified as inconsistency, underdetermination, or contextual insufficiency. The classification identifies whether failure lies in the constraints Γ , in the available unknowns U, in schema applicability, or in the expressive capacity of the context C. Objects Lifted into the Concept Graph The lifting criterion is stability across contexts. Concepts, schema concepts, laws, and recurring diagnostic structures may be represented as nodes in the Concept Graph when they remain stable across an appropriate family of contexts. Context-specific realizations, including particular relations, equivalences, and concept instantiations, remain local and are linked to the corresponding stable objects rather than lifted independently. Families of compatible contexts may themselves provide reusable domains of applicability for laws and schemas. Procedures and algorithmic primitives are represented separately in the Procedure Graph and linked to Concept Graph objects through typing and applicability relations. 7 Discussion The results above place task formulation and schema applicability at the same representational level. A context fixes which distinctions are available, while the task specification determines which of these distinctions and relations are required by the givens, unknowns, and constraints. Problem solving therefore depends not only on the available procedures, but also on what can be expressed in the current context. This distinction clarifies several different sources of difficulty. Inconsistency arises when no admissible instantiation satisfies the constraints, underdetermination when several non-equivalent instantiations remain admissible, and contextual insufficiency when the distinctions or relations required by the intended solution are absent from the context. The examples exhibit these cases in elementary form: quotienting removes irrelevant order information, projection suppresses irrelevant coordinates, and insufficient relational structure leaves a query unresolved. A change of representation can therefore alter the admissible solution space without changing the task data themselves. The distinction between relations and laws extends the same idea across contexts. A relation may depend on the granularity and organization of a particular context. A law has compatible realizations across a family of contexts under admissible transformations such as refinement, coarsening, projection, or representative selection. This stability allows a law to be represented as a reusable object in the Concept Graph, while its context-relative realizations remain tied to particular tasks or contexts. The schema hierarchy, task–schema interface, and distinction between relations and laws together define a structural layer for problem solving. Within this layer, quotienting, projection, context transformation, and schema applicability can be analyzed independently of the particular mechanism used to discover or select them. This separation also provides a basis for later solver architectures in which proposal generation, verification, and persistent knowledge can be implemented by different components. 8 Conclusion This paper developed a hierarchy of cognitive schemas for knowledge-based problem solving. Equivalence, order, successor, dependence, implication, discrete succession, and number-like structure are derived from contexts, relations, representative objects, and admissible transformations rather than introduced as independent primitives. Task specification connects these schemas to problem formulation. A task context determines which distinctions and relations are available for instantiating the unknowns under the stated constraints. This also separates three forms of ill-posedness: inconsistency, underdetermination, and contextual insufficiency. In the last case, the required distinctions or relations are absent from the current context, so the representation must be changed before a solution can be expressed. Relations and laws are separated in the same way across contexts. Relations may be specific to a particular context, whereas laws have compatible realizations across a family of contexts under admissible transformations. Such stable structures can be reused and represented in the Concept Graph. A broader research direction is to investigate how this explicit structural layer can interact with language-model architectures. Two complementary possibilities are of particular interest: building problem-solving capabilities from an initially untrained or minimally pretrained model whose persistent knowledge is organized through the explicit Knowledge Space, and coupling the framework to a pretrained LLM that provides rich natural-language interpretation and candidate proposals while explicit representation, verification, and knowledge stabilization remain outside the model. In both cases, the objective is to separate proposal generation from verified persistent knowledge and controlled structural learning. These directions provide a route for extending the present representational framework toward solver architectures that combine flexible proposal generation with explicit verification and persistent structural learning. 9 Declarations 9.1 Availability of Data and Material Data availability statement: not applicable. 9.2 Competing Interests The authors declare that they have no competing interests. 9.3 Funding No funding was received for this work. 9.4 Authors’ Contributions The authors contributed equally to all aspects of the work. 9.5 Acknowledgements The authors have no acknowledgements to declare. References [1] A. Jakovác and A. Telcs (2025) Representation and abstraction. Mathematics 13 (10), p. 1666. Cited by: §1. [2] A. Jakovác and A. Telcs (2026) A structural theory of cognitive representation and problem solving: contexts, invariance, and the knowledge space. Note: Manuscript Cited by: §1. [3] F. C. Bartlett (1932) Remembering: a study in experimental and social psychology. Cambridge University Press, Cambridge. Cited by: §2. [4] D. E. Rumelhart (1980) Schemata: the building blocks of cognition. In Theoretical Issues in Reading Comprehension: Perspectives from Cognitive Psychology, Linguistics, Artificial Intelligence, and Education, R. J. Spiro, B. C. Bruce, and W. F. Brewer (Eds.), p. 33–58. Cited by: §2. [5] M. Minsky (1975) A framework for representing knowledge. In The Psychology of Computer Vision, P. H. Winston (Ed.), p. 211–277. Cited by: §2. [6] R. C. Schank and R. P. Abelson (1977) Scripts, plans, goals, and understanding: an inquiry into human knowledge structures. Lawrence Erlbaum Associates, Hillsdale, NJ. Cited by: §2. [7] A. Newell and H. A. Simon (1972) Human problem solving. Prentice-Hall, Englewood Cliffs, NJ. Cited by: §2. [8] J. R. Anderson, D. Bothell, M. D. Byrne, S. Douglass, C. Lebiere, and Y. Qin (2004) An integrated theory of the mind. Psychological Review 111 (4), p. 1036–1060. External Links: Document Cited by: §2. [9] J. E. Laird, A. Newell, and P. S. Rosenbloom (1987) SOAR: an architecture for general intelligence. Artificial Intelligence 33 (1), p. 1–64. External Links: Document Cited by: §2. [10] Z. Pawlak (1982) Rough sets. International Journal of Computer and Information Sciences 11 (5), p. 341–356. External Links: Document Cited by: §2. [11] Z. Pawlak (1991) Rough sets: theoretical aspects of reasoning about data. Theory and Decision Library D, Vol. 9, Kluwer Academic Publishers, Dordrecht. External Links: Document Cited by: §2. [12] A. Skowron and C. Rauszer (1992) The discernibility matrices and functions in information systems. In Intelligent Decision Support: Handbook of Applications and Advances of the Rough Sets Theory, R. Słowiński (Ed.), p. 331–362. External Links: Document Cited by: §2. [13] R. Wille (1982) Restructuring lattice theory: an approach based on hierarchies of concepts. In Ordered Sets, I. Rival (Ed.), p. 445–470. Cited by: §2. [14] B. Ganter and R. Wille (1999) Formal concept analysis: mathematical foundations. Springer, Berlin. External Links: Document Cited by: §2. [15] B. Ganter and S. O. Kuznetsov (2001) Pattern structures and their projections. In Conceptual Structures: Broadening the Base, Lecture Notes in Computer Science, Vol. 2120, Berlin, p. 129–142. External Links: Document Cited by: §2. [16] Y. Yao (2008) A unified framework of granular computing. In Handbook of Granular Computing, W. Pedrycz, A. Skowron, and V. Kreinovich (Eds.), External Links: Document Cited by: §2. [17] J. F. Sowa (1984) Conceptual structures: information processing in mind and machine. Addison-Wesley, Reading, MA. Cited by: §2. [18] F. Baader, D. Calvanese, D. L. McGuinness, D. Nardi, and P. F. Patel-Schneider (Eds.) (2003) The description logic handbook: theory, implementation, and applications. Cambridge University Press, Cambridge. Cited by: §2. [19] D. Gentner (1983) Structure-mapping: a theoretical framework for analogy. Cognitive Science 7 (2), p. 155–170. External Links: Document Cited by: §2. [20] K. J. Holyoak and P. Thagard (1989) Analogical mapping by constraint satisfaction. Cognitive Science 13 (3), p. 295–355. External Links: Document Cited by: §2. [21] P. Gärdenfors (2000) Conceptual spaces: the geometry of thought. MIT Press, Cambridge, MA. Cited by: §2. [22] S. Phillips and W. H. Wilson (2010) Categorial compositionality: a category theory explanation for the systematicity of human cognition. PLOS Computational Biology 6 (7), p. e1000858. External Links: Document Cited by: §2. [23] S. Muggleton (1991) Inductive logic programming. New Generation Computing 8 (4), p. 295–318. External Links: Document Cited by: §2. [24] A. Cropper, S. Dumančić, R. Evans, and S. H. Muggleton (2022) Inductive logic programming at 30. Machine Learning 111 (1), p. 147–172. External Links: Document Cited by: §2. [25] K. Ellis, L. Wong, M. Nye, M. Sable-Meyer, L. Cary, L. Anaya Pozo, L. Hewitt, A. Solar-Lezama, and J. B. Tenenbaum (2023) Dreamcoder: growing generalizable, interpretable knowledge with wake–sleep bayesian program learning. Philosophical Transactions of the Royal Society A 381 (2251), p. 20220050. Cited by: §2. [26] B. M. Lake, T. D. Ullman, J. B. Tenenbaum, and S. J. Gershman (2017) Building machines that learn and think like people. MIT Press. Cited by: §2. [27] J. Andreas, D. Klein, and S. Levine (2017) Modular multitask learning with policy sketches. In International Conference on Machine Learning, Cited by: §2. [28] P. W. Battaglia, J. B. Hamrick, V. Bapst, et al. (2018) Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261. Cited by: §2. [29] K. Xu, W. Hu, J. Leskovec, and S. Jegelka (2019) How powerful are graph neural networks?. International Conference on Learning Representations. Cited by: §2. [30] Z. Sun, Z. Deng, J. Nie, and J. Tang (2019) RotatE: knowledge graph embedding by relational rotation in complex space. International Conference on Learning Representations. Cited by: §2. [31] T. Cohen and M. Welling (2016) Group equivariant convolutional networks. In Proceedings of the International Conference on Machine Learning, Cited by: §2. [32] M. Arjovsky, L. Bottou, I. Gulrajani, and D. Lopez-Paz (2019) Invariant risk minimization. arXiv preprint arXiv:1907.02893. Cited by: §2. [33] S. Gulwani, O. Polozov, and R. Singh (2017) Program synthesis. Foundations and Trends in Programming Languages 4 (1–2), p. 1–119. Cited by: §2. [34] I. H. Sørensen et al. (2008) Specification of software systems. Springer. Cited by: §2. [35] J. Pearl (2009) Causality: models, reasoning, and inference. Cambridge University Press. Cited by: §2, §3. [36] R. Geirhos, J. Jacobsen, C. Michaelis, R. Zemel, W. Brendel, M. Bethge, and F. A. Wichmann (2020) Shortcut learning in deep neural networks. Nature Machine Intelligence 2, p. 665–673. Cited by: §2. [37] L. Schmidt, S. Santurkar, D. Tsipras, K. Talwar, and A. Madry (2021) Characterizing out-of-distribution generalization with synthetic tasks. NeurIPS. Cited by: §2. [38] Q. He, W. Wang, and H. Wang (2026) Introduction to the special issue on integrating large language models and knowledge graphs for generative ai. ACM Transactions on Intelligent Systems and Technology 17 (6). External Links: Document Cited by: §2. [39] M. Bombieri, P. Fiorini, S. P. Ponzetto, and M. Rospocher (2026) Do LLMs dream of ontologies?. ACM Transactions on Intelligent Systems and Technology 17 (6). External Links: Document Cited by: §2. [40] H. Zhang, T. Wang, Z. Wang, N. Lin, C. Chen, and L. Cheng (2026) A GPT-assisted multi-granularity contrastive learning approach for knowledge graph entity typing. ACM Transactions on Intelligent Systems and Technology 17 (6). External Links: Document Cited by: §2. [41] S. Mishra, U. Sudev, and T. Chakraborty (2026) FLAME: self-supervised low-resource taxonomy expansion using large language models. ACM Transactions on Intelligent Systems and Technology 17 (6). External Links: Document Cited by: §2. [42] A. Meloni, D. Reforgiato Recupero, F. Osborne, A. Salatino, E. Motta, S. Vahdati, and J. Lehmann (2026) Exploring large language models for scientific question answering via natural language to SPARQL translation. ACM Transactions on Intelligent Systems and Technology 17 (6). External Links: Document Cited by: §2. [43] W. Zhang, G. Dai, D. Luo, Y. Wang, and C. Ye (2026) From hallucination to certainty: meta-knowledge guided self-correcting large language models. ACM Transactions on Intelligent Systems and Technology 17 (6). External Links: Document Cited by: §2.