{"id":"5c1490b7-eb7e-4cab-9b8e-56aca5b3f6a2","arxiv_id":"2411.14287","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"An explicit algorithm constructs strict sign regular matrices of every size and every sign pattern, together with insertion and border-extension theorems.","lead":"The paper gives a recipe for building strictly sign regular matrices of any size with any prescribed sign pattern, and shows such a matrix can be extended by adding a row or column at any border or between any two existing lines. A smart generalist might care because these matrices appear throughout analysis, combinatorics and statistics, and until now explicit examples were hard to produce.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Theorem 2.7 omits the cancellation bound for the odd-l perturbation case, leaving the rectangular border-extension proof incomplete; the gap is repairable with the λ_k, Λ_k bound already defined.","rationale":"The paper's central claim is an explicit construction of SSR matrices of every size and sign pattern, and the construction depends on Theorem A, whose rectangular-case proof relies on Theorem 2.7. The reader's weakest-assumption analysis correctly identified the missing cancellation bound for the odd-l case in Theorem 2.7. My stress-test confirms that this is the most load-bearing mathematical gap: without the omitted inequality, the perturbation induction does not prove that all r×r minors retain the correct sign. The gap is localized and repairable using the λ_k, Λ_k already introduced, so it does not overturn the construction; it does require a proof repair. I also checked the main SSR construction path in Algorithm 3 and found it sound for min(m,n) ≥ 2: the square-building loop uses add_col_left only on matrices that are genuinely SSR, add_perturbation correctly uses leading principal minors because any contiguous minor containing (1,1) is leading, and the final rectangular extension only adds columns to a square SSR matrix. The one-dimensional orientation bug in the Python code and the separate issue in Algorithm 4's repeated SSRp extension do not affect the central SSR construction, though they should be noted. Since the reader already conditioned the verdict on the same proof repair, my assessment does not move the verdict.","tokens_in":18781,"tokens_out":50298,"duration_ms":456388,"concrete_test":"Independently re-derive the omitted odd-l case in Theorem 2.7 by substituting l odd into the displayed determinant formula and using |det(Â^{δ_{k−1}})_{I×[r]}| ≥ λ_k and |det(A_k)_{I×[r]}| ≤ Λ_k. Verify that ǫ_r det(Â^{δ_k})_{I×[r]} ≥ λ_k − δ_kΛ_k > 0 whenever ǫ_{r−1} ≠ ǫ_r. If the inequality follows from the defined λ_k, Λ_k, then Theorem 2.7 is complete after inserting this bound; if not, Theorem A's rectangular case requires a new argument.","verdict_should_be":"UNCHANGED","load_bearing_attack":"For the central Theorem A construction in the rectangular case m > n, Theorem 2.7 perturbs the first m−n entries of the new column one at a time and must show that every r×r contiguous minor containing that entry keeps its required sign. The proof writes the determinant after the δ_k perturbation as det(Â^{δ_k})_{I×[r]} = det(Â^{δ_{k−1}})_{I×[r]} ± δ_k det(Â^{δ_{k−1}})_{I∖{i_l}×[r]∖{1}} depending on whether the perturbed row appears at odd or even position l. It then gives a λ_k − δ_kΛ_k lower bound only for even l, saying that odd l follows by a similar argument. That omission is load-bearing: when l is odd and ǫ_{r−1} ≠ ǫ_r, the δ_k-term has the opposite sign from the existing minor, so sign preservation is not automatic. The needed inequality is ǫ_r det(Â^{δ_k})_{I×[r]} ≥ λ_k − δ_kΛ_k > 0, using the same λ_k, Λ_k as the even-l case. Without this bound, Theorem 2.7 is incomplete, and therefore Theorem A for rectangular border extension is not fully established. The gap appears repairable, but it must be written out for the proof to be rigorous.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes an explicit construction of strictly sign regular matrices of arbitrary size and sign pattern. The main tool is a border-extension theorem (Theorem A): every SSR matrix can be bordered by a new row or column while remaining SSR, with control over the sign of any newly appearing larger minors. A second theorem (Theorem B) inserts a line between two consecutive lines of an SSR matrix. The proofs in Section 2 choose the new line as an alternating linear combination of existing lines with sufficiently large positive coefficients, and in the rectangular case perturb the first entries of the new column to make the larger minors nonzero with the desired sign. Section 3 handles middle insertions by completing the matrix to an even square, and Section 4 converts the constructions into Algorithms 1-4 with Python code in Appendix A.","tokens_in":19041,"tokens_out":55450,"duration_ms":511384,"significance":"If the identified gaps are repaired, the paper gives the first fully constructive algorithm for SSR matrices of every size and sign pattern, answering a natural question left open by the classical existence results of Gantmacher-Krein. The reduction to Karlin's contiguous-minor criterion is appropriate, and the coefficient choices are finite and computable. The extension and insertion theorems are also of independent interest for generating test matrices in total positivity and variation-diminishing applications. The proofs use Karlin's theorem, Cramer's rule, and determinant identities, and no circular dependence on the paper's own earlier results was found. However, the computational appendix is not yet a reliable implementation of the stated algorithms, and one case in the proof of Theorem 2.7 is left implicit.","major_comments":[{"comment":"The proof of sign preservation for r x r minors containing the kth row and first column is incomplete for odd l. In the displayed expansion, when l is odd the delta_k term is added with coefficient det(Â^{δ_{k−1}})_{I\\{i_l}×[r]\\{1}}; after the identity for that minor, the delta_k contribution has sign ε_{r−1}. If ε_{r−1}=ε_r there is nothing to prove, but if ε_{r−1}≠ε_r the two terms are opposite and one must use the bound ε_r det(Â^{δ_k})_{I×[r]} ≥ λ_k − δ_kΛ_k > 0. The text writes this bound only for even l and says the odd case is similar. Since this inequality is exactly what keeps the construction inside SSR_n(ε), it should be stated explicitly. The missing argument is short and uses the already-defined λ_k and Λ_k, so the gap is repairable.","section":"Section 2, proof of Theorem 2.7"},{"comment":"The Python code does not currently implement Algorithms 2-4 as described. In SSR_construction, the min_dim=1 branch tests `min_dim == n` and otherwise transposes, returning the wrong orientation (for example, m=1,n=3 becomes 3 x 1 and m=3,n=1 becomes 1 x 3); the test should be `min_dim == m`. In SSR_p_construction, the first loop transposes A after every call to add_col_left, so starting from p x p it does not produce a p x m matrix; for instance p=2,m=5,n=5 yields a 4 x 6 matrix rather than 5 x 5. In add_perturbation, the update of λ and Λ with the matrix B is executed only for k>1, so the modulus 1 of the 1 x 1 minor of B is omitted from Λ, and the chosen perturbation can be larger than the intended λ/Λ bound. These deviations affect the advertised reproducibility of the algorithm and should be corrected.","section":"Appendix A, Listings 4-5"}],"minor_comments":[{"comment":"The one-dimensional cases (n=1 or m=1) are not covered by Lemma 2.2 or by the rectangular perturbation argument; they should be dispatched explicitly, for example by taking a constant vector of the required sign.","section":"Section 2, Theorem A proof"},{"comment":"When m=n, the top- and bottom-row insertions are described via Theorem 2.7 applied to A^T, but Theorem 2.7 assumes rows > columns; Theorem 2.5 or Remark 2.6 should be cited for the square case.","section":"Section 2, Theorem A proof"},{"comment":"The phrase 'if ε_{r−1}=ε_r' needs a convention for ε_0, or a separate sentence for the 1 x 1 minors, since the proof uses this comparison already for r=1.","section":"Theorem 2.7, r=1 case"},{"comment":"The notation '[r]/integerdivide{1}' appears to be an OCR or typesetting corruption of set difference; the displayed determinants should be typeset as [r]\\{1} and [n+1]\\{1}.","section":"Throughout Section 2"},{"comment":"For p=1, the proposed column formula c = Σ_{i=1}^{⌈p/2⌉}(−1)^{i−1}y_i(c_{p−i}+c_{p+i−1}) refers to c_0 and is undefined; the p=1 case should be treated separately by taking any vector with the required sign.","section":"Theorem 3.2"}],"recommendation":"major_revision","confidential_remarks":"The mathematical idea is sound and the theorems are likely correct after the omitted odd-l estimate in Theorem 2.7 is supplied and the one-dimensional edge cases are addressed. The main reasons for major revision are the incomplete proof case and the fact that the Python code advertised in the abstract has several concrete bugs. I would support acceptance after these points are fixed; no issues of novelty or attribution beyond the authors' own prior work arose."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things to know. First, this paper delivers a genuinely new explicit construction: SSR matrices of any size and any sign pattern, built by border extension and interior line insertion, with an algorithm and Python code. The earlier literature had existence arguments (Gantmacher–Krein) and a totally positive-only line insertion result (Johnson–Smith), so the general sign-pattern version is a real step forward. Second, the main construction probably works, but the proof of Theorem 2.7 is not fully rigorous as written. The odd-l perturbation case is left to “a similar argument,” and that is exactly the case where the δ-term opposes the existing minor sign. The missing bound is easy to supply with the same λ_k, Λ_k argument used for even l, so the paper is repairable, but the gap is load-bearing for rectangular border extension.\n\nWhat the paper does well: the square case (Theorem 2.5) is proved cleanly by inductively choosing positive coefficients from finite lower bounds. The interior line insertion theorem (Theorem 3.1) is a genuine extension beyond the TP case, and the reduction in Theorem B is elegant. The algorithm section is clear, and shipping actual Python code is a plus, not a formality.\n\nSoft spots, in proportion to how soft they are. The Theorem 2.7 omission is real but fixable; I would not reject over it. Equation (2.3) has a harmless sign typo in the displayed formula versus the lower bound that follows it. The Appendix A code has a concrete bug in the min_dim=1 branch: it builds a 1×max_dim row and then returns the transpose when m=1, so the output dimensions are swapped for one-dimensional matrices. The SSR_p results are sketched rather than fully detailed; that is acceptable for a companion result but should be checked line by line. There are also assorted typos and OCR-style artifacts in the text.\n\nCitation pattern is fine. The self-citations in the introduction motivate the question but are not load-bearing premises, and the proofs rely on Karlin’s theorem, Cramer’s rule, and determinant identities rather than on the authors’ own earlier results.\n\nWho is this for? Anyone working with SSR matrices in analysis, splines, combinatorics, or Gabor frames who needs concrete examples. It deserves a serious referee: the central construction is novel and plausible, and the gaps are repairable. My recommendation is to send it to review with a request for a revised version that fills the odd-l cancellation bound in Theorem 2.7, fixes the sign typo, and corrects the Python code’s 1D branch.","headline":"A genuinely useful explicit construction for SSR matrices; the main theorem has a repairable gap in the rectangular border case and the Python code has a 1D orientation bug, but the core idea is sound and worth refereeing.","tokens_in":19542,"tokens_out":2201,"would_cite":true,"duration_ms":21799,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["15B48","15A83","15A15","15-04"],"pacs":[],"model":"deepseek-v4-flash","headline":"This paper proves that every strictly sign regular matrix can be extended by a new row or column on any border, and uses that fact to build an algorithm that constructs a strictly sign regular matrix of any specified size and sign pattern.","keywords":["strictly sign regular matrices","totally positive matrices","sign pattern","matrix completion","construction algorithm","contiguous minors","line insertion"],"falsifier":"Run the supplied Python implementation to produce a $4\\times 5$ SSR matrix with sign pattern $(1,1,-1,-1)$, then verify in exact arithmetic that every contiguous minor of size $1,2,3,4$ carries the claimed sign; any sign violation would refute the construction. A sharper test: take a known $3\\times 3$ SSR matrix, add a column on the right with Algorithm 1, and check that all $3\\times 3$ contiguous minors of the $3\\times 4$ result have the sign required by the given pattern.","tokens_in":18580,"feed_emoji":"🧮","tokens_out":9851,"duration_ms":84848,"temperature":0.7,"pith_summary":"A strictly sign regular (SSR) matrix is one whose subdeterminants of any fixed size are either all positive or all negative. The paper shows that any SSR matrix can be extended by adding one row or column to any of its four borders, and that a new line can also be inserted between any two existing lines, keeping the matrix SSR. It then turns this extension step into an algorithm that, given any desired dimensions and sign pattern, outputs an explicit SSR matrix, with Python code supplied. The constructive step matters because classical results guarantee such matrices exist but give no way to write one down; explicit examples are needed across applications that use total positivity and its sign-regular cousins.","feed_headline":"Matrix extension theorem yields explicit SSR matrices of any size","feed_subtitle":"A new algorithm inserts rows and columns into strictly sign regular matrices, with Python code included.","key_machinery":"The load-bearing object is the normalized new-column representation $c=\\sum_{i=1}^{r}(-1)^{i-1}y_i c_i$ with $y_i>0$, where $r=\\min(m,n)$. A lemma shows every column of an SSR matrix has such an alternating form, so the search for a valid extension reduces to choosing the positive coefficients $y_i$; the proof sets $y_n$ arbitrarily and then chooses $y_k$ one by one via finitely many explicit lower bounds (equation (2.4)) so that all $k\\times k$ contiguous minors containing the new line keep the sign $\\epsilon_k$. A standard theorem (quoted in the paper) reduces SSR to checking contiguous minors, and the exchange matrix $P_n$ transposes the construction from left border to right border and from top to bottom. For the tall case $m>n$, the additional ingredient is a perturbation of the first $m-n$ entries of the new column by amounts smaller than $\\lambda_k/\\Lambda_k$, the ratio of the smallest to the largest modulus of the relevant nonzero contiguous minors, which preserves existing signs while forcing the new larger minors to be nonzero and equisigned.","core_discovery":"The central discovery is that border extension is always possible: for an $m\\times n$ SSR matrix with sign pattern $\\epsilon$, there is a new column (or row) whose addition on any chosen side keeps the matrix SSR with the same signs for minors of existing sizes, and the sign of any newly appearing larger minors can be chosen freely. The new column is constructed in normalized form $c=\\sum_{i=1}^{\\min(m,n)}(-1)^{i-1}y_i c_i$ with all $y_i>0$, choosing $y_n,y_{n-1},\\ldots$ one at a time so that every contiguous minor containing the new line has the required sign; only finitely many lower bounds are needed at each step. In the rectangular case $m>n$, the same coefficients make the matrix SSR of order $n$, and a controlled perturbation of the first $m-n$ entries of the new column, with step sizes below the ratio of the smallest to the largest relevant minor modulus, makes all $(n+1)$-minors nonzero with the prescribed sign. The same machinery inserts a line between consecutive lines (by completing the matrix to a square even-order SSR matrix, inserting in the middle, and deleting the added lines), and the whole procedure yields Algorithms 3 and 4 for any size, sign pattern, and order $p$.","pith_inferences":["The recursive lower-bound step could be adapted to generate random SSR matrices by sampling the positive coefficients $y_i$; such a sampler would give statistically usable test sets for numerical experiments that currently rely on a handful of known examples.","Because Theorem A lets one extend on all four borders, the SSR matrices of fixed size form a connected graph under single-line extensions, which could support constructive proofs or searches that need to move continuously through the class.","The perturbation argument for the tall case suggests a quantitative stability statement: every SSR matrix of order $n$ that sits inside a taller matrix can be completed to an SSR matrix of order $n+1$ as long as the gap between the smallest and largest relevant minors is not too small; this might transfer to nearby matrices with approximate signs.","The same framework may apply to other equisigned minor classes, such as sign-regular (non-strict) matrices, by taking limits of the perturbations, although the paper does not pursue that direction."],"forward_implications":["Every SSR matrix can be grown, one line at a time, into an SSR matrix of any larger size with the same sign pattern on the old minors and freely chosen signs on new sizes.","A line can be inserted between any two consecutive rows or columns, so the construction can also refine an SSR matrix without disturbing its order of lines.","For any $p\\le\\min(m,n)$ and any sign pattern of length $p$, an $m\\times n$ SSR$_p$ matrix exists and is produced by the algorithm.","The same algorithm covers the totally positive case (all signs $+1$), giving explicit totally positive matrices of arbitrary size, with the insertion step matching an earlier construction for that special case.","Rectangular matrices taller than wide can still be extended, with the new larger minors forced to be either all positive or all negative at will."],"supporting_citations":[{"why":"Supplies the criterion used as the proof target: all contiguous minors of each size having the prescribed sign is equivalent to being SSR; the extension step only needs to control those minors.","marker":"[13]"},{"why":"Establishes the line-insertion result for totally positive matrices that Theorem B generalizes to every sign pattern.","marker":"[12]"},{"why":"Gives a recursive construction of all matrices with positive principal minors, the closest earlier explicit-construction template for the algorithm.","marker":"[17]"},{"why":"Constructs sign regular tridiagonal matrices, a special case whose method the present algorithm replaces for general matrices.","marker":"[1]"},{"why":"Proves existence and density of SSR matrices among sign regular matrices, the classical background that the new explicit algorithm makes concrete.","marker":"[10]"}],"fun_headline_variants":["Algorithm constructs SSR matrices for any size and sign pattern","Border extension yields SSR matrices of every dimension","Insert rows and columns to build strictly sign regular matrices","Explicit algorithm for strict sign regular matrices of any shape"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The construction relies on the premise that the new line can always be written as an alternating sum of existing lines with positive coefficients, and that in tall matrices one can nudge the first entries of that line by tiny amounts—no larger than the ratio of the smallest to the largest relevant subdeterminant—without changing the sign of any existing minor.","fun_headline_variants_meta":{"raw":{"variants":["Algorithm constructs SSR matrices for any size and sign pattern","Border extension yields SSR matrices of every dimension","Insert rows and columns to build strictly sign regular matrices","Explicit algorithm for strict sign regular matrices of any shape"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000295,"raw_usage":{"total_tokens":1736,"prompt_tokens":985,"completion_tokens":751,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":601,"completion_tokens_details":{"reasoning_tokens":689}},"tokens_in":601,"tokens_out":751,"duration_ms":6475,"temperature":1.0,"reasoning_tokens":689,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-12T15:23:00.804032+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the supplied Python implementation to produce a $4\\times 5$ SSR matrix with sign pattern $(1,1,-1,-1)$, then verify in exact arithmetic that every contiguous minor of size $1,2,3,4$ carries the claimed sign; any sign violation would refute the construction. A sharper test: take a known $3\\times 3$ SSR matrix, add a column on the right with Algorithm 1, and check that all $3\\times 3$ contiguous minors of the $3\\times 4$ result have the sign required by the given pattern.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Supplies the criterion used as the proof target: all contiguous minors of each size having the prescribed sign is equivalent to being SSR; the extension step only needs to control those minors."},{"cited_title":"Johnson and R.L","cited_arxiv_id":null,"evidence_quote":"Establishes the line-insertion result for totally positive matrices that Theorem B generalizes to every sign pattern."},{"cited_title":"Tsatsomeros and Y.F","cited_arxiv_id":null,"evidence_quote":"Gives a recursive construction of all matrices with positive principal minors, the closest earlier explicit-construction template for the algorithm."},{"cited_title":"Abascal, F","cited_arxiv_id":null,"evidence_quote":"Constructs sign regular tridiagonal matrices, a special case whose method the present algorithm replaces for general matrices."},{"cited_title":"Gantmacher and M.G","cited_arxiv_id":null,"evidence_quote":"Proves existence and density of SSR matrices among sign regular matrices, the classical background that the new explicit algorithm makes concrete."}],"review_version":1}