{"id":"cb0c25b5-60ef-422a-9108-12dad0a06849","arxiv_id":"2504.17861","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"Conjugate-gradient-type iterative methods are formulated directly for T-product tensor equations, with finite-termination proofs and numerical demonstrations.","lead":"This paper rewrites the classical conjugate gradient method so it can solve tensor equations that use the T-product without ever forming large block matrices. The algorithms are proven to stop in a finite, dimension-dependent number of steps, and they are demonstrated on small random tensors and on image and video examples.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The finite-termination guarantees for Algorithms 3 and 4 depend on exact orthogonality that floating-point arithmetic destroys; without reorthogonalization or error analysis, the stated iteration bounds and minimal-norm claims are not guaranteed in practice.","rationale":"The reader's weakest assumption identifies exactly the load-bearing issue: the finite-termination and minimal-norm theorems are exact-arithmetic results. My own check of the algebra confirms that the orthogonality recurrences are valid in exact arithmetic, so I do not see an internal inconsistency in the mathematical core. The serious practical gap is that the algorithms as written use short recurrences and no reorthogonalization, so rounding errors can destroy the orthogonality on which the advertised iteration bounds depend. This is not a disagreement with consensus; it is a correctness risk for the implemented method. The paper's numerical examples are too small and too well-conditioned (random Gaussian C, exact right-hand sides) to expose the issue. The off-by-one discrepancy between Theorem 4.4's n1*l*n3+1 and Theorem 5.4's n2*l*n3 is minor and easily repaired; the proof of Theorem 4.6 is informal but the minimal-norm claim can be justified through the Fourier domain. Neither changes the main conditional verdict. I therefore recommend keeping the reader's CONDITIONAL verdict unchanged.","tokens_in":16400,"tokens_out":17305,"duration_ms":171523,"concrete_test":"Implement Algorithms 3 and 4 in IEEE double precision using a T-product routine, and run a consistent test with n1=n2=20, l=1, n3=5, where C is constructed with exponentially decaying singular values (condition number about 1e8) and D = C⋆Xtrue. Record the iteration count needed to reach ||R_k||_F <= 1e-10 * ||D||_F and compare it with the theorem bounds n1*l*n3+1 and n2*l*n3. If the count exceeds the bound, or if Algorithm 4's solution differs from the pinv-based minimal-norm least-squares solution by more than a few digits, the practical claim fails. As a control, rerun the same experiment with full reorthogonalization of Q against all previous Q directions; if the bound is restored, lost orthogonality is the cause.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central mathematical proofs (Lemma 4.3, Theorem 4.4, Theorem 5.4) are exact-arithmetic arguments: they show that the residual tensors R_k are mutually orthogonal and the search directions Q_k are mutually orthogonal, and then conclude by dimension counting that R_{n1*l*n3+1} must be zero. The orthogonality is derived from the exact recurrences R_k = D - C⋆X_k and Q_k = P_k - (Tr(P_k^T⋆Q_{k-1})/||Q_{k-1}||^2)Q_{k-1} in Algorithm 3, step 5. In floating-point arithmetic, the computed R_k is not exactly R_{k-1} - alpha_{k-1} C⋆Q_{k-1}, the computed T-product and inner products are rounded, and the short recurrence does not preserve global orthogonality against all previous directions. No reorthogonalization is performed, and no rounding-error analysis is provided. Therefore the claimed upper bounds on iteration counts, and the minimal-Frobenius-norm conclusion that relies on exact termination at R_{M+1}=0, are not guaranteed by the implemented algorithms. Since the abstract and Section 6 present the methods as practical solvers with negligible errors, this gap is load-bearing for the practical claim, even though the exact-arithmetic mathematics appears internally sound.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper develops three iterative algorithms for tensor equations under the T-product. Algorithm 2 is a conjugate-gradient-type method for C*X=D when C is T-symmetric positive definite; Algorithm 3 treats consistent equations C*X=D with rectangular C by a CGNR-type process using residuals R_k=D-C*X_k and search directions generated from C^T*R_k; Algorithm 4 applies the same construction to the normal equation C^T*C*X=C^T*D to obtain least-squares solutions. The main formal claims are that Algorithm 3 terminates in at most n1*l*n3+1 iterations with the exact solution, that Algorithm 4 terminates in at most n2*l*n3 iterations with a least-squares solution, and that with X1=0 the computed solutions have minimal Frobenius norm. Numerical experiments on random synthetic tensors and on image/video recovery illustrate the residual decay.","tokens_in":16680,"tokens_out":17619,"duration_ms":164137,"significance":"Read as exact-arithmetic statements, the convergence and minimal-norm results are coherent, and the tensor formulation is convenient because the algorithms avoid explicit construction of bcirc matrices and can be implemented with the FFT-based T-product. The extension of classical CG/CGNR to the T-product is natural, the proofs are self-contained, and the paper gives explicit finite-termination bounds that are useful for this problem class. A manual consistency check of the recurrences on a small system indicates that Algorithm 3 behaves as stated in exact arithmetic. The novelty is incremental, and no reproducibility artifact or comparison with existing T-product solvers is provided, but the paper's central exact-arithmetic claims are defensible. The main substantive weakness is that the practical claims of finite termination with negligible errors are stated without any treatment of floating-point effects, so the theorems should be read as exact-arithmetic results rather than as unconditional statements about the implemented algorithms.","major_comments":[{"comment":"The termination and minimal-norm guarantees are exact-arithmetic statements. The recurrences in Algorithm 3, step 5, and Algorithm 4, step 5, are used to prove <R_i,R_j>=0 and <Q_i,Q_j>=0 in Lemma 4.3; in floating-point arithmetic these identities are destroyed by rounding in the T-product, the inner products, and the short recurrences, and no reorthogonalization or rounding-error analysis is supplied. Consequently the asserted iteration bounds (n1*l*n3+1 and n2*l*n3) and the minimal-norm conclusion that relies on exact termination at a zero residual are not guaranteed by the implemented algorithms. Because the abstract and Section 6 present the methods as practical solvers with 'negligible errors,' this gap is load-bearing; either add a stability or rounding-error discussion, or explicitly qualify the theorems as exact-arithmetic results and soften the practical claim.","section":"Theorems 4.4 and 5.4; Algorithms 3 and 4; Section 6"},{"comment":"The proof of minimal Frobenius norm relies on the equivalence C*X=D  <=>  C.X=D  <=>  (I_{l.n3} (x) C) vec(X) = vec(D). For the T-product, the correct linear representation is bcirc(C) unfold(X) = unfold(D) in the original domain, or bdiag(C_hat) X_hat = D_hat in the Fourier domain; it is not simply (I_{l.n3} (x) C) vec(X) as written, unless substantial additional notation is introduced. As written, the range argument for the adjoint is therefore not established. The result itself is true: starting from X1=0, all iterates lie in the range of Y -> C^T*Y, and the solution in that range has minimal Frobenius norm. Please replace the proof with a correct argument.","section":"Theorem 4.6, Eqs. (4.6)-(4.7)"}],"minor_comments":[{"comment":"The abstract contains the typo 'demonste' for 'demonstrate,' and the text has numerous other typos, including 'tensot,' 'researchears,' 'uder,' and 'edequate'; the manuscript should be carefully proofread.","section":"Abstract and throughout"},{"comment":"In the proof, the displayed expression for Tr[(f(Y)-f(X))^{(1)}] has an extra factor 1/2 in front of the first term; the following line drops the factor, so the conclusion is correct but the displayed equation should be fixed.","section":"Lemma 3.3"},{"comment":"In the proof, the expression 'Tr((P_{k+1} * A * P_k)(1)) = 0' uses an undefined tensor A; it should presumably be the C-orthogonality statement Tr((P_{k+1}^T * C * P_k)(1)) = 0.","section":"Theorem 3.4"},{"comment":"Algorithm 2 is not given an explicit finite-termination theorem, although the same dimension argument used in Theorem 4.4 applies; stating this theorem would make the abstract's 'finite number of iterations' claim complete for all three algorithms.","section":"Section 3"},{"comment":"The proof is only one sentence referring to Theorems 4.4 and 4.6; because the normal-equations operator C^T*C can be semidefinite in the rank-deficient case, the proof should include a short explanation of why the dimension count and the minimal-norm argument remain valid.","section":"Theorem 5.4"}],"recommendation":"major_revision","confidential_remarks":"The paper is a modest incremental extension of classical Krylov methods to T-product tensor equations. The exact-arithmetic statements are defensible, but the practical claims ('negligible errors,' 'efficient') are stronger than the evidence; the absence of a rounding-error analysis and the lack of comparison with existing T-product solvers should be addressed before publication. The scope fits math.NA."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Malihe, here's my read on arXiv:2504.17861. The core is straightforward: the authors take classical CG, CGNE, and CGLS and rewrite them for third-order tensors with the T-product. The finite-termination proofs follow the standard orthogonal-residual arguments, and they look correct in exact arithmetic. I did a quick check of Algorithm 3 on a small consistent system and it terminated as advertised. So the mathematical core is sound, and what is genuinely new is the packaging: explicit tensor-form algorithms with convergence proofs, rather than just saying 'apply FFT and run a matrix solver.' The paper is self-contained and the preliminaries are clearly laid out. That's worth something.\n\nNow the soft spots. The biggest overclaim is in Section 6. Example 6.3 degrades images with a random Gaussian tensor C, then recovers the original by solving C⋆X = Xdeg. That is just solving a linear system with a known operator—it is not image restoration in any meaningful sense, and the PSNR numbers are high precisely because the problem is noiseless and consistent. There are no baselines, no noisy degradation, no comparison with the direct FFT-based solver. The paper presents this as 'practicality and effectiveness,' but it demonstrates nothing beyond that the algorithms converge on exact data. The exact-arithmetic termination bounds should also come with a caveat: in floating point, orthogonality is lost and the iteration counts are not guaranteed. That is not a fatal flaw—the algorithms still converge in practice, as the examples show—but the abstract's 'with negligible errors' is too strong without a rounding-error analysis. There are also a handful of typos (e.g., 'A' instead of 'C' in the proof of Theorem 3.4, and a stray 1/2 in Lemma 3.3's proof). Nothing load-bearing, but they should be cleaned up.\n\nNovelty is modest. Since the T-product is unitarily equivalent to block-circulant matrix multiplication, these algorithms are mathematically the same as applying classical CG-type methods to an equivalent linear system. The authors' own prior work [20] already covers Krylov subspace methods for the T-product, so the extension is incremental. But incremental can still be useful for a niche audience.\n\nShould you engage? If you work on tensor equations under the T-product, it is worth a skim. It is not a deep theoretical advance, but it is a clean, correct exposition of standard methods in a tensor idiom. I would send it to peer review with a request for major revision: tone down the practical claims, add a real comparison (at least against the direct solver), provide code or reproducible data, and add a sentence acknowledging the exact-arithmetic limitation. Recommended: referee it if it lands on your desk, but do not hold your breath for new insight.","headline":"A competent but unsurprising translation of CG/CGNE/CGLS to the T-product tensor setting, with standard exact-arithmetic proofs, overshadowed by an overclaimed image-restoration experiment.","tokens_in":17189,"tokens_out":1957,"would_cite":false,"duration_ms":21796,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["15A69","65F10"],"pacs":[],"model":"deepseek-v4-flash","headline":"For $C\\star X=D$ under the T-product, tensor-only iterative updates reach an exact solution in at most $n_1\\ell n_3+1$ steps, and least-squares problems in at most $n_2\\ell n_3$ steps.","keywords":["T-product","tensor equation","iterative algorithm","least-squares solution","minimal Frobenius norm","orthogonal tensor sequence","finite termination","image restoration"],"falsifier":"Run Algorithm 3 in exact rational arithmetic on a small generic consistent equation, for example $n_1=n_2=n_3=2$, $\\ell=1$, with $D$ constructed as $C\\star X^*$ for a known $X^*$, and check whether the residual after $n_1\\ell n_3+1=5$ steps is exactly zero for a nonzero starting tensor; any nonzero exact residual would disprove the finite-termination theorem. For the least-squares claim, run Algorithm 4 with $X_1=O$ in the same exact setting and verify by an independent calculation that the returned tensor minimizes $\\|C\\star X-D\\|_F$ and is the unique minimal-norm minimizer.","tokens_in":16221,"feed_emoji":"🧮","tokens_out":15217,"duration_ms":124716,"temperature":0.7,"pith_summary":"This paper is about solving tensor equations of the form $C\\star X=D$, where $\\star$ is the T-product, a tensor multiplication defined by block-circulant convolution along the third dimension. The authors propose iterative algorithms that work directly on tensors, never forming the large block-circulant matrix, and they claim each algorithm stops in a provably finite number of iterations in exact arithmetic: at most $n_1\\ell n_3+1$ steps for a consistent equation, and at most $n_2\\ell n_3$ steps for the least-squares problem $\\min_X \\|C\\star X-D\\|_F$. The practical payoff would be a memory-lean, predictable solver for tensor systems arising in image and video restoration, where starting from the zero tensor automatically selects the minimal Frobenius norm solution. The arguments turn on orthogonality: the generated residuals are mutually orthogonal, and the search directions are mutually orthogonal under the T-product inner product, so the residual sequence cannot continue beyond the dimension of the tensor space.","feed_headline":"T-product tensor equations solved in a bounded number of steps","feed_subtitle":"Iterative solvers finish T-product tensor equations in finitely many steps, with minimal-norm least squares.","key_machinery":"The load-bearing object is the T-product together with its Fourier-diagonalization identity: after applying fft along the third dimension, $C\\star D$ is computed slicewise as $\\widehat C^{(i)}\\widehat D^{(i)}$, so iterations can be coded directly on tensors. The algorithmic core is the direction-update recurrence $X_k=X_{k-1}+\\frac{\\|R_{k-1}\\|^2}{\\|Q_{k-1}\\|^2}Q_{k-1}$, with $R_k=D-C\\star X_k$, $P_k=C^T\\star R_k$, and $Q_k=P_k-\\frac{\\langle P_k,Q_{k-1}\\rangle}{\\|Q_{k-1}\\|^2}Q_{k-1}$. The inner-product identity $\\langle C,D\\rangle=\\operatorname{Tr}((D^T\\star C)^{(1)})$ translates every orthogonality statement into a trace condition, allowing the proofs to run in tensor arithmetic; the same recurrence, applied to the normal equation, gives the least-squares variant.","core_discovery":"The central claim is that direction-update tensor recurrences terminate exactly: for a consistent equation $C\\star X=D$ with $C\\in\\mathbb{R}^{n_1\\times n_2\\times n_3}$, Algorithm 3 returns an exact solution in at most $n_1\\ell n_3+1$ steps from any initial tensor, and for the possibly inconsistent case Algorithm 4 returns a least-squares solution of $\\min_X\\|C\\star X-D\\|_F$ in at most $n_2\\ell n_3$ steps. The mechanism is a dimension argument: the residual tensors $R_k$ are mutually orthogonal in the T-product inner product, and the search directions $Q_k$ are likewise orthogonal, so within a space of dimension $n_1\\ell n_3$ one residual must vanish; in the least-squares case the same argument runs on the normal equation $C^T\\star C\\star X=C^T\\star D$. Choosing $X_1=C^T\\star H$, in particular $X_1=O$, forces the returned solution into the range of $C^T$, which the paper proves is exactly the minimal Frobenius norm solution, and a residual with $Q_k=O$ signals inconsistency.","pith_inferences":["Beyond the paper, the termination bound is essentially a dimension count, so the same recurrence should transfer to other tensor products whenever a compatible transpose and trace inner product exist; the iteration limit would be the dimension of the corresponding solution space.","Beyond the paper, the reported experiments use random Gaussian coefficient tensors, which are typically well-conditioned; the natural stress test not included is to run Algorithm 4 on severely ill-conditioned or structured coefficient tensors and measure how far the floating-point residual deviates from the exact-arithmetic bound.","Beyond the paper, the minimal-norm guarantee suggests a direct method for the T-product pseudoinverse: apply Algorithm 4 with $X_1=O$ to $C\\star X=I$ for multiple right-hand sides and assemble the returned slices; the same finite-termination bound would apply."],"forward_implications":["Consistent T-product systems inherit a hard iteration bound: from any starting tensor the residual is exactly zero after at most $n_1\\ell n_3+1$ updates, so a solvable system cannot make the solver loop indefinitely.","Because the algorithms never form the equivalent block-circulant or Kronecker matrices, per-iteration storage stays at the size of the tensors themselves, and the dominant cost is a handful of fft-based T-products per step.","Starting from the zero tensor automatically returns the minimal Frobenius norm solution of a consistent equation and the minimal-norm least-squares solution of an inconsistent one, giving a deterministic route to a pseudoinverse-type tensor solution.","Algorithm 4 also covers the consistent case, since any exact solution minimizes the residual; a single implementation therefore handles both solvable and unsolvable systems, with the condition $R_k\\neq O$, $Q_k=O$ marking inconsistency."],"supporting_citations":[{"why":"introduces the T-product that the tensor equations in this paper are written in.","marker":"[12]"},{"why":"supplies the fft diagonalization identity used to compute each T-product in the iterations.","marker":"[16]"},{"why":"presents iterative algorithms for tensor equations under another tensor product, the template adapted here.","marker":"[25]"},{"why":"defines the tensor transpose and the identity used to form normal equations.","marker":"[5]"},{"why":"gives the associativity and distributivity laws for the T-product that the algebra depends on.","marker":"[11]"},{"why":"earlier iterative solvers for T-product tensor equations that this work extends with explicit termination bounds.","marker":"[20]"}],"fun_headline_variants":["T-product equations solved exactly or least-squares in finite steps","Finite-step solvers for T-product tensor equations","Bounded-step iterative solution for T-product equations","Tensor T-product solved exactly or least-squares in finite steps","Finite-step tensor solvers give minimal-norm least squares"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The iteration counts and minimal-norm conclusions assume exact arithmetic, because the proofs require the residual and search-direction tensors to be exactly orthogonal; with floating-point arithmetic those orthogonalities are lost to rounding, so the stated guarantees are only approximate and the paper gives no rounding-error analysis.","fun_headline_variants_meta":{"raw":{"variants":["T-product equations solved exactly or least-squares in finite steps","Finite-step solvers for T-product tensor equations","Bounded-step iterative solution for T-product equations","Tensor T-product solved exactly or least-squares in finite steps","Finite-step tensor solvers give minimal-norm least squares"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000721,"raw_usage":{"total_tokens":3183,"prompt_tokens":838,"completion_tokens":2345,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":454,"completion_tokens_details":{"reasoning_tokens":2264}},"tokens_in":454,"tokens_out":2345,"duration_ms":13780,"temperature":1.0,"reasoning_tokens":2264,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-16T10:32:12.221652+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run Algorithm 3 in exact rational arithmetic on a small generic consistent equation, for example $n_1=n_2=n_3=2$, $\\ell=1$, with $D$ constructed as $C\\star X^*$ for a known $X^*$, and check whether the residual after $n_1\\ell n_3+1=5$ steps is exactly zero for a nonzero starting tensor; any nonzero exact residual would disprove the finite-termination theorem. For the least-squares claim, run Algorithm 4 with $X_1=O$ in the same exact setting and verify by an independent calculation that the returned tensor minimizes $\\|C\\star X-D\\|_F$ and is the unique minimal-norm minimizer.","supporting_citations":[{"cited_title":"E., Braman, K., Hao, N., Hoover, R","cited_arxiv_id":null,"evidence_quote":"introduces the T-product that the tensor equations in this paper are written in."},{"cited_title":"W., Xu, X., Iterative algorithms for solving some tensor equations","cited_arxiv_id":null,"evidence_quote":"presents iterative algorithms for tensor equations under another tensor product, the template adapted here."},{"cited_title":"T product Tensors Part I: Inequalities","cited_arxiv_id":"2107.06285","evidence_quote":"defines the tensor transpose and the identity used to form normal equations."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"gives the associativity and distributivity laws for the T-product that the algebra depends on."},{"cited_title":"Computational and Applied Mathematics, 42(8), 358 (2023)","cited_arxiv_id":null,"evidence_quote":"earlier iterative solvers for T-product tensor equations that this work extends with explicit termination bounds."}],"review_version":1}