arXiv subjects

Stanislav Moiseev

Publications and source records attributed to Stanislav Moiseev.

13 recordsLinked to original sources

arXiv2026

Column Number of Delta-modular matrices: Refined Analysis via Sauer Matrices

In this paper, we build upon the analysis initiated by Gennadiy Averkov and Matthias Schymura (2022) and establish that the number of distinct columns of a $\Delta$-modular matrix $A \in \mathbb{Z}^{m \times n}$ of rank $m$ is $O(m^3 \Delta)$. This upper bound was previously known only for odd values of $\Delta$. Recall that a matrix is called $\Delta$-modular if the maximum of the absolute values of its $m \times m$ minors equals $\Delta$.

math.CO↗

arXiv2026

Algorithms for Standard-form ILP Problems via Koml\'os' Discrepancy Setting

We study the standard-form ILP problem $\max\{ c^\top x \colon A x = b,\; x \in Z_{\geq 0}^n \}$, where $A\in Z^{k\times n}$ has full row rank. We obtain refined FPT algorithms parameterized by $k$ and $\Delta$, the maximum absolute value of a $k\times k$ minor of $A$. Our approach combines discrepancy-based dynamic programming with matrix discrepancy bounds in Koml\'os' setting. Let $\kappa_k$ denote the maximum discrepancy over all matrices with $k$ columns whose columns have Euclidean norm at most $1$. Up to polynomial factors in the input size, the optimization problem can be solved in time $O(\kappa_k)^{2k}\Delta^2$, and the corresponding feasibility problem in time $O(\kappa_k)^k\Delta$. Using the best currently known bound $\kappa_k=\widetilde O(\log^{1/4}k)$, this yields running times $O(\log k)^{\frac{k}{2}(1+o(1))}\Delta^2$ and $O(\log k)^{\frac{k}{4}(1+o(1))}\Delta$, respectively. Under the Koml\'os conjecture, the dependence on $k$ in both running times reduces to $2^{O(k)}$.

cs.DS↗

arXiv2026

Zero-Order Optimization for LLM Fine-Tuning via Learnable Direction Sampling

Fine-tuning large pretrained language models (LLMs) is a cornerstone of modern NLP, yet its growing memory demands (driven by backpropagation and large optimizer States) limit deployment in resource-constrained settings. Zero-order (ZO) methods bypass backpropagation by estimating directional derivatives from forward evaluations, offering substantial memory savings. However, classical ZO estimators suffer from high variance and an adverse dependence on the parameter dimensionality $d$, which has constrained their use to low-dimensional problems. In this work, we propose a policy-driven ZO framework that treats the sampling distribution over perturbation directions as a learnable policy and updates it to reduce the variance of directional estimates. We develop a practical algorithm implementing this idea and provide a theoretical analysis, showing that learned sampling distributions improve the quality of gradient information and relax the explicit dependence on $d$ in convergence bounds. Empirically, we validate the approach on challenging LLM fine-tuning benchmarks, demonstrating substantially improved performance compared to standard ZO baselines. Our results suggest that adaptive direction sampling is a promising route to make ZO fine-tuning viable at scale. The source code is available at https://github.com/brain-lab-research/zo_ldsd

cs.LG↗

arXiv2026

TAM-Eval: Evaluating LLMs for Automated Unit Test Maintenance

While Large Language Models (LLMs) have shown promise in software engineering, their application to unit testing remains largely confined to isolated test generation or oracle prediction, neglecting the broader challenge of test suite maintenance. We introduce TAM-Eval (Test Automated Maintenance Evaluation), a framework and benchmark designed to evaluate model performance across three core test maintenance scenarios: creation, repair, and updating of test suites. Unlike prior work limited to function-level tasks, TAM-Eval operates at the test file level, while maintaining access to full repository context during isolated evaluation, better reflecting real-world maintenance workflows. Our benchmark comprises 1,539 automatically extracted and validated scenarios from Python, Java, and Go projects. TAM-Eval supports system-agnostic evaluation of both raw LLMs and agentic workflows, using a reference-free protocol based on test suite pass rate, code coverage, and mutation testing. Empirical results indicate that state-of-the-art LLMs have limited capabilities in realistic test maintenance processes and yield only marginal improvements in test effectiveness. We release TAM-Eval as an open-source framework to support future research in automated software testing. Our data and code are publicly available at https://github.com/trndcenter/TAM-Eval.

cs.SE↗

arXiv2026

RM -RF: Reward Model for Run-Free Unit Test Evaluation

We present RM-RF, a lightweight reward model for run-free evaluation of automatically generated unit tests. Instead of repeatedly compiling and executing candidate tests, RM-RF predicts - from source and test code alone - three execution-derived signals: (1) whether the augmented test suite compiles and runs successfully, (2) whether the generated test cases increase code coverage, and (3) whether the generated test cases improve the mutation kill rate. To train and evaluate RM-RF we assemble a multilingual dataset (Java, Python, Go) of focal files, test files, and candidate test additions labeled by an execution-based pipeline, and we release an associated dataset and methodology for comparative evaluation. We tested multiple model families and tuning regimes (zero-shot, full fine-tuning, and PEFT via LoRA), achieving an average F1 of 0.69 across the three targets. Compared to conventional compile-and-run instruments, RM-RF provides substantially lower latency and infrastructure cost while delivering competitive predictive fidelity, enabling fast, scalable feedback for large-scale test generation and RL-based code optimization.

cs.SE↗

arXiv2025

Targeted Test Selection Approach in Continuous Integration

In modern software development change-based testing plays a crucial role. However, as codebases expand and test suites grow, efficiently managing the testing process becomes increasingly challenging, especially given the high frequency of daily code commits. We propose Targeted Test Selection (T-TS), a machine learning approach for industrial test selection. Our key innovation is a data representation that represent commits as Bags-of-Words of changed files, incorporates cross-file and additional predictive features, and notably avoids the use of coverage maps. Deployed in production, T-TS was comprehensively evaluated against industry standards and recent methods using both internal and public datasets, measuring time efficiency and fault detection. On live industrial data, T-TS selects only 15% of tests, reduces execution time by $5.9\times$, accelerates the pipeline by $5.6\times$, and detects over 95% of test failures. The implementation is publicly available to support further research and practical adoption.

cs.SE↗

arXiv2025

MERA Code: A Unified Framework for Evaluating Code Generation Across Tasks

Advancements in LLMs have enhanced task automation in software engineering; however, current evaluations primarily focus on natural language tasks, overlooking code quality. Most benchmarks prioritize high-level reasoning over executable code and real-world performance, leaving gaps in understanding true capabilities and risks associated with these models in production. To address this issue, we propose MERA Code, a new addition to the MERA benchmark family, specifically focused on evaluating code for the latest code generation LLMs in Russian. This benchmark includes 11 evaluation tasks that span 8 programming languages. Our proposed evaluation methodology features a taxonomy that outlines the practical coding skills necessary for models to complete these tasks. The benchmark comprises an open-source codebase for users to conduct MERA assessments, a scoring system compatible with various programming environments, and a platform featuring a leaderboard and submission system. We evaluate open LLMs and frontier API models, analyzing their limitations in terms of practical coding tasks in non-English languages. We are publicly releasing MERA to guide future research, anticipate groundbreaking features in model development, and standardize evaluation procedures.

cs.SE↗

arXiv2025

Leveraging Coordinate Momentum in SignSGD and Muon: Memory-Optimized Zero-Order

Fine-tuning Large Language Models (LLMs) is essential for adapting pre-trained models to downstream tasks. Yet traditional first-order optimizers such as Stochastic Gradient Descent (SGD) and Adam incur prohibitive memory and computational costs that scale poorly with model size. In this paper, we investigate zero-order (ZO) optimization methods as a memory- and compute-efficient alternative, particularly in the context of parameter-efficient fine-tuning techniques like LoRA. We propose $\texttt{JAGUAR SignSGD}$, a ZO momentum-based algorithm that extends ZO SignSGD, requiring the same number of parameters as the standard ZO SGD and only $\mathcal{O}(1)$ function evaluations per iteration. To the best of our knowledge, this is the first study to establish rigorous convergence guarantees for SignSGD in the stochastic ZO case. We further propose $\texttt{JAGUAR Muon}$, a novel ZO extension of the Muon optimizer that leverages the matrix structure of model parameters, and we provide its convergence rate under arbitrary stochastic noise. Through extensive experiments on challenging LLM fine-tuning benchmarks, we demonstrate that the proposed algorithms meet or exceed the convergence quality of standard first-order methods, achieving significant memory reduction. Our theoretical and empirical results establish new ZO optimization methods as a practical and theoretically grounded approach for resource-constrained LLM adaptation. Our code is available at https://github.com/brain-mmo-lab/ZO_LLM

cs.LG↗

arXiv2025

Near-optimal edge partitioning via intersecting families

We study the problem of edge partitioning, where the goal is to partition the edge set of a graph into $k$ parts. The replication factor of a vertex $v$ is the number of parts that contain edges incident to $v$. The goal is to minimize the average replication factor of the vertices while keeping the sizes of the parts nearly equal. We study the regime where the number of parts is significantly smaller than the size of the graph. To this end, we prove asymptotically tight bounds on the optimal replication factor, both for any constant number of parts $k$ and when $k$ grows slowly with the number of vertices. In particular, for growing $k$, every graph admits an almost balanced partition with average replication factor $\sqrt{k}(1+o(1))$, and this bound is tight. The upper bounds are achieved by a new class of edge partitioning algorithms. These algorithms are computationally efficient, including in the LOCAL and CONGEST models, and can be implemented as stateless streaming algorithms in graph processing frameworks. The lower bounds are witnessed by complete graphs and by jumbled graphs, also known as pseudo-random graphs. Our method generalizes a family of algorithms based on symmetric intersecting families of sets. Informally, we replace the symmetry condition by a weaker balance condition that is still sufficient for the algorithms. This relaxation makes it possible to construct such families with asymptotically optimal rank $\sqrt{k}(1+o(1))$.

cs.DM↗

arXiv2025

LD-Leiden: Local Parallel Community Detection in Large Dynamic Networks

Dynamic community detection must update high-quality modularity partitions after edge batches, yet full Leiden reruns make small changes scale with the whole snapshot. Existing dynamic methods reduce work but often alter Leiden refinement, keep limited hierarchy state, or restrict graph support. This paper presents LD-Leiden, a local dynamic Leiden method for weighted directed and undirected graphs that preserves the move-refine-aggregate pipeline and updates only repaired affected regions. Its novelty is the combination of an affected-frontier rule after statistic repair, exact subtract-add aggregate repair, and conflict-filtered parallel local moves; together these mechanisms bound update cost by the visited frontier rather than the full graph. On real streams and streamed static graphs with up to 214M vertices and 3.30B edges, LD-Leiden is 48.77x faster than warm-started Leidenalg in 100-batch runs while preserving a 0.996 final modularity ratio. On the common undirected benchmark set, it is 6.94x faster than DF-Leiden and 9.73x faster than NetworKit while obtaining higher final modularity; synthetic sequences support the predicted local edge-volume scaling.

cs.SI↗

arXiv2024

Hyperplanes Avoiding Problem and Integer Points Counting in Polyhedra

In our work, we consider the problem of computing a vector $x \in Z^n$ of minimum $\|\cdot\|_p$-norm such that $a^\top x \not= a_0$, for any vector $(a,a_0)$ from a given subset of $Z^n$ of size $m$. In other words, we search for a vector of minimum norm that avoids a given finite set of hyperplanes, which is natural to call as the $\textit{Hyperplanes Avoiding Problem}$. This problem naturally appears as a subproblem in Barvinok-type algorithms for counting integer points in polyhedra. We show that: 1) With respect to $\|\cdot\|_1$, the problem admits a feasible solution $x$ with $\|x\|_1 \leq (m+n)/2$, and show that such solution can be constructed by a deterministic polynomial-time algorithm with $O(n \cdot m)$ operations. Moreover, this inequality is the best possible. This is a significant improvement over the previous randomized algorithm, which computes $x$ with a guaranty $\|x\|_{1} \leq n \cdot m$. The original approach of A.~Barvinok can guarantee only $\|x\|_1 = O\bigl((n \cdot m)^n\bigr)$. To prove this result, we use a newly established algorithmic variant of the Combinatorial Nullstellensatz; 2) The problem is NP-hard with respect to any norm $\|\cdot\|_p$, for $p \in \bigl(R_{\geq 1} \cup \{\infty\}\bigr)$. 3) As an application, we show that the problem to count integer points in a polytope $P = \{x \in R^n \colon A x \leq b\}$, for given $A \in Z^{m \times n}$ and $b \in Q^m$, can be solved by an algorithm with $O\bigl(\nu^2 \cdot n^3 \cdot \Delta^3 \bigr)$ operations, where $\nu$ is the maximum size of a normal fan triangulation of $P$, and $\Delta$ is the maximum value of rank-order subdeterminants of $A$. As a further application, it provides a refined complexity bound for the counting problem in polyhedra of bounded codimension. For example, in the polyhedra of the Unbounded Subset-Sum problem.

cs.CC↗

arXiv2024

An improvement of degree-based hashing (DBH) graph partition method, using a novel metric

This paper examines the graph partition problem and introduces a new metric, MSIDS (maximal sum of inner degrees squared). We establish its connection to the replication factor (RF) optimization, which has been the main focus of theoretical work in this field. Additionally, we propose a new partition algorithm, DBH-X, based on the DBH partitioner. We demonstrate that DBH-X significantly improves both the RF and MSIDS, compared to the baseline DBH algorithm. In addition, we provide test results that show the runtime acceleration of GraphX-based PageRank and Label propagation algorithms.

cs.DS↗

arXiv2023

Graph partition method based on finite projective planes

We present a novel graph partition algorithm with a theoretical bound for the replication factor of \sqrt(n), which improves known constrained approaches (grid: 2* \sqrt(n)-1, torus: 1.5*\sqrt(n)+1) and provides better performance

math.CO↗