{"id":"febf30a8-557e-4ae7-ad3b-3b7ed44da593","arxiv_id":"2505.05926","paper_version":3,"verdict":"REJECT","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"high","formal_verification":"none","parameter_count":6,"one_line_summary":"AHR combines an autoencoder with a repulsive-force class centroid layout to replay compressed latent exemplars, reporting higher accuracy than selected CIL baselines.","lead":"This paper proposes AHR, a class-incremental learning method that stores compressed versions of old task examples and reconstructs them when training on new tasks. It claims better accuracy and a ten times smaller memory footprint than standard exemplar replay, but the complexity claim rests on a misuse of big-O notation.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The advertised O(0.1t) memory reduction is not a valid asymptotic claim and is never tested: O(0.1t)=O(t) in Landau notation, and the experiments fix total memory, so the claimed O(t)-versus-O(0.1t) regime is absent from the evaluation.","rationale":"The paper's stated contribution is a memory-complexity improvement: from O(t) for exemplar replay to O(0.1t). The reader's weakest assumption identifies the same point I would stress: the asymptotic statement is formally vacuous and empirically untested. The experiments fix total memory (Table 2, Section 4), which makes the tested regime O(1) in t, not O(t); the appendix's complexity derivation is only an assertion about a constant compression factor. This is not a disagreement with consensus or a matter of preference — it is an internal mismatch between the advertised claim and both the notation used and the protocol run. Because the central claim rests on this mismatch, the rejection is justified even before considering the stale baseline set or missing code. I therefore agree with the reader's weakest assumption and see no reason to alter the verdict. I am not raising the physics-motivated RFA/CPSEM apparatus as a separate objection: the ablation in Table 2 shows RFA helps empirically, so that part is internally supported.","tokens_in":18823,"tokens_out":5685,"duration_ms":62665,"concrete_test":"Run a controlled scaling experiment on CIFAR-100: split into t = 5, 10, 20 tasks with a fixed exemplars-per-class budget for both AHR and iCaRL, and record total exemplar-memory bytes and accuracy as functions of t; additionally, in the fixed-budget protocol of Table 2, add an equal-exemplar-count AHR row reporting bytes used. If AHR's memory versus t curve is not strictly below iCaRL's at matched accuracy (or if both curves are flat because the budget is fixed), the O(0.1t) headline is not supported.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Abstract and Table 1 claim AHR reduces exemplar-replay memory from O(t) to O(0.1t). Two problems are load-bearing. (1) In standard asymptotic notation O(0.1t)=O(t); a constant-factor compression is a practical gain but not a new complexity class. Appendix A.4 supports the claim only by asserting the encoder compresses '10 times at the very least', so the stated memory complexity 'becomes O(0.1t)' — this is not a derivation. (2) The evaluation never enters the O(t) regime the claim is about. Section 4 and Table 2 fix a constant total exemplar budget ('# Total Exemplars 200/2000') and state all methods use 'fixed exemplar memory, not growing', so both baseline and AHR memory are O(1) in t. No experiment varies t while holding exemplars per class fixed, and no comparison at equal exemplar count reports memory in bytes. The remaining empirical finding — that at a fixed byte budget, more lossy latent exemplars can beat fewer raw exemplars (AHR-lossless vs AHR-lossy-mini) — is plausible and consistent with earlier compressed-replay work (REMIND, i-CTRL), but it does not establish the advertised memory reduction or the O(0.1t) bound.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The manuscript proposes AHR, a class-incremental learning strategy that stores exemplars not as raw data but as compressed latent vectors produced by a hybrid autoencoder (HAE), and uses a charged-particle-system-inspired repulsive force algorithm (RFA) to place class centroids in the latent space. The authors claim that AHR reduces memory complexity from O(t) to O(0.1t) at the worst case, while keeping compute complexity at O(t), and report state-of-the-art accuracy across five benchmarks compared with ten baselines. The paper includes an extensive experimental section with ablations on compression, latent-space structuring methods, and resource consumption.","tokens_in":19106,"tokens_out":7624,"duration_ms":74169,"significance":"If the central complexity claim were valid, AHR would be a notable contribution: it would show that compressed latent replay can match or exceed raw exemplar replay while using an order of magnitude less memory. The empirical study is broad: five benchmarks, many baselines, ablation of lossy versus lossless replay, comparisons of latent-space structuring methods (RFA versus contrastive versus GMM), and resource-consumption experiments. The practical finding that, at a fixed memory budget, storing more lossy latent exemplars can outperform storing fewer raw exemplars is consistent with prior compressed-replay work (REMIND, i-CTRL) and is a useful confirmation. However, the advertised asymptotic memory reduction is not a valid complexity claim, and the experimental protocol, which fixes the total exemplar budget, does not measure memory scaling with the number of tasks.","major_comments":[{"comment":"The claim that AHR achieves O(0.1t) memory complexity is not meaningful under standard asymptotic notation: O(0.1t) = O(t), since constant factors are subsumed by the definition of big-O. The derivation in Appendix A.4, which concludes that a roughly 10x compression ratio 'becomes O(0.1t)', confuses a constant-factor saving at a fixed task count with a change in growth rate. At most, the authors can claim a constant-factor memory reduction at a given t; the asymptotic complexity of both AHR and exemplar replay remains O(t). This affects the abstract, Table 1, Section 1, Section 2, and Appendix A.4, and is the paper's headline contribution.","section":"Abstract, Table 1, Appendix A.4"},{"comment":"The experimental evaluation cannot support the advertised memory reduction because it never enters the regime in which the O(t) versus O(0.1t) distinction would matter. Table 2 fixes the total exemplar budget (#Total Exemplars 200/2000), and the text explicitly states that 'all the strategies always follow the fixed exemplar memory, not growing exemplar memory'. Under this protocol, both AHR and the exemplar-replay baselines have O(1) memory with respect to the number of tasks t. To substantiate the asymptotic claim, the authors would need to vary t while holding the number of exemplars per class (or per-task memory) constant and report memory usage in bytes as t grows. No such experiment is provided.","section":"Section 4, Table 2"},{"comment":"The 'derivation' of O(0.1t) in Appendix A.4 simply asserts that the encoder compresses the input '10 times at the very least in our experiments' and then concludes the memory complexity becomes O(0.1t). This is not a derivation; it is a constant-factor observation with no asymptotic content. Additionally, the claim of state-of-the-art performance is not fully supported because the baseline set omits several recent strong CIL methods (e.g., FeCAM, RanPAC, or other compressed-replay approaches from 2023 onward). The paper's results demonstrate competitiveness with the included baselines, but the 'SOTA' claim should be tempered or the comparison set updated.","section":"Appendix A.4, Section 4"}],"minor_comments":[{"comment":"The table uses the nonstandard notation O(cte) for constant memory; this should be written O(1) to avoid confusion.","section":"Table 1"},{"comment":"The Lagrangian in Eq. (3) contains a garbled summation index 'k=i,j'; the double sum over tasks and classes should be written with explicit indices (e.g., sum over i and j).","section":"Equation (3)"},{"comment":"Line 3 of Algorithm 4 has a typo: 'R ANK' should be 'RANK'. The formula for ε is also ambiguous: it should be the total memory divided by the current number of classes, and the notation should be clarified.","section":"Algorithm 4"},{"comment":"The loss expression on lines 8–10 is not a complete equation; it mixes the HAE loss and distillation losses without clear notation. Please present the full objective function.","section":"Algorithm 3"},{"comment":"The paper states that the source code is included in the supplementary material, but no code was available in the reviewed version; if code is truly provided, the authors should ensure it is accessible to reviewers and readers.","section":"General presentation"}],"recommendation":"major_revision","confidential_remarks":"The paper is clearly written but the central asymptotic claim is mathematically wrong. In my view the error is correctable: the authors should reframe the contribution as a constant-factor memory reduction and add experiments that scale the number of tasks while keeping per-class exemplar counts fixed. The empirical results are otherwise solid and the ablation suite is thorough. I would not reject on the basis of the complexity claim alone, but the authors must address it head-on before the paper can be considered for publication."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Colleague,\n\nThis paper proposes AHR, an autoencoder-based hybrid replay that stores compressed latent codes instead of raw exemplars, with a physics-inspired repulsive force algorithm (RFA) to space class centroids in latent space and classify by nearest centroid. The practical recipe is new in its specific combination, though it sits squarely in the compressed-replay line of REMIND and i-CTRL. The empirical work is solid: five benchmarks, ten baselines, ablations showing that within a fixed memory budget, more lossy decoded exemplars beat fewer raw ones. That is a genuinely useful observation and consistent with earlier compressed-replay results.\n\nThe soft spot is the advertised headline. The paper claims memory complexity drops from O(t) to O(0.1t). That is wrong in Landau notation: O(0.1t) is the same class as O(t). The constant factor matters in practice, but it is not an asymptotic reduction. And the experiments never enter the regime where exemplar count grows with t: total exemplar budget is fixed at 200 or 2000 across all tasks, so both AHR and baselines have O(1) memory in t. The claimed O(t)-versus-O(0.1t) comparison is absent. Appendix A.4 asserts a factor-of-10 compression without a derivation. So the central complexity claim is invalid as stated and untested by the evaluation. This is not a minor quibble; it is the paper's stated contribution.\n\nOther soft spots: the baseline set stops around 2022-2023, missing recent strong CIL methods like Foster and RanPAC. Code is promised in the supplementary material, but no actual repo link is visible. The RFA hyperparameters (charge, mass, time step) are many; the ablation against contrastive and GMM is helpful but does not show sensitivity.\n\nProportionate assessment: the underlying method works and the fixed-budget result is believable. The RFA centroid placement is a legitimate addition. But the paper needs a major rewrite to claim only a constant-factor memory saving, and to compare honestly with modern baselines and code availability. A serious referee could get it into shape.\n\nI'd send this to review rather than desk reject, because the empirical core is reproducible and the ablation is informative, even though the main claim must be corrected. If I worked in this area, I wouldn't cite it in its current form.","headline":"A useful empirical recipe with a broken headline claim: the O(0.1t) memory bound is not a valid asymptotic statement, and the experiments never test it, but the fixed-budget comparison of lossy latent replay is a real result worth refereeing.","tokens_in":19685,"tokens_out":1880,"would_cite":false,"duration_ms":18867,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"An autoencoder that stores replay exemplars as compressed latent codes matches or beats existing class-incremental learning methods while using less memory.","keywords":["class-incremental learning","catastrophic forgetting","exemplar replay","generative replay","hybrid replay","hybrid autoencoder","latent space compression","repulsive force algorithm"],"falsifier":"Keep the number of stored exemplars per class constant while increasing the number of tasks $t$, and measure the actual memory bytes consumed by AHR's latent exemplars plus its decoder against raw exemplar storage; if the total grows with the same slope as raw storage, or if the decoder's fixed cost dominates on short task streams, the central memory-complexity claim is not supported.","tokens_in":18562,"feed_emoji":"💾","tokens_out":5016,"duration_ms":47208,"temperature":0.7,"pith_summary":"Class-incremental learning systems must remember old classes while absorbing new ones, usually by replaying stored exemplars; this paper argues that storing those exemplars in the compressed latent space of a purpose-built autoencoder, rather than as raw images, gives the accuracy of exemplar replay with a fraction of the memory. The proposed strategy, AHR, pairs a hybrid autoencoder (HAE) with a repulsive-force placement of class centroids so that the same network both reconstructs old data for replay and classifies new data by nearest centroid. On five benchmarks and against ten baselines, the paper reports that AHR outperforms recent replay, generative, and hybrid methods under matched memory and compute budgets. If the strategy holds up, it would let continual learners keep more exemplars per class and scale to longer task streams on memory-constrained devices.","feed_headline":"Latent-space replay cuts class-incremental memory use","feed_subtitle":"An autoencoder stores replay exemplars as compressed codes, beating baselines on five benchmarks.","key_machinery":"The central object is the hybrid autoencoder (HAE), an encoder-decoder network whose objective is the sum of an $L^2$ reconstruction term and a clustering term that pulls each latent code toward its class centroid embedding (CCE). The class centroid embeddings are placed and kept apart by the repulsive force algorithm (RFA), which treats centroids as charged particles and minimizes Coulomb-style potential energy through Euler-Lagrange equations; this determines where each new class's centroid sits before training. The episodic memory holds latent codes rather than raw data, and the decoder's job is deliberately memorization rather than generalization, so decoded exemplars are near-lossless. At test time the encoder plus nearest-centroid matching performs classification. The same machinery therefore carries both replay and discrimination.","core_discovery":"The paper's central claim is that replay memory for class-incremental learning can be compressed without losing the benefits of exact exemplar replay. Where exemplar replay stores raw samples and generative replay fabricates pseudo-data, AHR encodes each exemplar into a low-dimensional latent vector, about ten times smaller than the input in the reported setups, stores those vectors in an episodic memory, and decodes them on demand during training. The same hybrid autoencoder is trained with a loss that simultaneously minimizes reconstruction error and clusters same-class samples around fixed class-centroid embeddings; the centroids are placed incrementally with the charged-particle-system energy minimization and repulsive-force algorithm so that new classes push apart from old ones in latent space. At inference, classification is nearest-centroid in the latent space, with no task identifiers. The paper claims this yields state-of-the-art performance across MNIST, SVHN, CIFAR-10, CIFAR-100, and miniImageNet while cutting worst-case memory from $O(t)$ to $O(0.1t)$ at the same $O(t)$ compute.","pith_inferences":["The asymptotic claim $O(0.1t)$ should be read as a constant-factor compression: in standard big-O semantics $0.1t$ and $t$ have the same growth rate, so the real promise is a tenfold constant-factor saving, not a new complexity class.","The evaluation fixes the total exemplar budget (200 or 2000) across all task counts, so the advertised memory reduction as $t$ grows is not directly measured; a test that grows $t$ while holding exemplars per class fixed would isolate it.","Because the decoder is a fixed cost that does not grow with $t$, the break-even point depends on task-stream length; on very short streams the decoder overhead could outweigh memory savings."],"forward_implications":["AHR can be grafted onto existing exemplar-replay pipelines, replacing stored raw images with stored latent codes and decoding them during rehearsal.","Under a fixed memory budget, the compression lets the learner store roughly ten times more exemplars per class, increasing exemplar diversity and reducing catastrophic forgetting.","Because classification happens directly in latent space by nearest centroid, the approach does not need task identifiers at test time and can operate in task-free settings.","The reported gains are largest when memory is small, suggesting compressed latent replay is most useful for long task streams and low-memory devices."],"supporting_citations":[{"why":"Supplies the exemplar-replay paradigm, herding selection, and nearest-centroid classification that AHR extends.","marker":"(Rebuffi et al., 2017)"},{"why":"Defines generative replay, the alternative AHR contrasts with and partially incorporates.","marker":"(Shin et al., 2017)"},{"why":"Provides the brain-inspired replay framework and the BI-R-SI baseline, and the evidence that lossy replay data can mitigate forgetting.","marker":"(Ven et al., 2020)"},{"why":"Supplies the charged-particle-system energy minimization and repulsive-force algorithm used to place class centroids.","marker":"(Nazmitdinov et al., 2017)"},{"why":"i-CTRL, the closest hybrid-replay baseline that also classifies in latent space.","marker":"(Tong et al., 2022)"},{"why":"REMIND, the compressed-feature replay baseline AHR compares against.","marker":"(Hayes et al., 2020b)"},{"why":"Defines the benchmark naming, evaluation protocol, and the exemplar-diversity evidence used to explain gains.","marker":"(Masana et al., 2020)"},{"why":"Supplies the balanced-training and implicit bias-correction components AHR adopts.","marker":"(Castro et al., 2018)"}],"fun_headline_variants":["Replay in latent space cuts class-incremental memory tenfold","Hybrid autoencoder stores replay as codes, slashing memory budget","Tenfold memory cut for class-incremental learning via autoencoder replay","Autoencoder replay: same accuracy, a tenth of the memory"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The memory-saving case assumes a tenfold compression of stored exemplars is a real asymptotic reduction, yet $0.1t$ grows exactly like $t$, and the experiments hold total memory fixed instead of letting it grow with the number of tasks.","fun_headline_variants_meta":{"raw":{"variants":["Replay in latent space cuts class-incremental memory tenfold","Hybrid autoencoder stores replay as codes, slashing memory budget","Tenfold memory cut for class-incremental learning via autoencoder replay","Autoencoder replay: same accuracy, a tenth of the memory"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000925,"raw_usage":{"total_tokens":3977,"prompt_tokens":967,"completion_tokens":3010,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":583,"completion_tokens_details":{"reasoning_tokens":2935}},"tokens_in":583,"tokens_out":3010,"duration_ms":20230,"temperature":1.0,"reasoning_tokens":2935,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-15T22:53:31.042581+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Keep the number of stored exemplars per class constant while increasing the number of tasks $t$, and measure the actual memory bytes consumed by AHR's latent exemplars plus its decoder against raw exemplar storage; if the total grows with the same slope as raw storage, or if the decoder's fixed cost dominates on short task streams, the central memory-complexity claim is not supported.","supporting_citations":[],"review_version":1}