Paper deep dive
Learning to Access Computation: Accessibility Plasticity as a Principle of Adaptive Intelligence
Zhaowen Fan
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 7/28/2026, 3:47:45 AM
Summary
The paper introduces 'Accessibility Plasticity' as a distinct principle of adaptive intelligence, separating computational capability (what computation exists) from computational accessibility (which computations can interact). It proposes a 'reuse-first' hierarchy where systems adapt by reorganizing relationships between existing computations before modifying parameters or structure. Formalized via an adaptive computational substrate graph, the approach aims to reduce catastrophic forgetting and adaptation costs in dynamic environments by treating accessibility as a first-class adaptive variable.
Entities (7)
Relation Signals (5)
Accessibility Plasticity → separates → Computational Capability
confidence 95% · This work introduces Accessibility Plasticity... generally do not distinguish computational capability from computational accessibility as separate adaptive variables.
Reuse-First Hierarchy → orders → Adaptive Degrees of Freedom
confidence 93% · The hierarchy can be summarized as: R << Delta A << Delta W << Delta(D,G) where R denotes pure computational reuse... Delta A denotes changes in computational accessibility...
Accessibility Plasticity → precedes → Capability Plasticity
confidence 92% · establish a reuse-first hierarchy of adaptation, where accessibility modification precedes more costly capability and structural changes.
Relationship State → determines → Accessibility
confidence 90% · The adaptive computational object associated with that potential relationship is the relationship state... The resulting accessibility does not represent a message weight. Instead, it defines whether and to what degree the computational relationship becomes available...
Adaptive Computational Substrate → implements → Accessibility Plasticity
confidence 88% · We formalize Accessibility Plasticity through a relationship-based operational realization... The adaptive computational substrate is the formal object used here to represent this idea.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Modern neural networks primarily adapt through parameter modification within predefined computational structures. While recent methods introduce modularity, conditional computation, and parameter-efficient adaptation, they generally do not distinguish computational capability from computational accessibility as separate adaptive variables. This work introduces Accessibility Plasticity, a principle of adaptive computation in which systems adapt not only by changing what computation exists, but also by reorganizing which existing computations can interact and participate. We formalize Accessibility Plasticity through a relationship-based operational realization and establish a reuse-first hierarchy of adaptation, where accessibility modification precedes more costly capability and structural changes. A proof-of-concept evaluation on sequential learning tasks shows that accessibility adaptation can reduce capability modification while maintaining comparable task performance. These results suggest accessibility as a distinct adaptive dimension and provide a foundation for future dynamic neural systems whose computational relationships evolve with changing environments.
Tags
Links
- Source: https://arxiv.org/abs/2607.22748v1
- Canonical: https://arxiv.org/abs/2607.22748v1
Trouble viewing inline? Open PDF directly →
Full Text
49,993 characters extracted from source content.
Expand or collapse full text
Learning to Access Computation: Accessibility Plasticity as a Principle of Adaptive Intelligence Zhaowen Fan Department of Computer Science, Sichuan University, Email: iamsuperfan@stu.scu.edu.cn Abstract Modern neural networks primarily adapt through parameter modification within predefined computational structures. While recent methods introduce modularity, conditional computation, and parameter-efficient adaptation, they generally do not distinguish computational capability from computational accessibility as separate adaptive variables. This work introduces Accessibility Plasticity, a principle of adaptive computation in which systems adapt not only by changing what computation exists, but also by reorganizing which existing computations can interact and participate. We formalize Accessibility Plasticity through a relationship-based operational realization and establish a reuse-first hierarchy of adaptation, where accessibility modification precedes more costly capability and structural changes. A proof-of-concept evaluation on sequential learning tasks shows that accessibility adaptation can reduce capability modification while maintaining comparable task performance. These results suggest accessibility as a distinct adaptive dimension and provide a foundation for future dynamic neural systems whose computational relationships evolve with changing environments. Keywords Accessibility Plasticity; adaptive computation; continual learning; neural plasticity; conditional computation; dynamic neural systems 1 Introduction Most contemporary artificial neural systems are optimized under a parameter-centric learning paradigm: a computational architecture is specified before deployment, and adaptation is primarily achieved by modifying numerical parameters within that fixed computational organization [13]. This paradigm has enabled remarkable progress in large-scale perception, language modeling, and decision-making, with modern foundation models achieving unprecedented capabilities through large-scale pretraining and parameter optimization [22, 5, 16, 4]. However, when deployed in dynamic environments with continuously evolving data distributions, tasks, and operational conditions, parameter-centric adaptation remains costly and prone to catastrophic forgetting, limiting the ability to preserve and efficiently reuse previously acquired capabilities [17]. Recent advances have explored alternatives by introducing modularity, [18] conditional computation [3], and parameter-efficient adaptation [6]. Residual architectures such as ResNet [8] demonstrate the value of preserving existing computational pathways, while graph neural networks [12, 2] highlight the role of relationships among computational units in information propagation. Adapters [10] and low-rank adaptation [11] reduce modification cost by restricting parameter updates, whereas mixture-of-experts [21], attention mechanisms [22], and routing strategies [20] dynamically regulate information flow and component selection. Nevertheless, these approaches are generally developed as architecture-specific mechanisms rather than as a unified adaptive principle. They manipulate connectivity, parameter subsets, expert selection, or information routing, but do not explicitly distinguish computational capability from computational accessibility or treat the evolving relationships among computations as a first-class adaptive object. Biological intelligence suggests that such a separation may be fundamental. [7] Organisms rarely respond to environmental changes by immediately reconstructing their entire computational machinery; instead, adaptation occurs across multiple timescales [19]. Existing pathways are reused whenever possible [1], functional relationships and activity patterns are reorganized, synaptic strengths are modified [14], and only over longer timescales does large-scale structural reorganization occur [9]. This ordering suggests that efficient adaptation may depend not only on learning new computations, but also on dynamically controlling access to existing computational resources [15], motivating the concept of Accessibility Plasticity introduced in this work. This paper investigates the following question: Can artificial systems adapt more efficiently by modifying how existing computation is accessed before modifying what computation exists? We introduce Accessibility Plasticity as a distinct adaptive degree of freedom that separates computational capability from computational accessibility: the former describes what transformations a system can perform, while the latter describes which computational components can interact during adaptation. Under this perspective, learning is not only a process of changing computational operators, but also a process of reorganizing relationships among existing computations. We formalize this principle through a relationship-based computational system in which capability and accessibility evolve as separate states. The proposed reuse-first principle prioritizes accessibility adaptation before more costly capability or structural modifications. We show through a proof-of-concept evaluation that accessibility adaptation can reduce capability modification while maintaining comparable task performance in sequential learning scenarios. The operational mechanism studied in this work is one realization of Accessibility Plasticity, providing a foundation for future adaptive systems in which computational relationships evolve continuously with changing environments. 2 Conceptual Framework 2.1 Capability, Accessibility, and Scope Standard feedforward descriptions of neural computation can be summarized as Architecture→Parameters→Computation.Architecture . In that view, the architecture determines which transformations may interact, while the learned parameters determine the specific behavior realized along those fixed routes. The proposed perspective introduces an additional dimension. Architecture does not fully determine realized computation; it provides only potential computation. Accessible computation depends on the relationships that determine whether existing capabilities can interact under current conditions. The adaptive computational substrate is the formal object used here to represent this idea. It is not the claim itself. The claim is that accessibility should be treated as a distinct computational object, alongside capability, and that its adaptation can precede modification of computational capability. At the most compact level, the manuscript distinguishes two fundamental computational objects: W W determines what computation exists, determines what computation is accessible. The theory concerns the second object without reducing it to the first. This manuscript does not claim to provide a complete theory of intelligence. It proposes a missing adaptive degree of freedom: the ability of a computational system to modify accessibility independently from capability. The purpose of the paper is therefore to isolate and formalize that degree of freedom, not to claim that all adaptation reduces to this single mechanism. 2.2 Reuse Before Modification The conceptual principle is: An intelligent adaptive system should exhaust cheaper and more reversible forms of modification before invoking more expensive and more persistent ones. This principle changes the optimization target. Traditional optimization primarily focuses on maximizing task performance. The proposed paradigm instead seeks performance-efficient adaptation: maxP()⋅R()Cadapt \; P(T)· R(S)C_adapt (1) where P()P(T) denotes task performance, R()R(S) denotes computational reuse of the substrate, and CadaptC_adapt denotes the cost of changing the system. The shift is conceptual as well as technical: intelligence is not only the ability to achieve a goal, but the ability to achieve goals by efficiently reusing existing computational resources. This formulation is particularly relevant to continual learning, where repeated parameter overwriting can become a liability. 2.3 Accessibility Plasticity versus Selection Selection answers which already accessible path should be used now. Accessibility plasticity answers how the future structure of accessible computation should change through experience. The first is an inference-time choice inside a given accessibility state; the second is a learning-time modification of that accessibility state itself. This distinction matters because a selection mechanism can choose among already available possibilities without changing the substrate that makes those possibilities available. Accessibility plasticity instead changes the accessibility landscape so that future computations are shaped by past experience. Thus accessibility is not only a parameter to be optimized at a single endpoint. It can be treated as a dynamically evolving computational state whose trajectory reflects interaction with a changing environment. 3 Formalization 3.1 Adaptive Computational Substrate We represent the substrate as an undirected graph G=(V,E).G=(V,E). (2) Each node vi∈Vv_i∈ V is a computational unit vi=Wi,v_i=W_i, (3) where WiW_i denotes the local transition operator and no persistent node state is stored inside the vertex itself. For a transient input signal xitx_i^t, the node computes x~it=Wixit, x_i^\,t=W_ix_i^t, (4) so the node contributes only its transition matrix and does not introduce an additional nonlinear transformation at this stage. Each undirected relation index eij=eji∈Ee_ij=e_ji∈ E marks a potential computational relationship. The adaptive computational object associated with that potential relationship is the relationship state: Rij=(ℱij,dij),R_ij=(F_ij,d_ij), (5) where ℱijF_ij is a learned compatibility function and dij≥0d_ij≥ 0 denotes computational resistance. Given an information flow, the relationship state evaluates the compatibility of the interaction and modifies the future accessibility of this computational relationship. The evolving relationship state already encodes the history of previous interactions, so no separate relation-memory variable is required. 3.2 Relationship State and Accessibility Computation in an adaptive computational substrate is not determined solely by the existence of computational units or by fixed connections between them. Instead, relationships between computational units define an adaptive accessibility structure that determines which transformations can participate in the current computation. Crucially, accessibility is not identical to the relation set E. The set E specifies potential relationships in the substrate, whereas accessibility specifies which relationships become computationally available under the current adaptive state. Relationship states are therefore one realization of accessibility, not accessibility itself. For a potential relationship between computational units i and j, the relationship state evaluates an interaction tendency: sijt=ℱij(xit,xjt),s_ij^t=F_ij(x_i^t,x_j^t), (6) where ℱijF_ij represents a discrimination mechanism that evaluates whether interaction between the two computational capabilities is computationally meaningful. The tendency is modulated by a resistance term: zijt=sijt−βdij,z_ij^t=s_ij^t-β d_ij, (7) where dij≥0d_ij≥ 0 represents the intrinsic difficulty of establishing the relationship and β controls the influence of resistance. The accessibility of the relationship is then determined by aijt=g(zijt),a_ij^t=g(z_ij^t), (8) where g(⋅)g(·) maps the evaluated tendency into an accessibility state. The resulting accessibility does not represent a message weight. Instead, it defines whether and to what degree the computational relationship becomes available within the current substrate configuration. The effective computational substrate at time t is therefore induced by the set of accessible relationships: Et∗=(i,j)∈E∣aijt>θ,E_t^*=\(i,j)∈ E a_ij^t>θ\, (9) which forms a dynamically accessible substrate: Gt=(V,Et∗).G_t=(V,E_t^*). (10) Multiple adaptive relationships may become simultaneously accessible, producing concurrent computational pathways within the induced substrate GtG_t. Accordingly, the system does not rely on a single predetermined execution trajectory. Instead, computation emerges from the collective configuration of active relationships. The central distinction is that relationships are not passive communication channels. Their states are adaptive computational structures that evaluate, enable, suppress, and reshape future accessibility between existing capabilities. At the principle level, accessibility evolves according to an abstract update operator: t+1=A(t,t).A_t+1=P_A(A_t,X_t). (11) This equation is intentionally more general than the particular relationship-state implementation used in the proof-of-concept experiments. It states that accessibility is a time-indexed computational object whose future state may depend on its present configuration and on the encountered environment tX_t. Updates to ℱijF_ij or dijd_ij are possible realizations of this principle, not definitions of Accessibility Plasticity itself. 3.3 Computational Interpretation The model separates two usually entangled concepts: • node operators determine what local computation can be performed; • accessibility states determine whether and how existing computation can be reached. This separation is the core design move of the paradigm. Learning is therefore not only the acquisition or modification of computational capability. It is also the reorganization of access to capabilities that already exist in the substrate. The system can respond to new tasks by reshaping relationships to existing operators before rewriting the operators themselves. Unlike conventional neural networks, where learning is primarily stored in node parameters, the proposed substrate allows learning to emerge from the evolution of relationships between computational units. Adaptation occurs through the evolution of computational relationships, not through explicit storage of interaction history. In compact form, the interpretation is: W W ⇒what computation exists, computation exists, ⇒what computation is accessible. computation is accessible. The contribution of the paper is Accessibility Plasticity as a first-class object of learning, not a new family of network architectures. Reuse ℛRExploit existing computationAccessibility Plasticity Δ what existing computation becomes accessibleCapability Plasticity ΔW WModify computational operatorsSubstrate Plasticity Δ(D,G) (D,G)Reorganize computational organization Figure 1: Adaptive systems possess multiple degrees of adaptive freedom. The proposed hierarchy orders forms of adaptation by increasing depth: systems should preferentially reuse existing computation, then modify computational accessibility, then modify computational capability, and only at the deepest level reorganize computational organization itself. Lower levels preserve more of the current computational identity of the system, whereas higher levels incur greater modification cost and structural persistence. The hierarchy denotes an ordering of adaptive depth rather than a mandatory optimization schedule. 3.4 Hierarchy of Adaptive Depth Adaptive systems possess multiple degrees of adaptive freedom. These degrees of freedom differ in persistence, reversibility, and modification cost. Adaptive freedom refers to the hierarchy of internal degrees of freedom through which a system can respond to environmental change. We propose a reuse-first ordering in which a system first exploits existing computational capability, then reorganizes computational accessibility, then modifies computational capability itself, and only finally reconfigures the organization of computation. The hierarchy can be summarized as: ℛ≺Δ≺ΔW≺Δ(D,G)R W (D,G) where ℛR denotes pure computational reuse without modification of accessibility, capability, or organization; Δ denotes changes in computational accessibility; ΔW W denotes modifications of computational capability; and Δ(D,G) (D,G) denotes reorganization of the computational substrate. The ordering does not represent a fixed algorithmic procedure or a mandatory optimization sequence. It is an ordering of adaptation depth. Lower levels preserve more of the existing computational identity of the system, whereas higher levels introduce increasingly fundamental changes to what the system can compute and how computation is organized. Reuse The first adaptive response is to exploit existing computational capability without modification. Given a new task or a shift in input distribution, the system first evaluates whether its current computational organization already contains sufficient capability to solve the problem. Successful reuse preserves existing knowledge and incurs minimal adaptation cost because neither accessibility relations nor computational operators are altered. Accessibility plasticity When the required computational capability already exists but is not effectively reachable under the current configuration, adaptation occurs through changes in computational accessibility. Accessibility is therefore not an additional computational capability; it is a property describing whether existing capabilities can participate in computation. We refer to this process as accessibility plasticity. In the adaptive computational substrate studied here, relationship-state evolution provides one substrate-level realization of this principle. Unlike mechanisms that merely select among existing pathways at inference time, accessibility plasticity modifies the underlying relationship landscape through which future computational pathways emerge. Let the accessibility configuration of the computational substrate be t=aijt,A_t=\a_ij^t\, (12) where aijta_ij^t represents the accessibility of the computational relationship between units i and j under the current substrate state. For the adaptive computational substrate, accessibility is induced by the relationship state Rijt=(ℱijt,dijt)R_ij^t=(F_ij^t,d_ij^t): aijt=g(ℱijt(xit,xjt)−βdijt),a_ij^t=g (F_ij^t(x_i^t,x_j^t)-β d_ij^t ), (13) where ℱijtF_ij^t evaluates relational compatibility and dijtd_ij^t represents computational distance between units. The mapping from relationship state to accessibility is not unique; the purpose of Eq. 13 is to provide one realizable coordinate system for an otherwise abstract adaptive variable. The evolution of accessibility is therefore described at an abstract level as: t+1=A(t,t),A_t+1=P_A(A_t,X_t), (14) where AP_A denotes an accessibility plasticity operator and tX_t represents the computational experience accumulated by the system at time t, including interaction outcomes, task feedback, and environmental signals. This formulation emphasizes that accessibility is itself an adaptive state variable whose evolution is governed by experience, rather than a fixed property of the computational substrate. The abstract update t+1=A(t,t)A_t+1=P_A(A_t,X_t) is therefore the protected theoretical statement; any concrete distance-based update or relationship-state update is only one possible realization, not the definition of Accessibility Plasticity. A concrete realization of this principle can be obtained by adapting the underlying relationship geometry. For example, computational distance may evolve according to: dijt+1=dijt−ηdsijt,d_ij^t+1=d_ij^t- _ds_ij^t, (15) where sijts_ij^t denotes the interaction outcome between computational units i and j. Successful interactions reduce computational distance and increase future accessibility, whereas unsuccessful interactions weaken the corresponding relationship. In this realization, the history of interaction is implicitly stored in the evolving relationship state rather than through an external memory mechanism. Therefore, adaptation occurs first by reshaping access to existing computation rather than modifying the computation itself. Capability plasticity When accessibility adaptation is insufficient because the existing computational capability cannot adequately represent the required transformation within the current substrate, the system modifies its local computational capabilities. This corresponds to conventional parameter adaptation, but with a stronger interpretation: capability plasticity changes what computation is available within the substrate, whereas accessibility plasticity changes whether existing computation can be reached. Wi←Wi+ΔWi.W_i← W_i+ W_i. (16) Because modifying operators can overwrite previously acquired competence, it is considered a deeper and more costly form of adaptation than accessibility plasticity. Substrate plasticity The highest level of adaptation occurs when both accessibility and capability modification become insufficient. At this level, the organization of computation itself changes. The learned computational distance matrix D=[dij]D=[d_ij] defines the relational geometry of the substrate. Persistent low-distance regions indicate strong computational affinity, while high-distance regions indicate weak relationships. Through this learned geometry, the substrate may reorganize itself by: • forming computational modules with persistent relational affinity; • dissolving obsolete structures when their internal relationships become incompatible; • redistributing computational boundaries according to learned relational geometry. Therefore, substrate plasticity is not presented here as a search procedure over architectures. It is the deepest adaptive level at which computational organization itself changes. A generic substrate adaptation objective can be written as: minD,GLtask+λsCs(D,G) _D,GL_task+ _sC_s(D,G) (17) where Cs(D,G)C_s(D,G) measures the cost of reorganizing computational organization under the learned relational geometry. At this highest level, adaptation no longer changes only information flow or individual computational operators. Instead, it transforms the computational landscape in which future computation becomes possible. 4 Operational Realization (Experimental Setup) The experiments are designed as proof-of-concept validation of the principle, not as a benchmark campaign for state-of-the-art continual learning. Their role is to test whether accessibility behaves as a distinct adaptive variable and whether reuse-first adaptation can reduce shared capability modification under sequential tasks. Concretely, the experimental design evaluates the following hypotheses: • accessibility plasticity constitutes a meaningful adaptive degree of freedom; • adaptive systems can reduce capability modification by first modifying accessibility; • accessibility adaptation is not equivalent to merely adding extra adaptive parameters; • accessibility alone is insufficient for continual adaptation, consistent with the proposed hierarchy ℛ≺Δ≺ΔW≺Δ(D,G)R W (D,G). 4.1 Proof-of-Concept Realization and Training Protocol The reuse-first hierarchy defines a general preference over modification depth: adaptation should first exploit existing computation, then reorganize accessibility, and only afterwards rewrite computational capability. At the principle level, the objective is not only low task loss, but low task loss with minimal internal transformation. One practical realization therefore augments the task objective with separate costs for accessibility and capability change: ℒ=Ltask+λACA+λWCW.L=L_task+ _AC_A+ _WC_W. (18) The key point is not regularization by itself. The point is that the optimization distinguishes modification depths by assigning different costs to changes in accessibility and changes in capability. In the present instantiation, CA C_A =‖Δℱ‖1+‖ΔD‖1, =\| \|_1+\| D\|_1, (19) CW C_W =∑i‖ΔWi‖F. = _i\| W_i\|_F. The first term measures reorganization of relationship state, while the second measures changes to shared computational operators. The intended inductive preference is λA≤λW, _A≤ _W, so that capability plasticity remains available but is invoked only when shallower adaptation is insufficient. Algorithm 1 summarizes one operational realization of the principle. It should be read as an instantiation rather than as the contribution itself. The experiments implement the hierarchy using a performance-based controller: at each task, the system attempts the shallowest adaptation depth and avoids deeper modification if the current depth satisfies a fixed training criterion. Operationally, s∗=minss:Acc(s)≥τ,s∈reuse,Δ,ΔW.s = _s\s:Acc(s)≥τ\, s∈\reuse, , W\. (20) Here τ=0.9τ=0.9 is the task-sequential experimental performance constraint, not the theoretical definition of Accessibility Plasticity. The dynamic datastream demonstration uses a slightly stricter target-environment controller threshold (τ=0.92τ=0.92) because it tracks progress toward the hardest stream endpoint rather than per-task adaptation alone. The task-sequential experiments contain three controlled stages for each task after the first: 1. Reuse: adapt only the task-specific readout head while freezing shared capability and accessibility; 2. Accessibility plasticity: freeze shared capability and update only the relationship state that induces accessibility; 3. Capability plasticity: freeze the learned relationship state and update only the shared computational operators if the previous stages do not achieve the task-accuracy threshold. The first task is used to initialize the shared capability bank, so it necessarily invokes capability plasticity. Thereafter, adaptation-stage decisions are made on the current task’s training split, while the reported continual-learning metrics are measured on held-out test data. This design avoids using test performance to decide when deeper modification stages are activated. In the dynamic datastream demonstration, the same staged preference is preserved, but reuse corresponds to evaluating the current model state on the incoming stream slice rather than to head-only adaptation. Environment and task inputxt,tx_t,X_tExisting computational capabilityW1,W2,…,WnW_1,W_2,…,W_nRelationship stateRij=(ℱij,dij)R_ij=(F_ij,d_ij)Accessibility statetA_tTask computation and outputyty_tSatisfied with the output?Organizational plasticityUpdate organizationΔ(D,G) (D,G)Capability plasticityUpdate computationΔW WAccessibility plasticityUpdate relationship state Rt+1R_t+1t+1=A(t,t)A_t+1=P_A(A_t,X_t) Figure 2: Operational realization of the adaptive transformation hierarchy. The system first evaluates output satisfaction. If adaptation is required, it proceeds through a hierarchical routing structure: first modifying accessibility state via relationship updates (t+1=A(t,t)A_t+1=P_A(A_t,X_t)), then invoking capability plasticity (ΔW W) if needed, and finally engaging theoretical organizational plasticity (Δ(D,G) (D,G)) as a deeper evolutionary layer. Algorithm 1 One Reuse-First Instantiation in the Operational Realization 1:computational graph G=(V,E)G=(V,E), task batch ℬB, adaptation thresholds ϵr,ϵA,ϵW _r, _A, _W 2:Evaluate current configuration on ℬB 3:if task loss ≤ϵr≤ _r then 4: return without modification 5:end if 6:Update accessibility state A 7:Realize accessibility adaptation through relationship updates 8:if task loss ≤ϵA≤ _A then 9: return after accessibility adaptation 10:end if 11:Freeze accessibility state A 12:Update computational operators W 13:if task loss ≤ϵW≤ _W then 14: return after capability adaptation 15:end if 16:Trigger deeper organizational reconfiguration if required 4.2 Datasets, Baselines, and Evaluation Metrics All experiments are CPU-only and use a single fixed random seed. Two controlled continual-learning settings are evaluated. Split MNIST. Five sequential binary tasks are constructed from MNIST: 0 versus 11, 22 versus 33, 44 versus 55, 66 versus 77, and 88 versus 99. Permuted MNIST. The same binary task sequence is retained, but each task receives a fixed task-specific pixel permutation. This benchmark preserves the simple continual-learning protocol while introducing a stronger distribution shift. For both datasets, each class contributes 250250 training examples and 120120 test examples per task. The baseline and EWC models are two-layer multilayer perceptrons with hidden dimension 6464 and task-specific binary heads. The operational realization of Accessibility Plasticity uses a shared bank of 88 experts, hidden dimension 6464, and a task-conditioned relationship state R=(ℱ,d)R=(F,d) that induces accessibility over the experts. The experimental comparisons include: • Baseline MLP: direct capability modification of a shared trunk; • Accessibility Plasticity Realization: reuse-first accessibility plasticity with capability updates when necessary; • Fixed Relationships: the same capability bank with accessibility adaptation disabled; • Accessibility Only: accessibility adaptation allowed, later capability plasticity disabled; • Random Accessibility Control: the same accessibility-state budget as the operational realization, but accessibility updates are random rather than relationship-driven; • EWC: a classical weight-preservation baseline. 4.2.1 Dynamic Accessibility Evolution In addition to the two task-sequential demonstrations, we include a lightweight streaming distribution-shift experiment. Its purpose is not benchmark comparison, but to test whether accessibility behaves as a dynamically evolving adaptive state. A single binary MNIST classifier is first trained on an easy stationary slice of digits 0 versus 11 to establish an initial computational state. The same classifier and readout are then exposed to an eight-step datastream in which permutation strength and noise level increase gradually over time. At each stream step, the system first evaluates the current model state, then updates the accessibility-inducing relationship state, and only then updates shared capability parameters if accessibility adaptation remains insufficient. The main readout is a learning-progress curve on the fixed hardest target distribution at the endpoint of the stream, together with the measured accessibility movement ΔAt A_t and shared capability movement ΔWt W_t at each step. The primary reported metrics are final average accuracy, average forgetting, capability modification cost CWC_W, accessibility modification cost CAC_A, and modification-efficiency score MES=PerformanceCA+CW.MES= PerformanceC_A+C_W. (21) In the experiments, CWC_W is measured as the accumulated movement of the shared capability parameters only. For the baseline and EWC models, these parameters are the shared MLP trunk. For the operational realization of Accessibility Plasticity, they are the shared expert bank and shared post layer. Task-specific heads are excluded from CWC_W, and relationship-state parameters are excluded from CWC_W and counted instead in CAC_A. This distinction is important because the experimental claim concerns modification of shared computational capability, not all trainable parameters indiscriminately. 5 Results & Discussion Table 1 reports the results on Split MNIST, and Table 2 reports the results on Permuted MNIST. The results should be interpreted as proof-of-concept evidence for the proposed principle rather than as benchmark rankings. Model Accuracy Forgetting CWC_W CAC_A MES Baseline MLP 0.9583 0.0250 8.4460 0.0000 0.1135 Accessibility Plasticity Realization 0.9183 0.0177 2.8674 1.4131 0.2145 Fixed Relationships 0.9350 0.0052 6.8209 0.0000 0.1371 Accessibility Only 0.6625 0.0000 0.9107 1.2227 0.3105 Random Accessibility Control 0.8858 0.0083 1.8810 2.7926 0.1895 EWC 0.9658 0.0177 8.7388 0.0000 0.1105 Table 1: Proof-of-concept results on Split MNIST. The central comparison is not raw accuracy alone, but the relationship between performance and shared capability modification cost. Model Accuracy Forgetting CWC_W CAC_A MES Baseline MLP 0.9700 0.0125 9.5016 0.0000 0.1021 Accessibility Plasticity Realization 0.9242 0.0094 2.2484 0.5597 0.3291 Fixed Relationships 0.9408 0.0156 6.2389 0.0000 0.1508 Accessibility Only 0.6375 0.0000 0.9107 1.3141 0.2865 Random Accessibility Control 0.8608 0.0052 1.7982 2.9599 0.1809 EWC 0.9700 0.0104 9.3522 0.0000 0.1037 Table 2: Proof-of-concept results on Permuted MNIST. The qualitative pattern observed on Split MNIST remains visible under stronger distribution shift. Figure 3: Capability modification cost across methods on Split MNIST and Permuted MNIST. The operational realization of Accessibility Plasticity occupies a markedly lower capability-modification regime than the direct weight-updating baselines while remaining meaningfully above zero, indicating reduced but not eliminated capability plasticity. Figure 4: Final average accuracy on Split MNIST and Permuted MNIST. The purpose of the comparison is not to identify the highest-accuracy method in isolation, but to show that reduced capability modification under Accessibility Plasticity does not come from collapse of task performance. 5.1 Experimental Observations The first empirical observation is that the operational realization of Accessibility Plasticity does not achieve the highest raw accuracy. The strongest raw accuracies are obtained by the baseline MLP and EWC. This is consistent with the purpose of the experiments: they are not intended to establish state-of-the-art continual learning, but to test whether adaptation can move into a lower shared-capability-modification regime. Figures 3 and 4 summarize this empirical trade-off directly. Split MNIST. On Split MNIST, the operational realization of Accessibility Plasticity reaches accuracy 0.91830.9183 with capability cost 2.86742.8674, compared with baseline accuracy 0.95830.9583 and capability cost 8.44608.4460. The same model attains lower raw accuracy than Fixed Relationships (0.93500.9350), but requires much less capability modification (2.86742.8674 versus 6.82096.8209). The Random Accessibility Control reaches 0.88580.8858 accuracy while incurring accessibility cost 2.79262.7926, substantially higher than the accessibility cost of the learned operational realization (1.41311.4131). The Accessibility Only ablation yields final accuracy 0.66250.6625, indicating that accessibility adaptation alone does not carry the full sequential-learning burden. Permuted MNIST. On Permuted MNIST, the same qualitative pattern remains visible under stronger distribution shift. The operational realization reaches accuracy 0.92420.9242 with capability cost 2.24842.2484, compared with baseline accuracy 0.97000.9700 and capability cost 9.50169.5016. Fixed Relationships attains accuracy 0.94080.9408, but again with much larger capability cost (6.23896.2389). The Random Accessibility Control falls to 0.86080.8608 accuracy while spending accessibility cost 2.95992.9599, compared with 0.55970.5597 for the learned operational realization. Accessibility Only remains insufficient, with final accuracy 0.63750.6375. Figure 5: Accuracy-capability trade-off space for all methods on both datasets. Colors identify methods and marker shapes identify datasets, allowing the figure to compare adaptation regimes without crowding the plot with direct point labels. Dashed and dash-dotted curves show smooth objective-front fits to the empirical non-dominated trends within each dataset, not theoretical Pareto fronts over the broader model class. The operational realization of Accessibility Plasticity occupies a region with competitive accuracy and substantially lower shared capability modification than the direct weight-updating baselines. Accuracy-capability trade-off. Figure 5 summarizes the same empirical pattern in a single view. The operational realization of Accessibility Plasticity remains well below the baseline and EWC in capability modification cost while avoiding the severe performance collapse of the Accessibility Only ablation. Fixed Relationships and Random Accessibility Control occupy distinct intermediate regimes, reinforcing that the central effect is not merely the presence of additional adaptive state, but the learned use of accessibility as a separate adaptive degree of freedom. Figure 6: Online adaptation in a gradually shifting datastream. A modest initial state is established first, after which the same binary MNIST classifier is exposed to an eight-step stream with increasing permutation mix and noise level. The top panel shows the controlled shift schedule, the middle panel reports accessibility and capability modification at each step, and the bottom panel tracks accuracy on the fixed hardest target environment before adaptation, after accessibility adaptation, and after the final model state. The trajectory shows continuous accessibility evolution throughout the stream, with capability plasticity appearing only at the latest and hardest steps. 5.1.1 Dynamic Accessibility Evolution Figure 6 tests the temporal interpretation of Accessibility Plasticity. Before the stream begins, the initialized model state reaches 0.77920.7792 accuracy on the hardest target environment. As the datastream progressively approaches that environment, target accuracy rises from 0.80830.8083 at the first stream step to 0.92500.9250 at the last. Accessibility changes at every step, with ΔAt A_t remaining nonzero throughout the stream, while shared capability modification is withheld until the final two and hardest steps (ΔWt=0.0556 W_t=0.0556 and 0.06200.0620). The stagewise curves show that accessibility adaptation already improves target accuracy during the stream, from 0.77920.7792 to 0.89580.8958 before the late capability updates, after which the final target accuracy reaches 0.92500.9250. This experiment is intentionally small, but it provides a clearer proof-of-concept for the claim that accessibility is not only an optimization variable at an endpoint; it can function as a continuously evolving adaptive state under feedback from a changing datastream. 5.2 Interpretation Relative to the Central Claims The experiments support this claim. Removing accessibility adaptation while keeping the shared capability bank produces a materially different regime. Compared with Fixed Relationships, the operational realization reduces capability modification by approximately 58.0%58.0\% on Split MNIST and 64.0%64.0\% on Permuted MNIST. This is the most direct evidence in the current experiments that accessibility is not a decorative auxiliary variable, but a meaningful adaptive degree of freedom. The support for this claim is positive but appropriately qualified. After the first task, the operational realization follows the trace reuse → accessibility → capability on every subsequent task in both datasets. Accessibility adaptation often improves the current-task training signal before capability plasticity is enabled, and the relationship state is frozen once capability plasticity begins. Across the eight post-initial tasks, accessibility adaptation improves current-task training accuracy in seven cases. The effect is especially visible on Permuted MNIST, where the accessibility stage raises current-task training accuracy from 0.5200.520 to 0.5440.544, from 0.6180.618 to 0.6500.650, from 0.4940.494 to 0.5760.576, and from 0.5640.564 to 0.7920.792 before shared capability is updated. However, accessibility adaptation alone is usually not sufficient to reach the target threshold, so capability plasticity is still invoked. The experiments therefore support a reduction-before-rewriting interpretation rather than a claim that accessibility generally eliminates the need for capability change. The random accessibility control is designed precisely for this question. It matches the operational realization at the level of accessibility-state budget, but replaces relationship-driven updates with random perturbations. If the effect were only a consequence of adding extra adaptable state, the random control should behave similarly to the learned realization. It does not. On Split MNIST, the random control attains lower accuracy (0.88580.8858 versus 0.91830.9183) while spending much more accessibility cost (2.79262.7926 versus 1.41311.4131). On Permuted MNIST, the gap is even clearer: 0.86080.8608 versus 0.92420.9242 in accuracy, with 2.95992.9599 versus 0.55970.5597 in accessibility cost. These comparisons support the claim that structured relationship adaptation matters, not merely the presence of extra adaptive parameters. The Accessibility Only variant strongly supports this claim. Once later capability plasticity is disabled, final accuracy drops to 0.66250.6625 on Split MNIST and 0.63750.6375 on Permuted MNIST. Forgetting is low in this condition, but that low forgetting is inseparable from the model’s limited ability to absorb the full task sequence. In other words, accessibility plasticity can carry part of the adaptation burden, but not the whole burden. This is consistent with the proposed hierarchy: reuse and accessibility plasticity are meaningful shallower responses, but deeper capability plasticity remains necessary when the required computation does not become sufficiently available through accessibility alone. 5.3 Relationship to Existing Adaptive Mechanisms These experiments do not establish state-of-the-art continual learning, nor do they show superiority over all continual-learning baselines. They also do not constitute empirical comparisons against attention, routing, gating, mixture-of-experts systems, dynamic networks, or deeper organizational plasticity. That is intentional. The present paper proposes Accessibility Plasticity as a higher-level adaptive abstraction rather than as a competing architectural mechanism. Existing mechanisms such as attention, routing, gating, and mixture-of-experts may be viewed as possible realizations of accessibility modulation at different levels of description; direct empirical comparisons with those mechanisms are left for future work. 5.4 Limitations and Future Work The current empirical evidence should therefore be interpreted narrowly and carefully. It provides proof-of-concept support for the claim that accessibility is a distinct computational object whose adaptation can precede and reduce shared capability modification. It does not yet validate the deepest level of the hierarchy, Δ(D,G) (D,G), and it does not yet provide the scale of evidence that would be required for a mature benchmark paper. Natural next steps include multiple random seeds, confidence intervals, larger continual-learning benchmarks, stronger ablation studies, larger-scale online environments, embodied agents, and lifelong-learning settings in which environmental change is not organized into hand-designed phases. These extensions would broaden the empirical case; they are not prerequisites for the narrower proof-of-concept conclusions drawn here. 6 Conclusion This paper develops Accessibility Plasticity as a paradigm for reuse-first adaptation and presents one graph-based operational realization. The key move is to separate computational capability from computational accessibility and to treat accessibility as a fundamental computational object. In this view, W determines what computation exists, whereas A determines what computation is accessible. Learning is therefore not only changing what computation exists; it is changing how existing computation becomes accessible. The resulting framework is mathematically simple enough to instantiate, yet conceptually broad enough to connect continual learning and adaptive computation under a shared principle. If validated empirically, the paradigm would support a shift from architecture-centric learning toward relationship-centric adaptation. Even if future experiments reveal limitations, the formulation provides a rigorous starting point for studying whether intelligent systems can adapt by reorganizing computation before rebuilding it. References [1] M. L. Anderson (2010) Neural reuse: a fundamental organizational principle of the brain. Behavioral and brain sciences 33 (4), p. 245–266. Cited by: §1. [2] P. W. Battaglia, J. B. Hamrick, V. Bapst, A. Sanchez-Gonzalez, V. Zambaldi, M. Malinowski, A. Tacchetti, D. Raposo, A. Santoro, R. Faulkner, et al. (2018) Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261. Cited by: §1. [3] Y. Bengio, N. Léonard, and A. Courville (2013) Estimating or propagating gradients through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432. Cited by: §1. [4] R. Bommasani, D. A. Hudson, E. Adeli, R. Altman, S. Arora, S. von Arx, M. S. Bernstein, J. Bohg, A. Bosselut, E. Brunskill, et al. (2021) On the opportunities and risks of foundation models. arXiv preprint arXiv:2108.07258. Cited by: §1. [5] T. Brown, B. Mann, N. Ryder, M. Subbiah, J. D. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al. (2020) Language models are few-shot learners. Advances in neural information processing systems 33, p. 1877–1901. Cited by: §1. [6] N. Ding, Y. Qin, G. Yang, F. Wei, Z. Yang, Y. Su, S. Hu, Y. Chen, C. Chan, W. Chen, et al. (2023) Parameter-efficient fine-tuning of large-scale pre-trained language models. Nature machine intelligence 5 (3), p. 220–235. Cited by: §1. [7] D. Hassabis, D. Kumaran, C. Summerfield, and M. Botvinick (2017) Neuroscience-inspired artificial intelligence. Neuron 95 (2), p. 245–258. Cited by: §1. [8] K. He, X. Zhang, S. Ren, and J. Sun (2016) Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, p. 770–778. Cited by: §1. [9] A. Holtmaat and K. Svoboda (2009) Experience-dependent structural synaptic plasticity in the mammalian brain. Nature Reviews Neuroscience 10 (9), p. 647–658. Cited by: §1. [10] N. Houlsby, A. Giurgiu, S. Jastrzebski, B. Morrone, Q. De Laroussilhe, A. Gesmundo, M. Attariyan, and S. Gelly (2019) Parameter-efficient transfer learning for nlp. In International conference on machine learning, p. 2790–2799. Cited by: §1. [11] E. J. Hu, Y. Shen, P. Wallis, Z. Allen-Zhu, Y. Li, S. Wang, L. Wang, W. Chen, et al. (2022) Lora: low-rank adaptation of large language models.. Iclr 1 (2), p. 3. Cited by: §1. [12] T. N. Kipf and M. Welling (2016) Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907. Cited by: §1. [13] Y. LeCun, Y. Bengio, and G. Hinton (2015) Deep learning. nature 521 (7553), p. 436–444. Cited by: §1. [14] J. C. Magee and C. Grienberger (2020) Synaptic plasticity forms and functions. Annual review of neuroscience 43 (1), p. 95–117. Cited by: §1. [15] E. Marder and V. Thirumalai (2002) Cellular, synaptic and network effects of neuromodulation. Neural Networks 15 (4-6), p. 479–493. Cited by: §1. [16] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, et al. (2015) Human-level control through deep reinforcement learning. nature 518 (7540), p. 529–533. Cited by: §1. [17] G. I. Parisi, R. Kemker, J. L. Part, C. Kanan, and S. Wermter (2019) Continual lifelong learning with neural networks: a review. Neural networks 113, p. 54–71. Cited by: §1. [18] J. Pfeiffer, S. Ruder, I. Vulić, and E. M. Ponti (2023) Modular deep learning. arXiv preprint arXiv:2302.11529. Cited by: §1. [19] B. A. Richards, T. P. Lillicrap, P. Beaudoin, Y. Bengio, R. Bogacz, A. Christensen, C. Clopath, R. P. Costa, A. de Berker, S. Ganguli, et al. (2019) A deep learning framework for neuroscience. Nature neuroscience 22 (11), p. 1761–1770. Cited by: §1. [20] C. Rosenbaum, T. Klinger, and M. Riemer (2017) Routing networks: adaptive selection of non-linear functions for multi-task learning. arXiv preprint arXiv:1711.01239. Cited by: §1. [21] N. Shazeer, A. Mirhoseini, K. Maziarz, A. Davis, Q. Le, G. Hinton, and J. Dean (2017) Outrageously large neural networks: the sparsely-gated mixture-of-experts layer. arXiv preprint arXiv:1701.06538. Cited by: §1. [22] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin (2017) Attention is all you need. Advances in neural information processing systems 30. Cited by: §1, §1.