Towards Version-aware Operations and Transaction Memories for Multi-layer MeMo

# Towards Version-aware Operations and Transaction Memories for Multi-layer MeMo
Source: [https://arxiv.org/html/2606.24040](https://arxiv.org/html/2606.24040)
\\copyrightclause

Copyright for this paper by its authors\. Use permitted under Creative Commons License Attribution 4\.0 International \(CC BY 4\.0\)\.

\\conference

MeMo Workshop on Mechanistic Interpretability & Neuro\-symbolic Approaches by\-design, Rome \(Italy\), 24/6/2026

\[orcid=0009\-0002\-5807\-3432, email=peiran\.li@fu\-berlin\.de, \]

\(2026\)

###### Abstract

MeMo proposes language models with explicit multi\-layer correlation matrix memories \(CMMs\), where memorization, retrieval, and forgetting are architectural operations\. This paper asks how such memories can reduce the need for retraining when knowledge changes\. For changes expressible as MeMo memory associations, the model’s accessible knowledge can be updated by editing explicit memories rather than retraining the whole model\. We propose a version\-aware operation layer in which high\-level operations such asreplace,obsolete,keep\-history,rollback, andtraceare compiled into MeMo\-native primitive calls over sequences and tokens\. The key observation is that a version\-aware operation is rarely a single MeMo association\. It is an ordered transaction of primitive edits, for example forgetting one sequence\-token chain, memorizing another, preserving a historical chain, and recording an inverse program\. The framework introduces two auxiliary CMMs: a Version CMM \(V\-CMM\) for mapping version transitions to transaction handles, and a Transaction CMM \(T\-CMM\) for storing reusable change contents and inverse programs\. It supports both direct sequence\-level edits and structured diff\-level inputs, and outlines an evaluation route for update success, rollback, traceability, locality, and transaction reuse\.

###### keywords:

MeMo\\sepcorrelation matrix memory\\septransaction memory\\sepversion\-aware operations\\sepmemory editing\\sepneuro\-symbolic AI

## 1Introduction

Large Language Models are often adapted to new or changed knowledge through continued training, retrieval augmentation, or parameter\-level model editing\[gururangan2020dontstop,lewis2020rag,meng2022rome,meng2023memit\]\. These methods can be effective, but they are not ideal when a knowledge change is small and can already be expressed as an explicit memory association\. In that case, the natural goal is to update the model’s accessible knowledge by editing memory directly, rather than retraining on a fully revised corpus\. MeMo is a useful starting point because it externalizes memory through correlation matrix memories and makes memorization and forgetting explicit operations rather than only side effects of training\[zanzotto2025memo\]\. Its final architecture is Multi\-layer MeMo: a stack of CMMs composes input sequences and supports retrieval from explicit memory structures\.

This paper keeps that Multi\-layer MeMo architecture intact\. We ask what operation layer is needed when explicit memories are long\-lived, versioned, and repeatedly edited\. MeMo provides primitive actions such as memorizing, retrieving, and forgetting a sequence\-value association, but knowledge evolution also needs replacement, historical preservation, obsolescence, trace, and rollback\.

The central idea is to treat such operations as transactions over MeMo primitive edits\. A transaction is not a single association\(S,y\)\(S,y\); it is an ordered program that may remove\(S,yo​l​d\)\(S,y\_\{old\}\), add\(S,yn​e​w\)\(S,y\_\{new\}\), save historical memories, and record an inverse\. We therefore design a two\-stage auxiliary memory\. A Version CMM \(V\-CMM\) maps version transitions to transaction handles, and a Transaction CMM \(T\-CMM\) maps transaction handles to executable edits\. MeMo CMMs store what is remembered; V\-CMM and T\-CMM store which memory edits belong to a version change and how those edits should be executed\.

The proposed algebra has two input levels\. At the lower level, it supports direct sequence\-token updates, such as replacing the memorized continuation of a MeMo sequence\. At the higher level, structured knowledge changes, for example ontology moves or obsoletions, are compiled into sets of sequence\-token transactions\. Change languages such as KGCL provide a realistic interface for such structured changes\[hegde2025change\], while the contribution remains a version\-aware operation algebra for Multi\-layer MeMo\.

## 2Multi\-layer MeMo as Substrate

A CMM stores associations by outer products, following classical correlation matrix memory and related distributed\-memory ideas\[kohonen1972correlation,anderson1972simple,plate1995holographic\]\. For example,

C=∑iki​vi⊤\.C=\\sum\_\{i\}k\_\{i\}v\_\{i\}^\{\\top\}\.\(1\)A query multiplies the memory matrix, and forgetting subtracts a corresponding outer product\. Multi\-layer MeMo extends this mechanism with several CMM layers that compose input sequences into higher\-level sequence representations\[zanzotto2025memo\]\. We denote the original stack by:

𝒞MeMo=\{C\(1\),C\(2\),…,C\(L\),C\(o​u​t\)\}\.\\mathcal\{C\}\_\{\\mathrm\{MeMo\}\}=\\\{C^\{\(1\)\},C^\{\(2\)\},\\ldots,C^\{\(L\)\},C^\{\(out\)\}\\\}\.\(2\)
At the interface level, we abstract the existing implementation through three primitive procedures:

memo​\(S,y\),\\displaystyle\\mathrm\{memo\}\(S,y\),forget​\(S,y\),\\displaystyle\\mathrm\{forget\}\(S,y\),retrieve​\(S\),\\displaystyle\\mathrm\{retrieve\}\(S\),\(3\)whereSSis an input sequence andyyis the associated token or value\. The internal multi\-layer CMM machinery decides how the relevant layers are updated\. The operation layer introduced below delegates to these primitives instead of directly modifying the layer design\.

## 3Version\-aware Operations

### 3\.1Direct sequence\-level operations

The lowest\-level input to the proposed algebra is already MeMo\-native: a sequence\-token edit\. At the operation level, a primitive edit can be represented as:

ej=\(Sj,yj,λj\),λj∈\{\+1,−1\},e\_\{j\}=\(S\_\{j\},y\_\{j\},\\lambda\_\{j\}\),\\qquad\\lambda\_\{j\}\\in\\\{\+1,\-1\\\},\(4\)whereλj=\+1\\lambda\_\{j\}=\+1denotes memorization andλj=−1\\lambda\_\{j\}=\-1denotes forgetting\. When an implementation exposes layer\-specific updates, the executable form is\(ℓj,Sj,yj,λj\)\(\\ell\_\{j\},S\_\{j\},y\_\{j\},\\lambda\_\{j\}\); otherwiseℓj\\ell\_\{j\}is left implicit and the standard multi\-layer MeMo routine decides which internal CMMs to update\. A high\-level operation is an ordered transaction of such edits:

τ=⟨e1;e2;…;em⟩\.\\tau=\\langle e\_\{1\};e\_\{2\};\\ldots;e\_\{m\}\\rangle\.\(5\)The order matters when later edits depend on continuations created by earlier ones\. For example, a direct replacement of a MeMo continuation is:

replace\(S,yo​l​d,yn​e​w\)=⟨\\displaystyle\\textsc\{replace\}\(S,y\_\{old\},y\_\{new\}\)=\\langle\(S,yo​l​d,−1\);\\displaystyle\(S,y\_\{old\},\-1\);\\\(S,yn​e​w,\+1\)⟩\.\\displaystyle\(S,y\_\{new\},\+1\)\\rangle\.\(6\)This operation changes the current view but does not erase the old value as a historical fact\. Version preservation adds explicit versioned sequences:

keep\-History=⟨\\displaystyle\\textsc\{keep\-History\}=\\langle\(Svt,yo​l​d,\+1\);\\displaystyle\(S\_\{v\_\{t\}\},y\_\{old\},\+1\);\\\(Svt\+1,yn​e​w,\+1\)⟩\.\\displaystyle\(S\_\{v\_\{t\+1\}\},y\_\{new\},\+1\)\\rangle\.\(7\)Thus, forgetting from the current view is not necessarily erasure\. It can mean deactivation from the latest view while preserving earlier memories for version\-specific queries and rollback\.

Multi\-token continuations\.Although examples are sometimes written as ifyywere a single value, MeMo’s native primitive is next\-token memory\. A continuationY=\[y1,…,yn\]Y=\[y\_\{1\},\\ldots,y\_\{n\}\]must therefore be decomposed into a chain of primitive edits:

chain\(S,Y,λ\)=⟨\\displaystyle\\mathrm\{chain\}\(S,Y,\\lambda\)=\\langle\(S,y1,λ\);\(S​y1,y2,λ\);\\displaystyle\(S,y\_\{1\},\\lambda\);\(Sy\_\{1\},y\_\{2\},\\lambda\);\(8\)…;\(Sy1⋯yn−1,yn,λ\)⟩\.\\displaystyle\\ldots;\(Sy\_\{1\}\\cdots y\_\{n\-1\},y\_\{n\},\\lambda\)\\rangle\.A replacement between continuations becomes:

replace​\(S,Yo,Yn\)=chain​\(S,Yo,−1\);chain​\(S,Yn,\+1\)\.\\textsc\{replace\}\(S,Y\_\{o\},Y\_\{n\}\)=\\mathrm\{chain\}\(S,Y\_\{o\},\-1\);\\mathrm\{chain\}\(S,Y\_\{n\},\+1\)\.\(9\)The T\-CMM records either this expanded edit set for small transactions or, in the scalable implementation, a reusable template and parameter handles from which the edit chain is generated at execution time\. In both cases, the original MeMo stack still receives only standard\(s​e​q​u​e​n​c​e,t​o​k​e​n\)\(sequence,token\)operations\.

### 3\.2Structured keys and higher\-level changes

A structured assertion can be represented as\(v,s,r,o\)\(v,s,r,o\), wherevvis a version or view,ssis a subject,rris a relation, andoois an object value\. To make it compatible with Multi\-layer MeMo, the structured key is serialized into an input sequence:

σ​\(v,s,r\)=\[VERSION,v,SUBJECT,s,RELATION,r\]\.\\sigma\(v,s,r\)=\[\\texttt\{VERSION\},v,\\texttt\{SUBJECT\},s,\\texttt\{RELATION\},r\]\.\(10\)For structured resources,ss,rr, andoodenote stable identifiers rather than mutable labels; labels are used only for verbalization\. Writing the assertion is a standard MeMo call:

memo​\(σ​\(v,s,r\),o\),\\mathrm\{memo\}\(\\sigma\(v,s,r\),o\),\(11\)and removing it from a view is:

forget​\(σ​\(v,s,r\),o\)\.\\mathrm\{forget\}\(\\sigma\(v,s,r\),o\)\.\(12\)A structured change such as a class move or definition change is first normalized into one or more sequence\-level transactions\. For instance, replacing the latest value of\(s,r\)\(s,r\)fromoo​l​do\_\{old\}toon​e​wo\_\{new\}becomes:

⟨\\displaystyle\\langle\(σ​\(vlatest,s,r\),oo​l​d,−1\);\\displaystyle\(\\sigma\(\\mathrm\{v\_\{latest\}\},s,r\),o\_\{old\},\-1\);\\\(σ​\(vlatest,s,r\),on​e​w,\+1\);\\displaystyle\(\\sigma\(\\mathrm\{v\_\{latest\}\},s,r\),o\_\{new\},\+1\);\(σ​\(vt,s,r\),oo​l​d,\+1\);\\displaystyle\(\\sigma\(v\_\{t\},s,r\),o\_\{old\},\+1\);\\\(σ\(vt\+1,s,r\),on​e​w,\+1\)⟩\.\\displaystyle\(\\sigma\(v\_\{t\+1\},s,r\),o\_\{new\},\+1\)\\rangle\.\(13\)The same mechanism supportsobsolete: an old current status is deactivated, a new obsolete status is memorized, an optional replacement is memorized, and the previous status is preserved under the source version\.

## 4Version and Transaction Correlation Memories

### 4\.1Why CMMs instead of only logs?

A version\-aware operation is not itself a standard MeMo memory entry\. MeMo stores next\-token associations of the form\(S,y\)\(S,y\)\. A transaction may instead relate two continuations, such as replacingYoY\_\{o\}byYnY\_\{n\}, and must be decomposed into several primitive\(s​e​q​u​e​n​c​e,t​o​k​e​n\)\(sequence,token\)edits\. It may remove old edits, add new edits, preserve versioned edits, and store an inverse program\.

An exact log is still useful, and in safety\-critical settings it should remain the deterministic source of truth\. However, logs alone do not provide a MeMo\-native representation of reusable change contents\. Version histories may be large, and many changes instantiate the same patterns: replacing a continuation, moving a class, obsoleting a term, or adding a synonym\. We therefore separate version indexing from transaction content\. A Version CMM \(V\-CMM\) maps a version transition to transaction handles\. A Transaction CMM \(T\-CMM\) maps a transaction handle to the executable edit fields needed by MeMo\. The exact log guarantees replayability; V\-CMM and T\-CMM provide compact associative indexing and reuse\.

### 4\.2V\-CMM for version indexing

Letva→vbv\_\{a\}\\rightarrow v\_\{b\}be a version transition containing transactionsτa,b,1,…,τa,b,n\\tau\_\{a,b,1\},\\ldots,\\tau\_\{a,b,n\}\. A slot\-based V\-CMM stores the association between a version transition, a slot, and a transaction handle:

V=∑\(va,vb,i,τ\)∈𝒱A​\(va,vb,i\)​B​\(τ\)⊤\.V=\\sum\_\{\(v\_\{a\},v\_\{b\},i,\\tau\)\\in\\mathcal\{V\}\}A\(v\_\{a\},v\_\{b\},i\)B\(\\tau\)^\{\\top\}\.\(14\)QueryingVVwithA​\(va,vb,i\)A\(v\_\{a\},v\_\{b\},i\)retrieves theii\-th transaction handle for that transition\. A count entry or a stop symbol can indicate how many slots are active\. This slot\-based form is easier to audit and execute deterministically than compressing all transactions into a single vector\. A more compact variant could bundle all transaction vectors for a transition into a superposed representation, but we treat that as an associative retrieval optimization rather than the execution semantics\.

### 4\.3T\-CMM for executable change content

A transaction entry is represented as a mapping:

\(τ,j,a\)↦b,\(\\tau,j,a\)\\mapsto b,\(15\)whereτ\\tauis a transaction identifier,jjindexes a primitive edit inside the transaction,aais a field name, andbbis the field value\. Examples include:

\(τ,j,sequence\)↦Sj,\\displaystyle\(\\tau,j,\\mathrm\{sequence\}\)\\mapsto S\_\{j\},\(τ,j,value\)↦yj,\\displaystyle\(\\tau,j,\\mathrm\{value\}\)\\mapsto y\_\{j\},\(16\)\(τ,j,sign\)↦λj,\\displaystyle\(\\tau,j,\\mathrm\{sign\}\)\\mapsto\\lambda\_\{j\},\(τ,j,layer\)↦ℓj\.\\displaystyle\(\\tau,j,\\mathrm\{layer\}\)\\mapsto\\ell\_\{j\}\.\(17\)The T\-CMM is:

T=∑\(τ,j,a,b\)∈𝒯Γ​\(τ,j,a\)​Ωa​\(b\)⊤,T=\\sum\_\{\(\\tau,j,a,b\)\\in\\mathcal\{T\}\}\\Gamma\(\\tau,j,a\)\\Omega\_\{a\}\(b\)^\{\\top\},\(18\)whereΓ\\Gammaencodes transaction\-field keys andΩa\\Omega\_\{a\}is a field\-dependent value encoder\. This field dependence is necessary because not all transaction values have the same role\. Metadata fields such as operation type, source version, or template identifier may use ordinary typed symbolic encoders\. Executable fields, however, must be MeMo\-compatible: sequence fields are decoded into sequences or handles that can be passed to the relevant MeMo sequence encoderk\(ℓ\)k^\{\(\\ell\)\}, token fields are decoded into values compatible with the MeMo value encoderv\(ℓ\)v^\{\(\\ell\)\}, and control fields such as sign and layer use separate typed encoders\.

Decoding a transaction therefore produces an ordered executable program:

decodeT​\(τ\)=⟨\(ℓj,Sj,yj,λj\)⟩j=1m\.\\mathrm\{decode\}\_\{T\}\(\\tau\)=\\langle\(\\ell\_\{j\},S\_\{j\},y\_\{j\},\\lambda\_\{j\}\)\\rangle\_\{j=1\}^\{m\}\.\(19\)Hereℓj\\ell\_\{j\}may specify a target MeMo layer, or be omitted when the standard multi\-layer MeMo memorization/forgetting routine should decide how to update its internal CMM stack\. Execution delegates to MeMo primitives as an ordered sequence:

execute​\(τ\)=p1;p2;⋯;pm,\\mathrm\{execute\}\(\\tau\)=p\_\{1\};p\_\{2\};\\cdots;p\_\{m\},\(20\)where

pj=\{memo​\(Sj,yj\),λj=\+1,forget​\(Sj,yj\),λj=−1\.p\_\{j\}=\\begin\{cases\}\\mathrm\{memo\}\(S\_\{j\},y\_\{j\}\),&\\lambda\_\{j\}=\+1,\\\\ \\mathrm\{forget\}\(S\_\{j\},y\_\{j\}\),&\\lambda\_\{j\}=\-1\.\\end\{cases\}\(21\)If an implementation exposes layer\-specific primitives,pjp\_\{j\}can additionally carryℓj\\ell\_\{j\}and apply the corresponding MeMo\-compatible encodersk\(ℓj\)k^\{\(\\ell\_\{j\}\)\}andv\(ℓj\)v^\{\(\\ell\_\{j\}\)\}\. Otherwise, the existing Multi\-layer MeMo procedure performs the layer updates internally\.

Rollback is obtained by reversing the ordered program and flipping signs:

τ−1=⟨\(ℓm,Sm,ym,−λm\);…;\(ℓ1,S1,y1,−λ1\)⟩\.\\tau^\{\-1\}=\\langle\(\\ell\_\{m\},S\_\{m\},y\_\{m\},\-\\lambda\_\{m\}\);\\ldots;\(\\ell\_\{1\},S\_\{1\},y\_\{1\},\-\\lambda\_\{1\}\)\\rangle\.\(22\)Rollback has three cases\. Ifτ\\tauis isolated or the last\-applied transaction, the inverse program can be applied directly\. If transactions are dependent, the system should replay the exact log to the target version\. If versions are represented as logical views, rollback can instead switch the latest\-view alias to an earlier version without physically subtracting memories\.

### 4\.4Templates and reuse

Repeated changes should not require storing fully expanded edit programs each time\. The T\-CMM can store transaction templates and compact parameters\. A minimalreplacetemplate is:

templaterep=\[\(slotS,sloto​l​d,−1\),\(slotS,slotn​e​w,\+1\)\],\\mathrm\{template\}\_\{\\mathrm\{rep\}\}=\[\(\\mathrm\{slot\}\_\{S\},\\mathrm\{slot\}\_\{old\},\-1\),\(\\mathrm\{slot\}\_\{S\},\\mathrm\{slot\}\_\{new\},\+1\)\],\(23\)and concrete edits are obtained by instantiation,

instantiate​\(templaterep,S,yo​l​d,yn​e​w\)\.\\mathrm\{instantiate\}\(\\mathrm\{template\}\_\{\\mathrm\{rep\}\},S,y\_\{old\},y\_\{new\}\)\.\(24\)Longer templates add source\-version and target\-version slots for history preservation\. Thus, V\-CMM indexes which transactions belong to a version transition, while T\-CMM stores reusable change contents rather than duplicating full logs for every version\.

## 5Examples

### 5\.1Direct sequence\-level replacement

Suppose a MeMo model has a current memory reflecting an older classification:

S=“Pluto is a”→\[planet\]\.S=\\text\{\`\`Pluto is a''\}\\rightarrow\[\\mathrm\{planet\}\]\.\(25\)A later knowledge version classifies Pluto as a dwarf planet:

S→\[dwarf,planet\]\.S\\rightarrow\[\\mathrm\{dwarf\},\\mathrm\{planet\}\]\.\(26\)This example enters the algebra directly at the sequence\-continuation level\. For the transitionv1→v2v\_\{1\}\\rightarrow v\_\{2\}, V\-CMM first indexes the associated transaction handle:

A​\(v1,v2,1\)⊤​V≈B​\(τp​l​u​t​o\)\.A\(v\_\{1\},v\_\{2\},1\)^\{\\top\}V\\approx B\(\\tau\_\{pluto\}\)\.\(27\)T\-CMM then decodesτp​l​u​t​o\\tau\_\{pluto\}as an instance of a reusable continuation\-replacement template with parameters\(S,\[planet\],\[dwarf,planet\],v1,v2\)\(S,\[\\mathrm\{planet\}\],\[\\mathrm\{dwarf\},\\mathrm\{planet\}\],v\_\{1\},v\_\{2\}\)\. Because the new continuation contains two tokens, the transaction cannot be a single MeMo write\. It is expanded into MeMo\-compatible primitive edits:

e1=\(ℓ,S,planet,−1\),\\displaystyle e\_\{1\}=\(\\ell,S,\\mathrm\{planet\},\-1\),\(28\)e2=\(ℓ,S,dwarf,\+1\),\\displaystyle e\_\{2\}=\(\\ell,S,\\mathrm\{dwarf\},\+1\),\(29\)e3=\(ℓ,S​dwarf,planet,\+1\)\.\\displaystyle e\_\{3\}=\(\\ell,S\\ \\mathrm\{dwarf\},\\mathrm\{planet\},\+1\)\.\(30\)Historical preservation adds versioned chains:

chain​\(Sv1,\[planet\],\+1\),\\displaystyle\\mathrm\{chain\}\(S\_\{v\_\{1\}\},\[\\mathrm\{planet\}\],\+1\),\(31\)chain​\(Sv2,\[dwarf,planet\],\+1\)\.\\displaystyle\\mathrm\{chain\}\(S\_\{v\_\{2\}\},\[\\mathrm\{dwarf\},\\mathrm\{planet\}\],\+1\)\.\(32\)Thus V\-CMM routes the version transition to the transaction, T\-CMM stores how the transaction expands, and the original MeMo stack only receives ordinary\(s​e​q​u​e​n​c​e,t​o​k​e​n\)\(sequence,token\)edits\. The latest view generates the continuation\[dwarf,planet\]\[\\mathrm\{dwarf\},\\mathrm\{planet\}\], while av1v\_\{1\}query generates\[planet\]\[\\mathrm\{planet\}\]\. For readability, continuations are shown as word\-level tokens; an implementation would use the tokenizer units exposed to MeMo\.

### 5\.2Structured diff\-level update

A structured source can enter one level higher\. Consider an ontology\-style change:

\(v1,Asthma,direct​\_​parent\)↦RespiratoryDisease\(v\_\{1\},\\mathrm\{Asthma\},\\mathrm\{direct\\\_parent\}\)\\mapsto\\mathrm\{RespiratoryDisease\}\(33\)\(v2,Asthma,direct​\_​parent\)↦ChronicRespiratoryDisease\(v\_\{2\},\\mathrm\{Asthma\},\\mathrm\{direct\\\_parent\}\)\\mapsto\\mathrm\{ChronicRespiratoryDisease\}\(34\)A KGCL\-like input may describe this as a class move\. KGCL is a source\-level change description: it records what changed in the ontology, but not which MeMo memories to edit\. V\-CMM is instead an execution\-level index over MeMo\-facing transactions\. The compiler maps the source change to a transaction handle, for example:

A​\(v1,v2,1\)⊤​V≈B​\(τa​s​t​h​m​a\)\.A\(v\_\{1\},v\_\{2\},1\)^\{\\top\}V\\approx B\(\\tau\_\{asthma\}\)\.\(35\)The corresponding T\-CMM entry stores areplace\-continuationtemplate with handles for the serialized sequenceσ​\(v,s,r\)\\sigma\(v,s,r\), the old continuation, the new continuation, and the source/target versions\. Decodingτa​s​t​h​m​a\\tau\_\{asthma\}yields the same kind of ordered primitive edit program as in the Pluto example\. Thus structured diffs are compiled into transactions indexed by V\-CMM, decoded by T\-CMM, and executed by the unchanged Multi\-layer MeMo memorization and forgetting routines\.

## 6Evaluation Roadmap and Scope

The proposed work should be evaluated as a staged research programme\. A first prototype will expose the nativememo\\mathrm\{memo\},forget\\mathrm\{forget\}, andretrieve\\mathrm\{retrieve\}calls of an existing Multi\-layer MeMo implementation, implement the operation algebra, and add V\-CMM/T\-CMM modules\. It should cover direct continuation replacements and structured source\-level changes such as ontology moves, synonym changes, obsoletions, and definition updates\.

A small benchmark can use controlled toy facts for direct MeMo edits and ontology\-style diffs, such as the Asthma parent\-change example in Section 5\. Baselines should include no update, retrieval augmentation, symbolic log\-only patching without T\-CMM reuse, continued training or retraining where feasible, and parameter editing methods for single\-fact updates\. The main metrics are update success, outdated\-current suppression, historical preservation, rollback correctness, trace correctness, locality, and reuse\. Trace is an interpretability contribution: it should expose the memory\-level path from a current answer to the transaction, source version, old value, new value, and primitive edits that produced it\.

Scope and capacity\.The proposal targets local changes that can be expressed as MeMo\-compatible memory edits; full rewrites may still require training\. V\-CMM indexes version deltas rather than full versions: forvi→vi\+1v\_\{i\}\\rightarrow v\_\{i\+1\}, letΔi=⟨τi,1;…;τi,ni⟩\\Delta\_\{i\}=\\langle\\tau\_\{i,1\};\\ldots;\\tau\_\{i,n\_\{i\}\}\\ranglewithni≤Bn\_\{i\}\\leq B\. Large changes can be split into patch batches, and long transactions into bounded sub\-transactions\. T\-CMM stores reusable templates and parameter handles rather than fully expanded edit programs, so a bounded delta addsO​\(B​P\)O\(BP\)transaction\-memory parameters, excluding symbol tables and the exact log\.

## 7Conclusion

This paper formulates a version\-aware operation layer for Multi\-layer MeMo\. The original architecture remains unchanged: V\-CMM indexes version transitions to transaction handles, T\-CMM stores reusable change contents, and the MeMo stack executes the decoded memo/forget calls\. The research agenda is to test whether explicit associative memories can support incremental, reversible, and traceable knowledge updates in cases where the relevant change can be expressed as MeMo\-compatible memory associations\. The same transaction mechanism may also support future authorship and provenance attribution by associating memory edits with authors, curators, documents, or source communities, extending traceability from what changed to who introduced a memory and which source justified it\.

## Declaration on Generative AI

Generative AI tools were used as writing and editing assistance during the preparation of this paper, including support for language polishing, structural revision, and improving clarity and conciseness\. The author takes full responsibility for the content of the paper\.

## References