Score
Designs and implements numerical algorithms and solvers that project variables or update directions onto constraint subspaces by exploiting block‑sparse Jacobian and KKT structure. Builds methods to assemble and solve sample‑wise block‑sparse systems, perform nullspace or reduced‑space projections to eliminate redundant unknowns, linearize coupled constraints, and produce minimal solver bases that reduce problem dimensionality.
This paper addresses the efficient solution of integer linear systems $Ax = b$ over finite-dimensional linear spaces. We present the first randomized solver for polynomially bounded integer inputs that is independent of the matrix condition number. Our algorithm operates over the rationals, achieving $ ilde{O}(n^2 cdot ext{nnz}(A))$ time complexity and $O(n log n)$ workspace—breaking the classical accuracy–space trade-off. The core techniques integrate bit-complexity optimization, near-linear-space data structures, and a synergistic design of exact integer arithmetic with approximation theory. As a result, our method provides a unified, highly efficient primitive for fundamental numerical tasks—including linear regression, linear programming, and eigenvalue/singular value decomposition—delivering exact or high-accuracy approximate solutions in polynomial time while using near-linear space. This significantly expands the tractability frontier for large-scale numerical linear algebra problems.
This paper addresses the challenge of optimizing constrained nonlinear black-box functions—lacking closed-form expressions—for real-time robot trajectory and control optimization. Method: We propose a model-free gradient-based optimization framework that uniquely integrates first-order gradient line search with a priority-aware constraint-handling mechanism based on null-space projection of the constraint Jacobian, requiring neither analytical gradients nor system derivatives. The method supports generic black-box function interfaces and is implemented efficiently in C++. Contributions/Results: (1) It achieves strict feasibility and high computational efficiency, overcoming traditional limitations that require explicit modeling or higher-order derivatives; (2) it delivers real-time performance—converging in milliseconds—across diverse robot dynamics and motion planning tasks; (3) an open-source implementation includes representative numerical experiments and standardized robotics benchmarks, demonstrating strong generalizability and engineering practicality.
This work addresses the challenge of globally characterizing the geometric structure of solution manifolds in redundant robotic tasks, which exhibit non-uniqueness and form continuous manifolds in configuration space. Existing approaches struggle to capture these structures comprehensively. The paper proposes a representation-centric implicit modeling paradigm that constructs a scalar field over the configuration space, whose zero-level set precisely coincides with the task-induced solution manifold. By integrating Jacobian-guided neighborhood sampling with implicit neural representations, the method learns a signed distance field of the solution manifold, enabling globally consistent and continuous modeling under arbitrary task mappings—a capability demonstrated for the first time. Experiments on a planar three-link robot and a seven-degree-of-freedom Franka manipulator validate the approach’s ability to accurately reconstruct solution manifolds and generalize across varying task parameters.
In parametric dynamical systems, the Proper Orthogonal Decomposition (POD) basis drifts with parameters, degrading the accuracy of reduced-order models (ROMs). Method: This paper proposes the Projected Gaussian Process (pGP) framework—the first to formulate subspace adaptation as a statistical learning task mapping parameter space to the Grassmann manifold. It employs a two-stage geometric mapping: Euclidean space → horizontal space → Grassmann manifold, integrating POD, exponential/logarithmic maps, horizontal-space projection, and Gaussian process regression to enable uncertainty-aware POD subspace prediction while preserving manifold structure. Contribution/Results: Numerical experiments demonstrate that pGP significantly improves ROM accuracy and robustness in both parametric extrapolation and interpolation scenarios, and provides interpretable, calibrated confidence quantification—establishing a new paradigm for parameter-sensitive model reduction.
This paper addresses the weak theoretical foundations of matrix decomposition in machine learning by systematically constructing a self-consistent, comprehensive, and modern-application-oriented pedagogical framework. Methodologically, it grounds the exposition in numerical linear algebra and matrix analysis, unifying classical decompositions—including LU, QR, SVD, and block triangular factorizations—while integrating numerical stability analysis and Hermitian/Hilbert space theory. Crucially, it bridges traditional numerical analysis with deep learning’s backpropagation setting, emphasizing differentiability and computational robustness of decompositions in algorithm design and model optimization. The primary contribution is a compact, dual-purpose (teaching and research) knowledge system that fills critical gaps in both theoretical coherence and machine-learning relevance present in existing literature, thereby providing rigorous mathematical foundations for high-dimensional data modeling and efficient training.
This work addresses the heavy reliance on large numbers of PDE solution samples in operator learning by proposing an efficient approximation framework based on incremental dimensionality expansion. By integrating tensor-product basis expansions with sparse recovery techniques—such as orthogonal matching pursuit—the method identifies low-dimensional structures and critical variable interactions, substantially reducing the required number of PDE solves. In multiple numerical experiments, the approach achieves accuracy comparable to or better than conventional quadrature methods and Fourier neural operators, while demanding significantly lower sample complexity and computational cost. Furthermore, the recovered sparse index sets offer interpretable insights into the underlying solution structure.
This work proposes the first fast deterministic algorithm for linear systems with arbitrary rectangular displacement structures—including Toeplitz-like, Vandermonde-like, and Cauchy-like matrices—addressing the limitation of existing fastest methods that rely on randomization and lack deterministic guarantees. The approach reformulates the structured linear system as a univariate polynomial modular equation and solves it via three deterministic steps: computing a vector M-Padé approximant basis, eliminating extraneous variables by solving a linear system over the polynomial ring, and recovering the solution through a synchronized M-Padé approximation. The algorithm deterministically computes both the solution to the linear system and a basis for its nullspace in $\tilde{O}(\alpha^{\omega-1}(m+n))$ operations over the base field, offering broader applicability and stronger reliability than prior randomized methods.
This work addresses the ill-conditioning and numerical instability inherent in traditional primal-dual interior-point methods for quadratic programming, which arise from explicitly enforcing complementarity conditions. To overcome this limitation, the authors propose a novel approach that implicitly satisfies the Karush–Kuhn–Tucker (KKT) complementarity conditions. By introducing auxiliary variables, employing a retraction mapping, and replacing the exponential map with the softplus function, the method ensures spectral boundedness of the KKT system, thereby fundamentally mitigating severe ill-conditioning near the solution. Coupled with a linear solver strategy that avoids matrix refactorization at each iteration, the proposed framework not only supports high-accuracy solutions and low-precision arithmetic but also opens new avenues for decomposition-free or indirect solution techniques tailored to large-scale quadratic programming problems.