{"id":"ca3565fc-46a6-465f-8c29-884421af3833","arxiv_id":"2501.11406","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":2,"one_line_summary":"Two abstracted-environment reduction frameworks convert a global accuracy requirement on an interconnected model into per-subsystem error budgets that guarantee stability and accuracy.","lead":"This paper presents two ways to reduce the size of models of interconnected systems, by shrinking each subsystem together with a low-order stand-in, called an abstraction, for its environment. The methods come with guarantees that the reduced whole system stays stable and meets a user-specified accuracy target, and they are tested on a wafer stage model.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Theorem 1's N_E formula fails an exact-reduction scalar test, so the central guarantee in Theorem 3 is not established as written.","rationale":"The reader's weakest_assumption concerns Lemma 3 and its deferred proof. That is a legitimate completeness concern, but my independent check of the explicit error expression disclosed a more acute problem: Theorem 1's displayed N_E matrix is not an identity for a simple single-subsystem example. Since Theorem 3 and Theorem 4 are derived from Theorem 1, the central claim of guaranteed stability and accuracy is not dependable as written. I verified the arithmetic by hand: with k=1, S22=0, Σ=2, and abstraction error 0.1, the exact reduction case must give Λ_C=0, but Eq. (22) produces -0.2353. This is not a subtle conservatism issue; it is an exact-equality claim that fails. The numerical benchmark may still happen to produce models that satisfy the final specification because a sign error can make the conditions more conservative, but the theorem itself is false as stated. A corrected derivation may repair the framework, which is why this is a correctness rejection rather than a suggestion that the overall research direction is invalid. The paper would need a re-derived N_E (and corresponding N_Sigma) plus re-run numerical checks before the guarantees can be accepted.","tokens_in":28145,"tokens_out":63374,"duration_ms":606390,"concrete_test":"Recompute Theorem 1 for the k=1 scalar case: S=[0 1;1 0], Σ=2, G_u=G_y=1, check_E1_22=0.1, and Λ_F,22=0. Directly, the reduced subsystem equals the original subsystem, so Λ_C=0. The printed N_E gives F_u(N_E, diag(0.1,0,0.1))=-0.2353. If the authors revise Eq. (22), rerun this same scalar identity check; the LFT must equal 0 for all values of the abstraction error when the reduction error is zero.","verdict_should_be":"REJECT","load_bearing_attack":"Theorem 1 (Eqs. (21)-(22)) asserts an exact LFT expression for the interconnected reduction error. This expression is the input to Theorem 3 and all robust specifications, so if it is wrong the central guarantee collapses. A concrete k=1 scalar check shows a failure. Take S=[0 1;1 0], Σ=2, G_u=G_y=1, and abstracted environment 22-block e=0.1. If the reduction error is zero (Λ_F,22=0), the reduced subsystem is exactly Σ, so the true interconnected error is Λ_C=0. Using the printed N_E with Z=S22-E_B,22=0 and M=(I-Σ S22)^(-1)Σ=2, the LFT gives F_u(N_E, diag(0.1,0,0.1)) = -0.2353, not 0. For nonzero reduction error δ=0.01, the direct value is Λ_C=0.006395, while the printed formula gives -0.2303. Thus Eq. (22) is not a valid realization of the error dynamics; a sign or structural error appears in the (3,1) block or its companions. Theorems 3 and 4 inherit this expression, so the claimed a-priori stability and accuracy guarantees are unsupported. The reader's concern about the deferred Lemma 3 proof is secondary: even with Lemma 3 accepted, Theorem 1's explicit formula fails a basic consistency check.","agreement_with_reader":"disagree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes two structure-preserving model-reduction frameworks for interconnected linear time-invariant systems. In both frameworks, each subsystem is reduced while connected to a low-order abstraction of its environment, where the environment is abstracted either as a whole (Algorithm 1) or by abstracting the other subsystems individually (Algorithm 2). The authors use robust-performance analysis to translate a prescribed accuracy specification on the reduced interconnected system into sufficient low-level accuracy specifications on the abstraction and reduction errors. The main theoretical results are Theorem 1 and Theorem 2, which express the interconnected error as an upper LFT of the low-level errors, and Theorem 3, which gives a frequency-domain scaling condition guaranteeing stability and accuracy of the reduced interconnected model. The framework is demonstrated on a 2D wafer-stage structural-dynamics benchmark, where environment abstraction (RAR-E) achieves a 128-state reduced interconnected model compared with 156 states for robust subsystem reduction (RSS).","tokens_in":1331,"tokens_out":1604,"duration_ms":124072,"significance":"If the main theorems were correct, the paper would offer a useful modular reduction framework with a priori stability and accuracy guarantees and a systematic way to choose reduction orders. The connection between environment abstraction and robust performance is natural, and the benchmark is a relevant industrial example. The paper also deserves credit for providing explicit algorithms (Algorithms 1-4) and for attempting to quantify conservatism in Section 6.3. However, the central error expression in Theorem 1 fails a basic exact-reduction consistency test, and the proofs of Lemma 3 and Theorems 1 and 3 are either deferred or sketched. Since Theorem 3 and Theorem 4 inherit Theorem 1, the claimed guarantees are not established as written. The computational-efficiency claim is also not supported by the benchmark, which reports higher computational cost for the proposed methods.","major_comments":[{"comment":"Theorem 1's expression for N_E is inconsistent with a simple exact-reduction test. Take k=1, S=[0 1; 1 0], Sigma=2, G_u=G_y=1, and abstracted environment block \\check E_22=0.1. If the reduction error is zero (\\tilde Lambda_F=0), then \\hat Sigma=Sigma and the true interconnected error is Lambda_C=0 by definition (14). In (22)-(24), Z=S22-E_B,22=0 and M=(I-Sigma S22)^{-1} Sigma=2, so the right-hand side of (21) becomes F_u(N_E, diag(0.1,0,0.1)) = -0.2353, which is not 0. For a nonzero reduction error delta=0.01, direct evaluation gives Lambda_C=0.006395, while the printed formula gives -0.2303. Thus Eq. (22) is not a valid realization of the interconnected error dynamics. Since Theorem 3 and Theorem 4 both rely on this expression, the a-priori stability and accuracy guarantees are unsupported as stated. The authors must correct N_E and re-verify all downstream results.","section":"Section 4.1.1, Eq. (22)"},{"comment":"Lemma 3 is load-bearing because Theorems 1 and 2 use it to express \\hat Sigma_B in terms of only the 22-partition reduction errors. Its proof is deferred to the authors' preprint [16, Lemma 2], and the paper itself notes in Section 5.3 that 'the accuracy of other partitions also influences the overall accuracy' of the interconnected model. This creates an apparent contradiction between the claimed sufficiency of the 22-only error terms and the acknowledged influence of the other partitions. A complete proof of Lemma 3, or a clear explanation of why the other partitions can be neglected in the error bound, is required before Theorem 3 can be accepted.","section":"Section 4.1, Lemma 3 (Eq. (16))"},{"comment":"The abstract and introduction claim that the approach 'significantly reduces the computational costs of reduction', but the benchmark shows the opposite for the considered example. The text after Table 2 states that RAR-E 'requires more computational resources for the structure-preserving reduction of F_l(\\check F_j,Sigma_j) than RSS requires for the subsystem reduction of Sigma_j' and that RAR-Sigma is even more costly. The subsequent argument that costs would be similar for very high-order systems is speculative and not demonstrated by any complexity analysis or additional experiment. The efficiency claim should be either substantiated or substantially qualified.","section":"Section 6.2 and Abstract"}],"minor_comments":[{"comment":"There is a typo in the sentence 'RSS andand RAR-Sigma result in reduced models of higher order'; 'andand' should be 'and'.","section":"Section 6.2"},{"comment":"The notation 'given \\check V, W' in (51) is ambiguous; Theorem 4 should specify whether the given weighting is \\check V_E or \\check V_Sigma, consistent with (44)-(45).","section":"Section 5.1, Theorem 4"}],"recommendation":"major_revision","confidential_remarks":"The paper depends heavily on the authors' preprint [16] for proofs of Lemma 3, Theorem 1, and Theorem 3. If [16] is not yet publicly available or not peer-reviewed, the reader cannot verify the central claims. More importantly, the explicit counterexample to Theorem 1 means the current version cannot be accepted. I would encourage the authors to re-derive the N_E expression, check the analogous N_Sigma expression in Theorem 2, and rerun the wafer-stage benchmark with the corrected formulas. If the corrections alter the reported reduced orders, the comparison with RSS should be redone."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Luuk's paper has a good idea: reduce each subsystem against a low-order abstraction of its environment, then use robust-performance arguments to turn a high-level accuracy specification on the interconnection into low-level error bounds on the abstraction and reduction steps. That is a practical way to make structure-preserving reduction tractable, and the two variants (whole-environment and per-subsystem abstraction) cover the modularity/accuracy trade-off. The wafer-stage benchmark is also encouraging: RAR-E lands at 128 states versus 156 for the existing RSS method with comparable or better accuracy.\n\nThe problem is in the math that is supposed to make the guarantees formal. Theorem 1 gives an explicit LFT expression for the interconnected error Lambda_C in terms of abstraction and reduction errors. That expression fails the most basic consistency test. Take a single scalar subsystem, S = [0 1; 1 0], Sigma = 2, zero reduction error, and any nonzero abstraction error, say 0.1. If the reduction error is zero, the reduced subsystem is exactly Sigma, so the true interconnected error must be zero. The printed N_E, with M = 2 and Z = 0, gives F_u(N_E, diag(0.1, 0, 0.1)) = -0.2353. That is not zero. The formula is simply wrong as written, or at least incompatible with its own definitions. Since Theorem 3 and the optimization of Theorem 4 are built on this expression, the a-priori stability and accuracy guarantees are not established. The proof is 'omitted for brevity' and deferred to the authors' prior work [16], which is not adequate when the printed result fails a sanity check.\n\nThere are lesser issues too. Lemma 3 is also deferred to [16], and Section 5.3 concedes that non-22 partitions influence overall accuracy, so the sufficiency claim for 22-only bounds is non-obvious. The computational-cost advantage is asserted but not demonstrated; the benchmark shows RAR-E requiring more effort for the structure-preserving step. And there is a single example without code or data.\n\nThat said, the framework is clearly thought out, the writing is careful, and the idea is worth pursuing. This is not a circular argument or a fitted result; the error bounds are user-chosen weights, and the benchmark is legitimate. I would send this to a serious referee with a request to fix Theorem 1 and provide the full proof. As is, I would not cite the guarantee.","headline":"Nice framework, but Theorem 1's error formula fails a zero-error sanity check, so the central guarantee is not supported as written.","tokens_in":28940,"tokens_out":7741,"would_cite":false,"duration_ms":62167,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["93B11","93A15","93B36","93C05"],"pacs":[],"model":"deepseek-v4-flash","headline":"Per-subsystem H-infinity error bounds, fixed a priori, guarantee the reduced interconnected model is stable and accurate; the environment-abstraction variant cuts a wafer-stage model to 128 states where an existing method needs 156.","keywords":["model order reduction","interconnected systems","abstracted environment","structure-preserving reduction","robust performance analysis","H-infinity error bounds","balanced truncation","wafer stage benchmark"],"falsifier":"Construct a small interconnected system (two or three subsystems) and produce reduced subsystems that satisfy the computed weighted bounds on the 22-partition errors while deliberately making the non-22 partitions of the reduction and abstraction errors large, for instance by perturbing only those blocks. If the resulting interconnected error $\\Lambda_C$ violates the prescribed specification even though the scaling inequality (42) holds with the claimed scalings, the 22-only sufficiency claim of Theorem 3 would be refuted; the same test would also expose whether Lemma 3's deferred proof, taken from reference [16], fails to cover the multi-subsystem case.","tokens_in":27942,"feed_emoji":"⚙️","tokens_out":13425,"duration_ms":106227,"temperature":0.7,"pith_summary":"The paper extends structure-preserving model reduction from reducing one subsystem against the full system to reducing every subsystem of an interconnected system, each against a cheap low-order stand-in for its environment. The central claim is that a user-specified accuracy bound on the reduced interconnected model can be converted, a priori, into weighted H-infinity bounds on the abstraction and reduction errors of each individual step; any abstraction and reduction that meet those low-level bounds automatically yield a well-posed, internally stable reduced interconnection whose error satisfies the high-level bound. Two variants are analysed: abstracting each environment as a whole (RAR-E) and abstracting the other subsystems one by one and interconnecting the abstractions (RAR-Sigma). On a 300-state wafer-stage benchmark, RAR-E produces a 128-state interconnected model while the prior robust subsystem reduction method needs 156 states for equal-or-worse accuracy; RAR-Sigma reaches 178 states yet yields the most accurate reduced model.","feed_headline":"Abstracted environments shrink a 300-state interconnected model to 128","feed_subtitle":"Reducing each subsystem against a low-order stand-in for its surroundings keeps accuracy and stability guarantees.","key_machinery":"The load-bearing identity is Lemma 3, equation (16): $\\hat{\\Sigma}_B = F_u\\left(\\begin{bmatrix} -\\breve{E}_{B,22} & I \\\\ I & 0 \\end{bmatrix}, \\Sigma_B(I - \\breve{E}_{B,22}\\Sigma_B)^{-1} + (G_y)^{-1}\\Lambda_{F,22}(G_u)^{-1}\\right)$, which states that the full diagonal of reduced subsystems is exactly reconstructible from the full-order subsystems, the $22$-blocks of the abstracted environments, and the $22$-partition reduction errors alone, with all other partitions dropping out of the expression. Theorems 1 and 2 then pull the abstraction errors out of the abstracted environment blocks to write $\\Lambda_C$ as an upper LFT of the connection matrix $N_E$ (environment abstraction) or $N_\\Sigma$ (subsystem abstraction) against a block-diagonal error operator in which each abstraction error appears in its $22$-block form, each reduction error appears weighted as $(G_y)^{-1}\\Lambda_{F,22}(G_u)^{-1}$, and the whole loop closes around the interconnection $S$. Theorem 3 converts this structure into a sufficient condition of robust-performance type: a frequency-wise scaling inequality $(VNW)(i\\omega) D_r (VNW)^H(i\\omega) \\preceq D_l$ with structured scaling pairs $(D_l, D_r)$ drawn from the sets $\\mathbb{D}_E$ or $\\mathbb{D}_\\Sigma$, which are defined through permutation matrices that sort the error blocks and frequency-wise positive-definite Hermitian blocks. The user-supplied weighting matrices $V$, $W$ and the gains $G_u$, $G_y$ tune how accuracy is distributed among the $22$-blocks and the rest of each subsystem.","core_discovery":"The paper's central discovery is an exact error identity. The authors show that the diagonal of reduced subsystems $\\hat{\\Sigma}_B$ can be rewritten as an upper linear-fractional transformation whose perturbation depends on the unreduced subsystems, the $22$-blocks of the abstracted environments, and only the $22$-block partition of each subsystem's reduction error $\\Lambda_F$ (Lemma 3). Pulling the abstraction errors out as well, the total interconnected error $\\Lambda_C = F_l(S,\\hat{\\Sigma}_B) - F_l(S,\\Sigma_B)$ becomes an upper LFT of a fixed connection matrix $N_E$ or $N_\\Sigma$, built from the interconnection $S$, the unreduced subsystems, and the abstracted environment blocks, against a block-diagonal collection of the low-level abstraction errors $\\Lambda_{E,22}$ or $\\Lambda_A$ and weighted reduction errors $\\tilde{\\Lambda}_F$. This makes $\\Lambda_C$ a structured feedback loop of small errors, so robust-performance theory applies: if each low-level error meets its weighted $\\mathcal{H}_\\infty$ bound and a scaling matrix pair $(D_l, D_r)$ satisfies $(VNW)(i\\omega) D_r (VNW)^H(i\\omega) \\preceq D_l$ for all real $\\omega$, then the reduced interconnection is stable and $\\Lambda_C$ meets the prescribed weighted bound (Theorem 3). An accompanying optimization (Theorem 4) finds the most lenient low-level bounds that still guarantee the high-level specification, turning order selection from trial-and-error into a systematic procedure.","pith_inferences":["Because the error identity only involves the $22$-partitions, the method's conservatism should grow with the strength of cross-coupling between subsystems; a sweep over coupling stiffness on the wafer-stage model would map where the abstraction step pays off and where the bounds become the bottleneck.","The paper's comparison implies that choosing the weighting functions $V$ and $W$ is the dominant source of conservatism; an automated, per-frequency weight design, of the kind the authors test in Section 6.3, would likely bring RAR-$\\Sigma$'s required order close to RAR-$E$'s.","RAR-$\\Sigma$'s modularity suits early design stages, where only rough subsystem models exist; using each newly computed reduced model as the abstraction for the next subsystem, which the paper notes is possible, should further reduce order and is a cheap iterative extension to test.","The a priori guarantee is only sufficient, not necessary; on systems where the $22$-block errors dominate, the reduced orders computed by Algorithms 3 and 4 may be far from the minimal orders that actually meet the specification, so a post-hoc check of the realized errors could unlock further reduction."],"forward_implications":["Order selection becomes systematic: Algorithms 3 and 4 first solve the scaling optimization to obtain the most lenient low-level error bounds, then reduce each environment and subsystem to the lowest order meeting its bound, so no trial and error is needed.","The reduced model is still an interconnection of individually reduced subsystems, so the modular structure is preserved and each design team can keep its own subsystem model.","The expensive structure-preserving reduction is applied to each subsystem against an abstracted environment of much lower order than the full interconnection (in the benchmark, orders 26 to 116 instead of 200), which is what makes the method tractable for large assemblies.","On the wafer-stage benchmark, the environment-abstraction variant RAR-E attains a 128-state reduced interconnected model, 28 states smaller than the 156-state model of the existing robust subsystem reduction method, with equal or better accuracy; the subsystem-abstraction variant RAR-Sigma is the most accurate but the largest at 178 states.","Stability and the prescribed accuracy specification hold by construction: any abstraction and reduction meeting the computed low-level bounds yield a well-posed, internally stable reduced model with $\\Lambda_C$ inside the prescribed set."],"supporting_citations":[{"why":"The authors' earlier single-subsystem abstracted reduction framework; it supplies Lemma 2 (deferred proof) on which Lemma 3 of this paper builds, and the proof pattern for Theorems 1-3.","marker":"[16]"},{"why":"The robust subsystem reduction (RSS) method and its top-down optimization; it is the benchmark method in Section 6 and the source of the iterative scaling-solving approach used in Theorem 4.","marker":"[18]"},{"why":"Zhou and Doyle's robust control text; it provides the LFT definitions, well-posedness criteria, and the robust-performance results underlying Theorem 3.","marker":"[19]"},{"why":"The robust-performance translation of high-level to low-level error specifications in modular model reduction; the paper adapts this technique to the abstracted-reduction setting.","marker":"[9]"},{"why":"Sandberg and Murray's interconnected-systems balanced truncation (ISBT); it is the structure-preserving reduction method applied to each subsystem in the numerical evaluation.","marker":"[4]"},{"why":"Enns' frequency-weighted balanced truncation; it is the open-loop reduction method used to generate the environment and subsystem abstractions.","marker":"[27]"}],"fun_headline_variants":["Abstracted environments enable efficient model reduction with guarantees","Stand-in environments cut costs while preserving stability and error bounds","Reduce interconnected models faster by abstracting their environment","Exact error bounds for reduced interconnected systems via abstraction","Abstraction reduces a 300-state model to 128 with guarantees"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The guarantee rests on the assertion, proved in the authors' earlier paper rather than here, that the reduced subsystems can be reconstructed from the unreduced subsystems, the abstracted-environment 22-blocks, and only the 22-partition reduction errors; the paper itself notes that the accuracy of other partitions also influences the overall error, so this 22-only sufficiency claim carries the whole result.","fun_headline_variants_meta":{"raw":{"variants":["Abstracted environments enable efficient model reduction with guarantees","Stand-in environments cut costs while preserving stability and error bounds","Reduce interconnected models faster by abstracting their environment","Exact error bounds for reduced interconnected systems via abstraction","Abstraction reduces a 300-state model to 128 with guarantees"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.00095,"raw_usage":{"total_tokens":4123,"prompt_tokens":1083,"completion_tokens":3040,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":699,"completion_tokens_details":{"reasoning_tokens":2975}},"tokens_in":699,"tokens_out":3040,"duration_ms":20018,"temperature":1.0,"reasoning_tokens":2975,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T18:20:22.067288+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Construct a small interconnected system (two or three subsystems) and produce reduced subsystems that satisfy the computed weighted bounds on the 22-partition errors while deliberately making the non-22 partitions of the reduction and abstraction errors large, for instance by perturbing only those blocks. If the resulting interconnected error $\\Lambda_C$ violates the prescribed specification even though the scaling inequality (42) holds with the claimed scalings, the 22-only sufficiency claim of Theorem 3 would be refuted; the same test would also expose whether Lemma 3's deferred proof, taken from reference [16], fails to cover the multi-subsystem case.","supporting_citations":[{"cited_title":"Abstracted Model Reduction: A General Framework for Efficient Interconnected System Reduction","cited_arxiv_id":"2411.13344","evidence_quote":"The authors' earlier single-subsystem abstracted reduction framework; it supplies Lemma 2 (deferred proof) on which Lemma 3 of this paper builds, and the proof pattern for Theorems 1-3."},{"cited_title":"ModularModelReductionofInterconnectedSystems:ATop-Down Approach,","cited_arxiv_id":null,"evidence_quote":"The robust subsystem reduction (RSS) method and its top-down optimization; it is the benchmark method in Section 6 and the source of the iterative scaling-solving approach used in Theorem 4."},{"cited_title":"Zhou and J","cited_arxiv_id":null,"evidence_quote":"Zhou and Doyle's robust control text; it provides the LFT definitions, well-posedness criteria, and the robust-performance results underlying Theorem 3."},{"cited_title":"Modular model reduction of interconnected systems: A robust per- formance analysis perspective,","cited_arxiv_id":null,"evidence_quote":"The robust-performance translation of high-level to low-level error specifications in modular model reduction; the paper adapts this technique to the abstracted-reduction setting."},{"cited_title":"Model reduction of interconnected linear systems,","cited_arxiv_id":null,"evidence_quote":"Sandberg and Murray's interconnected-systems balanced truncation (ISBT); it is the structure-preserving reduction method applied to each subsystem in the numerical evaluation."},{"cited_title":"Model Reduction with Balanced Realizations: an Error BoundandaFrequencyWeightedGeneralization,","cited_arxiv_id":null,"evidence_quote":"Enns' frequency-weighted balanced truncation; it is the open-loop reduction method used to generate the environment and subsystem abstractions."}],"review_version":1}