Tootfinder

CORE: Benchmarking LLMs Code Reasoning Capabilities through Static Analysis Tasks
Danning Xie, Mingwei Zheng, Xuwei Liu, Jiannan Wang, Chengpeng Wang, Lin Tan, Xiangyu Zhang
https://arxiv.org/abs/2507.05269

CORE: Benchmarking LLMs Code Reasoning Capabilities through Static Analysis Tasks
Large language models (LLMs) have been widely adopted across diverse software engineering domains, such as code generation, program repair, and vulnerability detection. These applications require understanding beyond surface-level code patterns: value propagation, control flow, and interdependence between program elements. However, existing benchmarks primarily evaluate end-to-end outcomes, such as whether code is correctly repaired or generated, leaving the models ability for program semantic …

Static Analysis for Detecting Transaction Conflicts in Ethereum Smart Contracts
Zareh Chahoki Atefeh, Roveri Marco
https://arxiv.org/abs/2507.04357 https:/…

Static Analysis for Detecting Transaction Conflicts in Ethereum Smart Contracts
Ethereum smart contracts operate in a concurrent environment where multiple transactions can be submitted simultaneously. However, the Ethereum Virtual Machine (EVM) enforces sequential execution of transactions within each block to prevent conflicts arising from concurrent access to the same state variables. Although this approach guarantees correct behavior, it limits the ability of validators to leverage multi-core architectures for faster transaction processing, thus restricting throughput.…

A Large-Scale Study of Floating-Point Usage in Statically Typed Languages
Andrea Gilot, Tobias Wrigstad, Eva Darulova
https://arxiv.org/abs/2509.04936 https://

A Large-Scale Study of Floating-Point Usage in Statically Typed Languages
Reasoning about floating-point arithmetic is notoriously hard. While static and dynamic analysis techniques or program repair have made significant progress, more work is still needed to make them relevant to real-world code. On the critical path to that goal is understanding what real-world floating-point code looks like. To close that knowledge gap, this paper presents the first large-scale empirical study of floating-point arithmetic usage in statically typed languages across public GitHub r…

Laplacian Analysis Meets Dynamics Modelling: Gaussian Splatting for 4D Reconstruction
Yifan Zhou, Beizhen Zhao, Pengcheng Wu, Hao Wang
https://arxiv.org/abs/2508.04966 https://

Laplacian Analysis Meets Dynamics Modelling: Gaussian Splatting for 4D Reconstruction
While 3D Gaussian Splatting (3DGS) excels in static scene modeling, its extension to dynamic scenes introduces significant challenges. Existing dynamic 3DGS methods suffer from either over-smoothing due to low-rank decomposition or feature collision from high-dimensional grid sampling. This is because of the inherent spectral conflicts between preserving motion details and maintaining deformation consistency at different frequency. To address these challenges, we propose a novel dynamic 3DGS fr…

Large Language Models Versus Static Code Analysis Tools: A Systematic Benchmark for Vulnerability Detection
Damian Gnieciak, Tomasz Szandala
https://arxiv.org/abs/2508.04448 htt…

Large Language Models Versus Static Code Analysis Tools: A Systematic Benchmark for Vulnerability Detection
Modern software relies on a multitude of automated testing and quality assurance tools to prevent errors, bugs and potential vulnerabilities. This study sets out to provide a head-to-head, quantitative and qualitative evaluation of six automated approaches: three industry-standard rule-based static code-analysis tools (SonarQube, CodeQL and Snyk Code) and three state-of-the-art large language models hosted on the GitHub Models platform (GPT-4.1, Mistral Large and DeepSeek V3). Using a curated s…

Construction of Exceptional Points in Time-Modulated High-Contrast Elastic Media
Yixian Gao, Shuguan Ji, Shangling Song
https://arxiv.org/abs/2509.05561 https://

Construction of Exceptional Points in Time-Modulated High-Contrast Elastic Media
Spatially periodic elastic metamaterials, comprising hard inclusions within a soft matrix in $d$-dimensional space ($d\geq 2$), exhibit a rich spectrum of physical phenomena. This paper investigates such a model and presents the following contributions. First, we analyze the system's subwavelength quasi-frequencies under static conditions, establishing their functional dependence on the high-contrast parameter. This analysis enables the determination of the subwavelength quasi-frequency range. …

A blog post summarizing our latest work: a static analyzer that leverages Rust in a non-trivial way!
https://blog.brownplt.org/2025/08/03/paralegal.html

Perturbations of Black Holes in Einstein-Maxwell-Dilaton-Axion (EMDA) Theories
C. N. Pope, D. O. Rohrer, B. F. Whiting
https://arxiv.org/abs/2508.04589 https://

Perturbations of Black Holes in Einstein-Maxwell-Dilaton-Axion (EMDA) Theories
We extend our earlier work on the linearised perturbations of static black holes in Einstein-Maxwell-Dilaton (EMD) theories to the case where the black holes are solutions in an enlarged theory including also an axion. We study the perturbations in a 3-parameter family of such EMDA theories. %The analysis is more involved now, because of the %couplings of the gravitational and electromagnetic modes %to both the dilaton and axion fields. The systems of equations describing the linearised perturb…

Transient thermal analysis of a bi-layered composites with the dual-reciprocity inclusion-based boundary element method
Chunlin Wu, Liangliang Zhang, Tengxiang Wang, Huiming Yin
https://arxiv.org/abs/2508.02683

Transient thermal analysis of a bi-layered composites with the dual-reciprocity inclusion-based boundary element method
This paper proposes a single-domain dual-reciprocity inclusion-based boundary element method (DR-iBEM) for a three-dimensional fully bonded bi-layered composite embedded with ellipsoidal inhomogeneities under transient/harmonic thermal loads. The heat equation is interpreted as a static one containing time- and frequency-dependent nonhomogeneous source terms, which is similar to eigen-fields but is transformed into a boundary integral by the dual-reciprocity method. Using the steady-state bimat…

Automated Code Repair for C/C Static Analysis Alerts
David Svoboda, Lori Flynn, William Klieber, Michael Duggan, Nicholas Reimer, Joseph Sible
https://arxiv.org/abs/2508.02820

Automated Code Repair for C/C++ Static Analysis Alerts
(Note: This work is a preprint.) Static analysis (SA) tools produce many diagnostic alerts indicating that source code in C or C++ may be defective and potentially vulnerable to security exploits. Many of these alerts are false positives. Identifying the true-positive alerts and repairing the defects in the associated code are huge efforts that automated program repair (APR) tools can help with. Our experience showed us that APR can reduce the number of SA alerts significantly and reduce the ma…

MalFlows: Context-aware Fusion of Heterogeneous Flow Semantics for Android Malware Detection
Zhaoyi Meng, Fenglei Xu, Wenxiang Zhao, Wansen Wang, Wenchao Huang, Jie Cui, Hong Zhong, Yan Xiong
https://arxiv.org/abs/2508.03588

MalFlows: Context-aware Fusion of Heterogeneous Flow Semantics for Android Malware Detection
Static analysis, a fundamental technique in Android app examination, enables the extraction of control flows, data flows, and inter-component communications (ICCs), all of which are essential for malware detection. However, existing methods struggle to leverage the semantic complementarity across different types of flows for representing program behaviors, and their context-unaware nature further hinders the accuracy of cross-flow semantic integration. We propose and implement MalFlows, a novel…

Dependency Chain Analysis of ROS 2 DDS QoS Policies: From Lifecycle Tutorial to Static Verification
Sanghoon Lee, Junha Kang, Kyung-Joon Park
https://arxiv.org/abs/2509.03381 ht…

Dependency Chain Analysis of ROS 2 DDS QoS Policies: From Lifecycle Tutorial to Static Verification
Robot Operating System 2 (ROS 2) relies on the Data Distribution Service (DDS), which offers more than 20 Quality of Service (QoS) policies governing availability, reliability, and resource usage. Yet ROS 2 users lack clear guidance on safe policy combinations and validation processes prior to deployment, which often leads to trial-and-error tuning and unexpected runtime failures. To address these challenges, we analyze DDS Publisher-Subscriber communication over a life cycle divided into Disco…

Predicting Movie Success with Multi-Task Learning: A Hybrid Framework Combining GPT-Based Sentiment Analysis and SIR Propagation
Wenlan Xie
https://arxiv.org/abs/2509.02809 http…

Predicting Movie Success with Multi-Task Learning: A Hybrid Framework Combining GPT-Based Sentiment Analysis and SIR Propagation
This study presents a hybrid framework for predicting movie success. The framework integrates multi-task learning (MTL), GPT-based sentiment analysis, and Susceptible-Infected-Recovered (SIR) propagation modeling. The study examines limitations in existing approaches. It models static production attributes, information dissemination, and audience sentiment at the same time. The framework uses 5,840 films from 2004 to 2024 and approximate 300,000 user reviews. It shows predictive performance wit…

Development of MR spectral analysis method robust against static magnetic field inhomogeneity
Shuki Maruyama, Hidenori Takeshima
https://arxiv.org/abs/2506.20897

Development of MR spectral analysis method robust against static magnetic field inhomogeneity
Purpose:To develop a method that enhances the accuracy of spectral analysis in the presence of static magnetic field B0 inhomogeneity. Methods:The authors proposed a new spectral analysis method utilizing a deep learning model trained on modeled spectra that consistently represent the spectral variations induced by B0 inhomogeneity. These modeled spectra were generated from the B0 map and metabolite ratios of the healthy human brain. The B0 map was divided into a patch size of subregions, and t…

SIRA: Scaled-Integer Range Analysis for Optimizing FPGA Dataflow Neural Network Accelerators
Yaman Umuroglu, Christoph Berganski, Felix Jentzsch, Michal Danilowicz, Tomasz Kryjak, Charalampos Bezaitis, Magnus Sjalander, Ian Colbert, Thomas Preusser, Jakoba Petri-Koenig, Michaela Blott
https://arxiv.org/abs/2508.21493

SIRA: Scaled-Integer Range Analysis for Optimizing FPGA Dataflow Neural Network Accelerators
While neural network quantization effectively reduces the cost of matrix multiplications, aggressive quantization can expose non-matrix-multiply operations as significant performance and resource bottlenecks on embedded systems. Addressing such bottlenecks requires a comprehensive approach to tailoring the precision across operations in the inference computation. To this end, we introduce scaled-integer range analysis (SIRA), a static analysis technique employing interval arithmetic to determin…

Measuring how changes in code readability attributes affect code quality evaluation by Large Language Models
Igor Regis da Silva Simoes, Elaine Venson
https://arxiv.org/abs/2507.05289

Measuring how changes in code readability attributes affect code quality evaluation by Large Language Models
Code readability is one of the main aspects of code quality, influenced by various properties like identifier names, comments, code structure, and adherence to standards. However, measuring this attribute poses challenges in both industry and academia. While static analysis tools assess attributes such as code smells and comment percentage, code reviews introduce an element of subjectivity. This paper explores using Large Language Models (LLMs) to evaluate code quality attributes related to its…

Quantum Uncertainties of Static Spherically Symmetric Spacetimes
Benjamin Koch, Ali Riahinia
https://arxiv.org/abs/2506.22545 https://

Quantum Uncertainties of Static Spherically Symmetric Spacetimes
We present a canonical quantization framework for static spherically symmetric spacetimes described by the Einstein-Hilbert action with a cosmological constant. In addition to recovering the classical Schwarzschild-(Anti)-de Sitter solutions via the Ehrenfest theorem, we investigate the quantum uncertainty relations that arise among the geometric operators in this setup. Our analysis uncovers an intriguing relation to black hole thermodynamics and opens a new angle towards generalized uncertain…

Automated Feature Tracking for Real-Time Kinematic Analysis and Shape Estimation of Carbon Nanotube Growth
Kaveh Safavigerdini, Ramakrishna Surya, Jaired Collins, Prasad Calyam, Filiz Bunyak, Matthew R. Maschmann, Kannappan Palaniappan
https://arxiv.org/abs/2508.19232

Automated Feature Tracking for Real-Time Kinematic Analysis and Shape Estimation of Carbon Nanotube Growth
Carbon nanotubes (CNTs) are critical building blocks in nanotechnology, yet the characterization of their dynamic growth is limited by the experimental challenges in nanoscale motion measurement using scanning electron microscopy (SEM) imaging. Existing ex situ methods offer only static analysis, while in situ techniques often require manual initialization and lack continuous per-particle trajectory decomposition. We present Visual Feature Tracking (VFTrack) an in-situ real-time particle tracki…

Replaced article(s) found for cs.OS. https://arxiv.org/list/cs.OS/new
[1/1]:
- KNighter: Transforming Static Analysis with LLM-Synthesized Checkers
Chenyuan Yang, Zijie Zhao, Zichen Xie, Haoyu Li, Lingming Zhang

Screening Masses for Scalar and Pseudoscalar Mesons and their Diquark Partners: Insights from the Contact Interaction Model
M. A. Ram\'irez-Garrido, R. J. Hern\'andez-Pinto, I. M. Higuera-Angulo, L. X. Guti\'errez-Guerrero
https://arxiv.org/abs/2508.01099

Screening Masses for Scalar and Pseudoscalar Mesons and their Diquark Partners: Insights from the Contact Interaction Model
In this study, we calculate the screening masses of forty spin-zero meson and diquark states composed of light, heavy and heavy-light quarks, within a symmetry-preserving framework based on Dyson-Schwinger equations and a vector $\times$ vector contact interaction. This effective interaction reproduces hadron static properties at $T=0$ MeV that are in close agreement with experimental data and results from more sophisticated interaction kernels. Our analysis reveals that, at temperatures above …

SIExVulTS: Sensitive Information Exposure Vulnerability Detection System using Transformer Models and Static Analysis
Kyler Katz, Sara Moshtari, Ibrahim Mujhid, Mehdi Mirakhorli, Derek Garcia
https://arxiv.org/abs/2508.19472

SIExVulTS: Sensitive Information Exposure Vulnerability Detection System using Transformer Models and Static Analysis
Sensitive Information Exposure (SIEx) vulnerabilities (CWE-200) remain a persistent and under-addressed threat across software systems, often leading to serious security breaches. Existing detection tools rarely target the diverse subcategories of CWE-200 or provide context-aware analysis of code-level data flows. Aims: This paper aims to present SIExVulTS, a novel vulnerability detection system that integrates transformer-based models with static analysis to identify and verify sensitive inf…

Desyan: A Platform for Seamless Value-Flow and Symbolic Analysis
Panagiotis Diamantakis, Thanassis Avgerinos, Yannis Smaragdakis
https://arxiv.org/abs/2508.00508 https://…

Desyan: A Platform for Seamless Value-Flow and Symbolic Analysis
Over the past two decades, two different types of static analyses have emerged as dominant paradigms both in academia and industry: value-flow analysis (e.g., data-flow analysis or points-to analysis) and symbolic analysis (e.g., symbolic execution). Despite their individual successes in numerous application fields, the two approaches have remained largely separate; an artifact of the simple reality that there is no broadly adopted unifying platform for effortless and efficient integration of s…

Adaptive finite element convergence analysis of AT1 phase-field model for quasi-static fracture in strain-limiting solids
Ram Manohar, S. M. Mallikarjunaiah
https://arxiv.org/abs/2507.00376

Adaptive finite element convergence analysis of AT1 phase-field model for quasi-static fracture in strain-limiting solids
This research rigorously investigates the convergence of adaptive finite element methods for regularized variational models of quasi-static brittle fracture in elastic solids. We specifically examine a novel Ambrosio-Tortorelli (AT1) phase-field model within the framework of elasticity theories, particularly for material models characterized by an algebraically nonlinear stress-strain relationship. Two distinct and novel adaptive mesh refinement algorithms, underpinned by robust local error ind…

Gender Similarities Dominate Mathematical Cognition at the Neural Level: A Japanese fMRI Study Using Advanced Wavelet Analysis and Generative AI
Tatsuru Kikuchi
https://arxiv.org/abs/2507.21140

Gender Similarities Dominate Mathematical Cognition at the Neural Level: A Japanese fMRI Study Using Advanced Wavelet Analysis and Generative AI
Recent large scale behavioral studies suggest early emergence of gender differences in mathematical performance within months of school entry. However, these findings lack direct neural evidence and are constrained by cultural contexts. We conducted functional magnetic resonance imaging (fMRI) during mathematical tasks in Japanese participants (N = 156), employing an advanced wavelet time frequency analysis to examine dynamic brain processes rather than static activation patterns. Wavelet decom…

#Semgrep static analysis tool for #code scanning at ludicrous speed 🔍
🔍 Supports 30 languages including #Python

We have finally documented Ruff – the tool greatly simplifies static code analysis for Python projects: #Python

Ruff
Ruff is an extremely fast Python linter and code formatter written in Rust that can enforce the rules of flake8, isort, perflint, Black, Bandit, and others. In total, Ruff can check over 800 rules....

Automated Type Annotation in Python Using Large Language Models
Varun Bharti, Shashwat Jha, Dhruv Kumar, Pankaj Jalote
https://arxiv.org/abs/2508.00422 https://

Automated Type Annotation in Python Using Large Language Models
Type annotations in Python enhance maintainability and error detection. However, generating these annotations manually is error prone and requires extra effort. Traditional automation approaches like static analysis, machine learning, and deep learning struggle with limited type vocabularies, behavioral over approximation, and reliance on large labeled datasets. In this work, we explore the use of LLMs for generating type annotations in Python. We develop a generate check repair pipeline: the L…

Intrinsic Incompatibility: Why Static Droplets Cannot Exist in Cahn-Hilliard-Navier-Stokes Systems
Jun Lai
https://arxiv.org/abs/2508.15712 https://arxiv.o…

Intrinsic Incompatibility: Why Static Droplets Cannot Exist in Cahn-Hilliard-Navier-Stokes Systems
Static droplets serve as fundamental benchmarks for interface-resolved simulations of two-phase flows. However, their accurate representation in phase-field models remains elusive due to persistent numerical artifacts. This work rigorously proves that static droplets cannot exist in phase-field models governed by the Cahn-Hilliard-Navier-Stokes equations. Through equilibrium analysis of the governing equations, we demonstrate that equilibrium necessitates uniform chemical potential, which nulli…

A three-dimensional, multi-wavelength view and time-dependent analysis of the Milky Way's local ionized gas
Lewis McCallum, Kenneth Wood, Robert Benjamin, Dhanesh Krishnarao, Anna F. McLeod
https://arxiv.org/abs/2506.17689

A three-dimensional, multi-wavelength view and time-dependent analysis of the Milky Way's local ionized gas
This work is the continuation of a series attempting to characterize the local warm ionized medium through both static and time dependent simulations. We build upon our three dimensional, observationally-derived simulation of the local photoionized interstellar medium - based on static photoionization simulations constrained by 3D dust maps - to include metals required to predict collisionally excited optical and infrared emission lines, providing the first all-sky prediction of a series of lin…

A Generalized Stability Analysis Method with Dynamic Phasors for LV AC Microgrids
B\"ulent Da\u{g}
https://arxiv.org/abs/2507.08383 https://

A Generalized Stability Analysis Method with Dynamic Phasors for LV AC Microgrids
Representation of inductive coupling lines with conventional static phasors is the main reason of inadequacy of the existing phasors based simplified stability analysis methods for microgrids with inductive coupling lines. In the literature, dynamic phasors have been proposed for the dynamic modelling of inductive lines to conserve the simplified structure of the analysis method. In this study a generalized stability analysis method for LV AC microgrids, composed of droop controlled inverters, …

Stabilization techniques for immersogeometric analysis of plate and shell problems in explicit dynamics
Giuliano Guarino, Yannis Voet, Pablo Antolin, Annalisa Buffa
https://arxiv.org/abs/2509.00522

Stabilization techniques for immersogeometric analysis of plate and shell problems in explicit dynamics
Finite element plate and shell formulations are ubiquitous in structural analysis for modeling all kinds of slender structures, both for static and dynamic analyses. The latter are particularly challenging as the high order nature of the underlying partial differential equations and the slenderness of the structures all impose a stringent constraint on the critical time step in explicit dynamics. Unfortunately, badly cut elements in immersed finite element discretizations further aggravate the …

QLPro: Automated Code Vulnerability Discovery via LLM and Static Code Analysis Integration
Junze Hu, Xiangyu Jin, Yizhe Zeng, Yuling Liu, Yunpeng Li, Dan Du, Kaiyu Xie, Hongsong Zhu
https://arxiv.org/abs/2506.23644

QLPro: Automated Code Vulnerability Discovery via LLM and Static Code Analysis Integration
We introduce QLPro, a vulnerability detection framework that systematically integrates LLMs and static analysis tools to enable comprehensive vulnerability detection across entire open-source projects.We constructed a new dataset, JavaTest, comprising 10 open-source projects from GitHub with 62 confirmed vulnerabilities. CodeQL, a state-of-the-art static analysis tool, detected only 24 of these vulnerabilities while QLPro detected 41. Furthermore, QLPro discovered 6 previously unknown vulnerabi…

Perturbative Analysis of the Field-Free Josephson Diode Effect in a Multilayered Josephson Junction
Shin-ichi Hikino
https://arxiv.org/abs/2507.20595 https://

Perturbative Analysis of the Field-Free Josephson Diode Effect in a Multilayered Josephson Junction
The Josephson diode effect (JDE) is a novel phenomenon in which a superconducting junction exhibits asymmetric Josephson currents with respect to the superconducting phase difference. In this study, we theoretically investigate how the interplay between a static exchange field and Rashba spin-orbit interaction (RSOI) influences the JDE. By employing the quasiclassical Green's function method and perturbative calculations, we derive analytical expressions for the Josephson current in a junction …

Passive Detection in Multi-Static ISAC Systems: Performance Analysis and Joint Beamforming Optimization
Renjie He, Yiqiu Wang, Meixia Tao, Shu Sun
https://arxiv.org/abs/2506.07019

Passive Detection in Multi-Static ISAC Systems: Performance Analysis and Joint Beamforming Optimization
This paper investigates the passive detection problem in multi-static integrated sensing and communication (ISAC) systems, where multiple sensing receivers (SRs) jointly detect a target using random unknown communication signals transmitted by a collaborative base station. Unlike traditional active detection, the considered passive detection does not require complete prior knowledge of the transmitted communication signals at each SR. First, we derive a generalized likelihood ratio test detecto…

Mean-field and Monte Carlo Analysis of Multi-Species Dynamics of agents
Eduardo Velasco Stock, Roberto da Silva, Sebastian Gon\c{c}alves
https://arxiv.org/abs/2506.16717

Mean-field and Monte Carlo Analysis of Multi-Species Dynamics of agents
We propose a mean-field (MF) approximation for the recurrence relation governing the dynamics of $m$ species of particles on a square lattice, and we simultaneously perform Monte Carlo (MC) simulations under identical initial conditions to emulate the intricate motion observed in environments such as subway corridors and scramble crossings in large cities. Each species moves according to transition probabilities influenced by its respective static floor field and the state of neighboring cells.…

EarthLink: Interpreting Climate Signals with Self-Evolving AI Agents
Zijie Guo, Jiong Wang, Xiaoyu Yue, Wangxu Wei, Zhe Jiang, Wanghan Xu, Ben Fei, Wenlong Zhang, Xinyu Gu, Lijing Cheng, Jing-Jia Luo, Chao Li, Yaqiang Wang, Tao Chen, Wanli Ouyang, Fenghua Ling, Lei Bai
https://arxiv.org/abs/2507.17311

EarthLink: Interpreting Climate Signals with Self-Evolving AI Agents
Modern Earth science is at an inflection point. The vast, fragmented, and complex nature of Earth system data, coupled with increasingly sophisticated analytical demands, creates a significant bottleneck for rapid scientific discovery. Here we introduce EarthLink, the first AI agent designed as an interactive copilot for Earth scientists. It automates the end-to-end research workflow, from planning and code generation to multi-scenario analysis. Unlike static diagnostic tools, EarthLink can lea…

Dynamic and Static Analysis of Python Software with Kieker Including Reconstructed Architectures
Daphn\'e Larrivain, Shinhyung Yang, Wilhelm Hasselbring
https://arxiv.org/abs/2507.23425

Dynamic and Static Analysis of Python Software with Kieker Including Reconstructed Architectures
The Kieker observability framework is a tool that provides users with the means to design a custom observability pipeline for their application. Originally tailored for Java, supporting Python with Kieker is worthwhile. Python's popularity has exploded over the years, thus making structural insights of Python applications highly valuable. Our Python analysis pipeline combines static and dynamic analysis in order to build a complete picture of a given system.

Task-Aware Tuning of Time Constants in Spiking Neural Networks for Multimodal Classification
Chiu-Chang Cheng, Kapil Bhardwaj, Ya-Ning Chang, Sayani Majumdar, Chao-Hung Wang
https://arxiv.org/abs/2508.20121

Task-Aware Tuning of Time Constants in Spiking Neural Networks for Multimodal Classification
Spiking Neural Networks (SNNs) are promising candidates for low-power edge computing in domains such as wearable sensing and time-series analysis. A key neuronal parameter, the leaky time constant (LTC), governs temporal integration of information in Leaky Integrateand-Fire (LIF) neurons, yet its impact on feedforward SNN performance across different data modalities remains underexplored. This study investigates the role of LTC in a temporally adaptive feedforward SNN applied to static image, d…

ETrace:Event-Driven Vulnerability Detection in Smart Contracts via LLM-Based Trace Analysis
Chenyang Peng, Haijun Wang, Yin Wu, Hao Wu, Ming Fan, Yitao Zhao, Ting Liu
https://arxiv.org/abs/2506.15790

ETrace:Event-Driven Vulnerability Detection in Smart Contracts via LLM-Based Trace Analysis
With the advance application of blockchain technology in various fields, ensuring the security and stability of smart contracts has emerged as a critical challenge. Current security analysis methodologies in vulnerability detection can be categorized into static analysis and dynamic analysis methods.However, these existing traditional vulnerability detection methods predominantly rely on analyzing original contract code, not all smart contracts provide accessible code.We present ETrace, a novel…

Distributed Surface Inspection via Operational Modal Analysis by a Swarm of Miniaturized Vibration-Sensing Robots
Thiemen Siemensma, Niels de Boer, Bahar Haghighat
https://arxiv.org/abs/2507.07724

Distributed Surface Inspection via Operational Modal Analysis by a Swarm of Miniaturized Vibration-Sensing Robots
Robot swarms offer the potential to serve a variety of distributed sensing applications. An interesting real-world application that stands to benefit significantly from deployment of swarms is structural monitoring, where traditional sensor networks face challenges in structural coverage due to their static nature. This paper investigates the deployment of a swarm of miniaturized vibration sensing robots to inspect and localize structural damages on a surface section within a high-fidelity simu…

Threshold-Driven Streaming Graph: Expansion and Rumor Spreading
Flora Angileri, Andrea Clementi, Emanuele Natale, Michele Salvi, Isabella Ziccardi
https://arxiv.org/abs/2507.23533

Threshold-Driven Streaming Graph: Expansion and Rumor Spreading
A randomized distributed algorithm called RAES was introduced in [Becchetti et al., SODA 2020] to extract a bounded-degree expander from a dense $n$-vertex expander graph $G = (V, E)$. The algorithm relies on a simple threshold-based procedure. A key assumption in [Becchetti et al., SODA 2020] is that the input graph $G$ is static - i.e., both its vertex set $V$ and edge set $E$ remain unchanged throughout the process - while the analysis of RAES in dynamic models is left as a major open questi…

Research on Quality Measurement and Dynamic Transmission of Higher Education in China from the Perspective of Dual Circulation: An Empirical Analysis Based on Entropy Weight-TOPSIS and PVAR Models
Zhangming Yang, Xiaoting Yin, Dahai Zhang
https://arxiv.org/abs/2508.09216

Research on Quality Measurement and Dynamic Transmission of Higher Education in China from the Perspective of Dual Circulation: An Empirical Analysis Based on Entropy Weight-TOPSIS and PVAR Models
Drawing on the new pattern of 'dual circulation', an evaluation system for the development level of China's higher education has been constructed, utilizing data from Chinese provinces over the period 2020 to 2022. Initially, the evaluation model is established, followed by the screening of initial indicators through correlation analysis. Subsequently, an entropy weight-TOPSIS model are employed for static quantification, and the PVAR model is introduced for the first time to describe the dynam…

AgentMental: An Interactive Multi-Agent Framework for Explainable and Adaptive Mental Health Assessment
Jinpeng Hu, Ao Wang, Qianqian Xie, Hui Ma, Zhuo Li, Dan Guo
https://arxiv.org/abs/2508.11567

AgentMental: An Interactive Multi-Agent Framework for Explainable and Adaptive Mental Health Assessment
Mental health assessment is crucial for early intervention and effective treatment, yet traditional clinician-based approaches are limited by the shortage of qualified professionals. Recent advances in artificial intelligence have sparked growing interest in automated psychological assessment, yet most existing approaches are constrained by their reliance on static text analysis, limiting their ability to capture deeper and more informative insights that emerge through dynamic interaction and i…

DS@GT at LongEval: Evaluating Temporal Performance in Web Search Systems and Topics with Two-Stage Retrieval
Anthony Miyaguchi, Imran Afrulbasha, Aleksandar Pramov
https://arxiv.org/abs/2507.08360

DS@GT at LongEval: Evaluating Temporal Performance in Web Search Systems and Topics with Two-Stage Retrieval
Information Retrieval (IR) models are often trained on static datasets, making them vulnerable to performance degradation as web content evolves. The DS@GT competition team participated in the Longitudinal Evaluation of Model Performance (LongEval) lab at CLEF 2025, which evaluates IR systems across temporally distributed web snapshots. Our analysis of the Qwant web dataset includes exploratory data analysis with topic modeling over time. The two-phase retrieval system employs sparse keyword se…

Nonlinear Evidence of Investor Heterogeneity: Retail Cash Flows as Drivers of Market Dynamics
Gabjin Oh
https://arxiv.org/abs/2508.20426 https://arxiv.org/…

Nonlinear Evidence of Investor Heterogeneity: Retail Cash Flows as Drivers of Market Dynamics
This study measures the long memory of investor-segregated cash flows within the Korean equity market from 2015 to 2024. Applying detrended fluctuation analysis (DFA) to BUY, SELL, and NET aggregates, we estimate the Hurst exponent ($H$) using both a static specification and a 250-day rolling window. All series exhibit heavy tails, with complementary cumulative distribution exponents ranging from approximately 2 to 3. As a control, time-shuffled series yield $H \approx 0.5$, confirming that the…

Towards Effective Complementary Security Analysis using Large Language Models
Jonas Wagner, Simon M\"uller, Christian N\"ather, Jan-Philipp Stegh\"ofer, Andreas Both
https://arxiv.org/abs/2506.16899

Towards Effective Complementary Security Analysis using Large Language Models
A key challenge in security analysis is the manual evaluation of potential security weaknesses generated by static application security testing (SAST) tools. Numerous false positives (FPs) in these reports reduce the effectiveness of security analysis. We propose using Large Language Models (LLMs) to improve the assessment of SAST findings. We investigate the ability of LLMs to reduce FPs while trying to maintain a perfect true positive rate, using datasets extracted from the OWASP Benchmark (v…

Software Model Checking via Summary-Guided Search (Extended Version)
Ruijie Fang, Zachary Kincaid, Thomas Reps
https://arxiv.org/abs/2508.15137 https://arx…

Software Model Checking via Summary-Guided Search (Extended Version)
In this work, we describe a new software model-checking algorithm called GPS. GPS treats the task of model checking a program as a directed search of the program states, guided by a compositional, summary-based static analysis. The summaries produced by static analysis are used both to prune away infeasible paths and to drive test generation to reach new, unexplored program states. GPS can find both proofs of safety and counter-examples to safety (i.e., inputs that trigger bugs), and features a…

lcpy: an open-source python package for parametric and dynamic Life Cycle Assessment and Life Cycle Costing
Spiros Gkousis, Evina Katsou
https://arxiv.org/abs/2506.13744

lcpy: an open-source python package for parametric and dynamic Life Cycle Assessment and Life Cycle Costing
This article describes lcpy, an open-source python package that allows for advanced parametric Life Cycle Assessment (LCA) and Life Cycle Costing (LCC) analysis. The package is designed to allow the user to model a process with a flexible, modular design based on dictionaries and lists. The modeling can consider in-time variations, uncertainty, and allows for dynamic analysis, uncertainty assessment, as well as conventional static LCA and LCC. The package is compatible with optimization and unc…

Spin fluctuations, absence of magnetic order, and crystal electric field studies in the Yb$^{3 }$-based triangular lattice antiferromagnet Rb$_3$Yb(VO$_4$)$_2$
Sebin J. Sebastian, R. Kolay, Abhidev. B, Q. -P. Ding, Y. Furukawa, R. Nath
https://arxiv.org/abs/2506.07005

Spin fluctuations, absence of magnetic order, and crystal electric field studies in the Yb$^{3+}$-based triangular lattice antiferromagnet Rb$_3$Yb(VO$_4$)$_2$
We report a comprehensive experimental investigation of the structural, thermodynamic, static, and dynamic properties of a triangular lattice antiferromagnet Rb$_3$Yb(VO$_4$)$_2$. Through the analysis of magnetic susceptibility, magnetization, and specific heat, complemented by crystal electric field (CEF) calculations, we confirm the Kramers' doublet with effective spin $J_{\rm{eff}}=1/2$ ground state. Magnetic susceptibility and isothermal magnetization analysis reveal a weak antiferromagneti…

From Profiling to Optimization: Unveiling the Profile Guided Optimization
Bingxin Liu, Yinghui Huang, Jianhua Gao, Jianjun Shi, Yongpeng Liu, Yipin Sun, Weixing Ji
https://arxiv.org/abs/2507.16649

From Profiling to Optimization: Unveiling the Profile Guided Optimization
Profile Guided Optimization (PGO) uses runtime profiling to direct compiler optimization decisions, effectively combining static analysis with actual execution behavior to enhance performance. Runtime profiles, collected through instrumentation or hardware- and software-assisted sampling, provide detailed insights into control flow, branch predictions, and memory access patterns. This survey systematically categorizes PGO research by profiling method (instrumentation vs. sampling), optimization…

Evaluating Ensemble and Deep Learning Models for Static Malware Detection with Dimensionality Reduction Using the EMBER Dataset
Md Min-Ha-Zul Abedin, Tazqia Mehrub
https://arxiv.org/abs/2507.16952

Evaluating Ensemble and Deep Learning Models for Static Malware Detection with Dimensionality Reduction Using the EMBER Dataset
This study investigates the effectiveness of several machine learning algorithms for static malware detection using the EMBER dataset, which contains feature representations of Portable Executable (PE) files. We evaluate eight classification models: LightGBM, XGBoost, CatBoost, Random Forest, Extra Trees, HistGradientBoosting, k-Nearest Neighbors (KNN), and TabNet, under three preprocessing settings: original feature space, Principal Component Analysis (PCA), and Linear Discriminant Analysis (L…

TreeRanker: Fast and Model-agnostic Ranking System for Code Suggestions in IDEs
Daniele Cipollone, Egor Bogomolov, Arie van Deursen, Maliheh Izadi
https://arxiv.org/abs/2508.02455

TreeRanker: Fast and Model-agnostic Ranking System for Code Suggestions in IDEs
Token-level code completion is one of the most critical features in modern Integrated Development Environments (IDEs). It assists developers by suggesting relevant identifiers and APIs during coding. While completions are typically derived from static analysis, their usefulness depends heavily on how they are ranked, as correct predictions buried deep in the list are rarely seen by users. Most current systems rely on hand-crafted heuristics or lightweight machine learning models trained on user…

On Supersymmetric D-brane probes in 4d $\mathcal{N}=2$ $\text{AdS}_2\times\mathbf{S}^2$ Attractors
Alberto Castellano, Carmine Montella, Matteo Zatti
https://arxiv.org/abs/2507.17857

On Supersymmetric D-brane probes in 4d $\mathcal{N}=2$ $\text{AdS}_2\times\mathbf{S}^2$ Attractors
We extend the $κ$-symmetry analysis of supersymmetric D-brane probes in the $\mathrm{AdS}_2 \times \mathbf{S}^2$ attractor geometry, originally performed by Simons, Strominger, Thompson, and Yin, to also include stationary -- but non-static -- worldlines carrying angular momentum along the 2-sphere. We demonstrate that certain special trajectories, with fixed radius and orbital velocity, solve the equations of motion and moreover satisfy a supersymmetry preserving condition, thus defining new …

Sculpting Spacetime: Thin Shells in Wormhole Physics
Francisco S. N. Lobo
https://arxiv.org/abs/2508.17823 https://arxiv.org/pdf/2508.17823

Sculpting Spacetime: Thin Shells in Wormhole Physics
In this work, we employ the Darmois-Israel thin-shell formalism to construct both static and dynamic thin-shell configurations surrounding traversable wormholes. Initially, using the cut-and-paste technique, we perform a linearized stability analysis in the presence of a general cosmological constant. Our results show that for sufficiently large positive values of the cosmological constant, corresponding to the Schwarzschild-de Sitter geometry, the stability regions of the wormhole solutions ar…

Fixed-Point-Oriented Programming: A Concise and Elegant Paradigm
Yong Qi Foo, Brian Sze-Kai Cheong, Michael D. Adams
https://arxiv.org/abs/2507.21439 https://

Fixed-Point-Oriented Programming: A Concise and Elegant Paradigm
Fixed-Point-Oriented Programming (FPOP) is an emerging paradigm designed to streamline the implementation of problems involving self-referential computations. These include graph algorithms, static analysis, parsing, and distributed computing-domains that traditionally require complex and tricky-to-implement work-queue algorithms. Existing programming paradigms lack direct support for these inherently fixed-point computations, leading to inefficient and error-prone implementations. This white…

Automatic Identification of Machine Learning-Specific Code Smells
Peter Hamfelt, Ricardo Britto, Lincoln Rocha, Camilo Almendra
https://arxiv.org/abs/2508.02541 https://

Automatic Identification of Machine Learning-Specific Code Smells
Machine learning (ML) has rapidly grown in popularity, becoming vital to many industries. Currently, the research on code smells in ML applications lacks tools and studies that address the identification and validity of ML-specific code smells. This work investigates suitable methods and tools to design and develop a static code analysis tool (MLpylint) based on code smell criteria. This research employed the Design Science Methodology. In the problem identification phase, a literature review w…

LLM vs. SAST: A Technical Analysis on Detecting Coding Bugs of GPT4-Advanced Data Analysis
Madjid G. Tehrani, Eldar Sultanow, William J. Buchanan, Mahkame Houmani, Christel H. Djaha Fodja
https://arxiv.org/abs/2506.15212

LLM vs. SAST: A Technical Analysis on Detecting Coding Bugs of GPT4-Advanced Data Analysis
With the rapid advancements in Natural Language Processing (NLP), large language models (LLMs) like GPT-4 have gained significant traction in diverse applications, including security vulnerability scanning. This paper investigates the efficacy of GPT-4 in identifying software vulnerabilities compared to traditional Static Application Security Testing (SAST) tools. Drawing from an array of security mistakes, our analysis underscores the potent capabilities of GPT-4 in LLM-enhanced vulnerability …

The Effect of Pointer Analysis on Semantic Conflict Detection
Matheus Barbosa, Paulo Borba, Rodrigo Bonif\'acio, Victor Lira, Galileu Santos
https://arxiv.org/abs/2507.20081

The Effect of Pointer Analysis on Semantic Conflict Detection
Current merge tools don't detect semantic conflicts, which occur when changes from different developers are textually integrated but semantically interfere with each other. Although researchers have proposed static analyses for detecting semantic conflicts, these analyses suffer from significant false positive rates. To understand whether such false positives could be reduced by using pointer analysis in the implementation of semantic conflict static analyses, we conduct an empirical study. We …

Performance Assessment of Load Balancing Methods in Cloud Computing: Analysis of Round Robin, Equally Spread, and Throttled Strategies Using Cloud Analyst
Saeid Aghasoleymani Najafabadi
https://arxiv.org/abs/2507.11899

Performance Assessment of Load Balancing Methods in Cloud Computing: Analysis of Round Robin, Equally Spread, and Throttled Strategies Using Cloud Analyst
Load balancing plays a pivotal role in cloud computing, ensuring that resources are optimally allocated to maintain high service quality and operational efficiency. As workloads in cloud environments become increasingly dynamic and unpredictable, load balancing strategies are evolving from traditional static methods to more adaptive and intelligent approaches. In this study, the Cloud Analyst simulation tool was used to evaluate the performance of different load balancing algorithms under vario…

SLICEMATE: Accurate and Scalable Static Program Slicing via LLM-Powered Agents
Jianming Chang, Jieke Shi, Yunbo Lyu, Xin Zhou, Lulu Wang, Zhou Yang, Bixin Li, David Lo
https://arxiv.org/abs/2507.18957 …

SLICEMATE: Accurate and Scalable Static Program Slicing via LLM-Powered Agents
Static program slicing, which extracts the executable portions of a program that affect the values at a specific location, supports many software analysis tasks such as debugging and security auditing. However, traditional slicing tools rely on computationally expensive reachability analysis over dependency graphs, which struggle to scale to large programs and often fail to handle code with incomplete syntax. Recently emerged learning-based methods, while more robust to such cases, still fall s…

SaMOSA: Sandbox for Malware Orchestration and Side-Channel Analysis
Meet Udeshi, Venkata Sai Charan Putrevu, Prashanth Krishnamurthy, Ramesh Karri, Farshad Khorrami
https://arxiv.org/abs/2508.14261

SaMOSA: Sandbox for Malware Orchestration and Side-Channel Analysis
Cyber-attacks on operational technology (OT) and cyber-physical systems (CPS) have increased tremendously in recent years with the proliferation of malware targeting Linux-based embedded devices of OT and CPS systems. Comprehensive malware detection requires dynamic analysis of execution behavior in addition to static analysis of binaries. Safe execution of malware in a manner that captures relevant behaviors via side-channels requires a sandbox environment. Existing Linux sandboxes are built f…

Freer Arrows and Why You Need Them in Haskell
Grant VanDomelen, Gan Shen, Lindsey Kuper, Yao Li
https://arxiv.org/abs/2506.12212 https://

Freer Arrows and Why You Need Them in Haskell
Freer monads are a useful structure commonly used in various domains due to their expressiveness. However, a known issue with freer monads is that they are not amenable to static analysis. This paper explores freer arrows, a relatively expressive structure that is amenable to static analysis. We propose several variants of freer arrows. We conduct a case study on choreographic programming to demonstrate the usefulness of freer arrows in Haskell.

Adaptive Vision-Based Coverage Optimization in Mobile Wireless Sensor Networks: A Multi-Agent Deep Reinforcement Learning Approach
Parham Soltani, Mehrshad Eskandarpour, Sina Heidari, Farnaz Alizadeh, Hossein Soleimani
https://arxiv.org/abs/2508.14676

Adaptive Vision-Based Coverage Optimization in Mobile Wireless Sensor Networks: A Multi-Agent Deep Reinforcement Learning Approach
Traditional Wireless Sensor Networks (WSNs) typically rely on pre-analysis of the target area, network size, and sensor coverage to determine initial deployment. This often results in significant overlap to ensure continued network operation despite sensor energy depletion. With the emergence of Mobile Wireless Sensor Networks (MWSNs), issues such as sensor failure and static coverage limitations can be more effectively addressed through mobility. This paper proposes a novel deployment strategy…

Are We SOLID Yet? An Empirical Study on Prompting LLMs to Detect Design Principle Violations
Fatih Pehlivan, Ar\c{c}in \"Ulk\"u Erg\"uzen, Sahand Moslemi Yengejeh, Mayasah Lami, Anil Koyuncu
https://arxiv.org/abs/2509.03093

Are We SOLID Yet? An Empirical Study on Prompting LLMs to Detect Design Principle Violations
Traditional static analysis methods struggle to detect semantic design flaws, such as violations of the SOLID principles, which require a strong understanding of object-oriented design patterns and principles. Existing solutions typically focus on individual SOLID principles or specific programming languages, leaving a gap in the ability to detect violations across all five principles in multi-language codebases. This paper presents a new approach: a methodology that leverages tailored prompt e…

On the one-dimensional piston model with Large Velocity Variations
Dian Hu, Qianfeng Li, Yongqian Zhang
https://arxiv.org/abs/2508.13971 https://arxiv.org/…

On the one-dimensional piston model with Large Velocity Variations
This paper investigates the dynamics of a one-dimensional piston expanding into a static rarefied gas. Using asymptotic analysis in the limit of vanishing initial density, we derive sharp estimates for the piston-shock distance, the separation of characteristic speeds, and the reflection coefficient associated with characteristic waves interacting with the leading shock front. Based on these estimates, we apply the method of characteristics to prove the global-in-time existence of piecewise smo…

Anisotropic compact star model with quadratic equation of state in paraboloidal spacetime
B S Ratanpal, Bhavesh Suthar
https://arxiv.org/abs/2508.16392 https://

Anisotropic compact star model with quadratic equation of state in paraboloidal spacetime
In this work, we report a new exact solution of Einstein's field equations for static spherically symmetric anisotropic matter distributions on the background of paraboloidal spacetime by assuming a quadratic equation of state. The model parameters were found by matching the interior spacetime metric with the Schwarzschild exterior metric. The new exact solution is non-singular and meets all of the physical plausibility conditions for a realistic compact star. The detailed physical analysis of …

Resolving Indirect Calls in Binary Code via Cross-Reference Augmented Graph Neural Networks
Haotian Zhang, Kun Liu, Cristian Garces, Chenke Luo, Yu Lei, Jiang Ming
https://arxiv.org/abs/2507.18801

Resolving Indirect Calls in Binary Code via Cross-Reference Augmented Graph Neural Networks
Binary code analysis is essential in scenarios where source code is unavailable, with extensive applications across various security domains. However, accurately resolving indirect call targets remains a longstanding challenge in maintaining the integrity of static analysis in binary code. This difficulty arises because the operand of a call instruction (e.g., call rax) remains unknown until runtime, resulting in an incomplete inter-procedural control flow graph (CFG). Previous approaches have …

LLM-Based Repair of Static Nullability Errors
Nima Karimipour, Michael Pradel, Martin Kellogg, Manu Sridharan
https://arxiv.org/abs/2507.20674 https://arxi…

LLM-Based Repair of Static Nullability Errors
Modern Java projects increasingly adopt static analysis tools that prevent null-pointer exceptions by treating nullness as a type property. However, integrating such tools into large, existing codebases remains a significant challenge. While annotation inference can eliminate many errors automatically, a subset of residual errors -- typically a mix of real bugs and false positives -- often persist and can only be resolved via code changes. Manually addressing these errors is tedious and error-p…

Precisely Detecting Python Type Errors via LLM-based Unit Test Generation
Chen Yang, Ziqi Wang, Yanjie Jiang, Lin Yang, Yuteng Zheng, Jianyi Zhou, Junjie Chen
https://arxiv.org/abs/2507.02318

Precisely Detecting Python Type Errors via LLM-based Unit Test Generation
Type errors in Python often lead to runtime failures, posing significant challenges to software reliability and developer productivity. Existing static analysis tools aim to detect such errors without execution but frequently suffer from high false positive rates. Recently, unit test generation techniques offer great promise in achieving high test coverage, but they often struggle to produce bug-revealing tests without tailored guidance. To address these limitations, we present RTED, a novel ty…

SAEL: Leveraging Large Language Models with Adaptive Mixture-of-Experts for Smart Contract Vulnerability Detection
Lei Yu, Shiqi Cheng, Zhirong Huang, Jingyuan Zhang, Chenjie Shen, Junyi Lu, Li Yang, Fengjun Zhang, Jiajia Ma
https://arxiv.org/abs/2507.22371

SAEL: Leveraging Large Language Models with Adaptive Mixture-of-Experts for Smart Contract Vulnerability Detection
With the increasing security issues in blockchain, smart contract vulnerability detection has become a research focus. Existing vulnerability detection methods have their limitations: 1) Static analysis methods struggle with complex scenarios. 2) Methods based on specialized pre-trained models perform well on specific datasets but have limited generalization capabilities. In contrast, general-purpose Large Language Models (LLMs) demonstrate impressive ability in adapting to new vulnerability pa…

Agentic Program Repair from Test Failures at Scale: A Neuro-symbolic approach with static analysis and test execution feedback
Chandra Maddila, Adam Tait, Claire Chang, Daniel Cheng, Nauman Ahmad, Vijayaraghavan Murali, Marshall Roch, Arnaud Avondet, Aaron Meltzer, Victor Montalvao, Michael Hopko, Chris Waterson, Parth Thakkar, Renuka Fernandez, Kristian Kristensen, Sivan Barzily, Sherry Chen, Rui Abreu, Nachiappan Nagappan, Payam Shodjai, Killian Murphy, James Everingham, Aparna Raman…

Agentic Program Repair from Test Failures at Scale: A Neuro-symbolic approach with static analysis and test execution feedback
Aim: With the advent of LLMs, sophisticated agentic program repair has become viable at large organizations with large codebases. In this work, we develop an Engineering Agent that fixes the source code based on test failures at scale across diverse software offerings internally. Method: Using Llama as the base, we employ the ReAct harness to develop an agent. We start with a test failure that was triaged by a rule-based test failure bot. We then set up an agentic harness and allow the agent …

Orthogonal splitting of the Riemann curvature tensor and its implications in modeling compact stellar structures
A. Rehman, Tayyab Naseer, Nazek Alessa, Abdel-Haleem Abdel-Aty
https://arxiv.org/abs/2506.16725

Orthogonal splitting of the Riemann curvature tensor and its implications in modeling compact stellar structures
Although the interpretation of complexity in extended theories of gravity is available in the literature, its illustration in $f(R,L_{m},\mathcal{T})$ theory is still ambiguous. The orthogonal decomposition of the Riemann tensor results in the emergence of complexity factor as recently proposed by Herrera [1]. We initiate the analysis by contemplating the interior spacetime as a static spherical anisotropic composition under the presence of charge. The modified field equations are derived along…

AI Agentic Vulnerability Injection And Transformation with Optimized Reasoning
Amine Lbath, Massih-Reza Amini, Aurelien Delaitre, Vadim Okun
https://arxiv.org/abs/2508.20866 htt…

AI Agentic Vulnerability Injection And Transformation with Optimized Reasoning
The increasing complexity of software systems and the sophistication of cyber-attacks have underscored the critical need for effective automated vulnerability detection and repair systems. Traditional methods, such as static program analysis, face significant challenges related to scalability, adaptability, and high false-positive and false-negative rates. AI-driven approaches, particularly those using machine learning and deep learning models, show promise but are heavily reliant on the qualit…

Call Me Maybe: Enhancing JavaScript Call Graph Construction using Graph Neural Networks
Masudul Hasan Masud Bhuiyan, Gianluca De Stefano, Giancarlo Pellegrino, Cristian-Alexandru Staicu
https://arxiv.org/abs/2506.18191

Call Me Maybe: Enhancing JavaScript Call Graph Construction using Graph Neural Networks
Static analysis plays a key role in finding bugs, including security issues. A critical step in static analysis is building accurate call graphs that model function calls in a program. However, due to hard-to-analyze language features, existing call graph construction algorithms for JavaScript are neither sound nor complete. Prior work shows that even advanced solutions produce false edges and miss valid ones. In this work, we assist these tools by identifying missed call edges. Our main idea i…

Universal Synthesis of Differentiably Tunable Numerical Abstract Transformers
Shaurya Gomber, Debangshu Banerjee, Gagandeep Singh
https://arxiv.org/abs/2507.11827

Universal Synthesis of Differentiably Tunable Numerical Abstract Transformers
Numerical abstract interpretation is a widely used framework for the static analysis of numerical programs. However, existing numerical abstract interpreters rely on hand-crafted, instruction-specific transformers tailored to each domain, with no general algorithm for handling common operations across domains. This limits extensibility, prevents precise compositional reasoning over instruction sequences, and forces all downstream tasks to use the same fixed transformer regardless of their preci…

MetaLint: Generalizable Idiomatic Code Quality Analysis through Instruction-Following and Easy-to-Hard Generalization
Atharva Naik, Lawanya Baghel, Dhakshin Govindarajan, Darsh Agrawal, Daniel Fried, Carolyn Rose
https://arxiv.org/abs/2507.11687

MetaLint: Generalizable Idiomatic Code Quality Analysis through Instruction-Following and Easy-to-Hard Generalization
Large Language Models, though successful in code generation, struggle with code quality analysis because they are limited by static training data and can't easily adapt to evolving best practices. We introduce MetaLint, a new instruction-following framework that formulates code quality analysis as the task of detecting and fixing problematic semantic code fragments or code idioms based on high-level specifications. Unlike conventional approaches that train models on static, rule-based data, Met…

PrompTrend: Continuous Community-Driven Vulnerability Discovery and Assessment for Large Language Models
Tarek Gasmi, Ramzi Guesmi, Mootez Aloui, Jihene Bennaceur
https://arxiv.org/abs/2507.19185

PrompTrend: Continuous Community-Driven Vulnerability Discovery and Assessment for Large Language Models
Static benchmarks fail to capture LLM vulnerabilities emerging through community experimentation in online forums. We present PrompTrend, a system that collects vulnerability data across platforms and evaluates them using multidimensional scoring, with an architecture designed for scalable monitoring. Cross-sectional analysis of 198 vulnerabilities collected from online communities over a five-month period (January-May 2025) and tested on nine commercial models reveals that advanced capabilitie…

Static Analysis as a Feedback Loop: Enhancing LLM-Generated Code Beyond Correctness
Scott Blyth, Sherlock A. Licorish, Christoph Treude, Markus Wagner
https://arxiv.org/abs/2508.14419

Static Analysis as a Feedback Loop: Enhancing LLM-Generated Code Beyond Correctness
Large language models (LLMs) have demonstrated impressive capabilities in code generation, achieving high scores on benchmarks such as HumanEval and MBPP. However, these benchmarks primarily assess functional correctness and neglect broader dimensions of code quality, including security, reliability, readability, and maintainability. In this work, we systematically evaluate the ability of LLMs to generate high-quality code across multiple dimensions using the PythonSecurityEval benchmark. We in…

Reducing False Positives with Active Behavioral Analysis for Cloud Security
Dikshant, Verma
https://arxiv.org/abs/2508.12584 https://arxiv.org/pdf/2508.12…

Reducing False Positives with Active Behavioral Analysis for Cloud Security
Rule-based cloud security posture management (CSPM) solutions are known to produce a lot of false positives based on the limited contextual understanding and dependence on static heuristics testing. This paper introduces a validation-driven methodology that integrates active behavioral testing in cloud security posture management solution(s) to evaluate the exploitability of policy violations in real time. The proposed system employs lightweight and automated probes, built from open-source tool…

A Slice-Based Change Impact Analysis for Regression Test Case Prioritization of Object-Oriented Programs
S. Panda, D. Munjal, D. P. Mohapatra
https://arxiv.org/abs/2508.19056 ht…

A Slice-Based Change Impact Analysis for Regression Test Case Prioritization of Object-Oriented Programs
Test case prioritization focuses on finding a suitable order of execution of the test cases in a test suite to meet some performance goals like detecting faults early. It is likely that some test cases execute the program parts that are more prone to errors and will detect more errors if executed early during the testing process. Finding an optimal order of execution for the selected regression test cases saves time and cost of retesting. This paper presents a static approach to prioritizing th…

Augmenting Large Language Models with Static Code Analysis for Automated Code Quality Improvements
Seyed Moein Abtahi, Akramul Azim
https://arxiv.org/abs/2506.10330

Augmenting Large Language Models with Static Code Analysis for Automated Code Quality Improvements
This study examined code issue detection and revision automation by integrating Large Language Models (LLMs) such as OpenAI's GPT-3.5 Turbo and GPT-4o into software development workflows. A static code analysis framework detects issues such as bugs, vulnerabilities, and code smells within a large-scale software project. Detailed information on each issue was extracted and organized to facilitate automated code revision using LLMs. An iterative prompt engineering process is applied to ensure tha…

Minimizing False Positives in Static Bug Detection via LLM-Enhanced Path Feasibility Analysis
Xueying Du, Kai Yu, Chong Wang, Yi Zou, Wentai Deng, Zuoyu Ou, Xin Peng, Lingming Zhang, Yiling Lou
https://arxiv.org/abs/2506.10322

Minimizing False Positives in Static Bug Detection via LLM-Enhanced Path Feasibility Analysis
Static bug analyzers play a crucial role in ensuring software quality. However, existing analyzers for bug detection in large codebases often suffer from high false positive rates. This is primarily due to the limited capabilities of analyzers in path feasibility validation with multiple conditional branches and complex data dependencies. While current LLM-based approaches attempt to address this issue, their effectiveness remains limited due to insufficient constraint cascade analysis and scal…

Certifiably robust malware detectors by design
Pierre-Francois Gimenez, Sarath Sivaprasad, Mario Fritz
https://arxiv.org/abs/2508.10038 https://arxiv.org/p…

Certifiably robust malware detectors by design
Malware analysis involves analyzing suspicious software to detect malicious payloads. Static malware analysis, which does not require software execution, relies increasingly on machine learning techniques to achieve scalability. Although such techniques obtain very high detection accuracy, they can be easily evaded with adversarial examples where a few modifications of the sample can dupe the detector without modifying the behavior of the software. Unlike other domains, such as computer vision,…

Detecting State Manipulation Vulnerabilities in Smart Contracts Using LLM and Static Analysis
Hao Wu, Haijun Wang, Shangwang Li, Yin Wu, Ming Fan, Yitao Zhao, Ting Liu
https://arxiv.org/abs/2506.08561

Detecting State Manipulation Vulnerabilities in Smart Contracts Using LLM and Static Analysis
An increasing number of DeFi protocols are gaining popularity, facilitating transactions among multiple anonymous users. State Manipulation is one of the notorious attacks in DeFi smart contracts, with price variable being the most commonly exploited state variable-attackers manipulate token prices to gain illicit profits. In this paper, we propose PriceSleuth, a novel method that leverages the Large Language Model (LLM) and static analysis to detect Price Manipulation (PM) attacks proactively.…

Assessing the Quality and Security of AI-Generated Code: A Quantitative Analysis
Abbas Sabra, Olivier Schmitt, Joseph Tyler
https://arxiv.org/abs/2508.14727 https://

Assessing the Quality and Security of AI-Generated Code: A Quantitative Analysis
This study presents a quantitative evaluation of the code quality and security of five prominent Large Language Models (LLMs): Claude Sonnet 4, Claude 3.7 Sonnet, GPT-4o, Llama 3.2 90B, and OpenCoder 8B. While prior research has assessed the functional performance of LLM-generated code, this research tested LLM output from 4,442 Java coding assignments through comprehensive static analysis using SonarQube. The findings suggest that although LLMs can generate functional code, they also introduce…

Disa: Accurate Learning-based Static Disassembly with Attentions
Peicheng Wang, Monika Santra, Mingyu Liu, Cong Sun, Dongrui Zeng, Gang Tan
https://arxiv.org/abs/2507.07246

Disa: Accurate Learning-based Static Disassembly with Attentions
For reverse engineering related security domains, such as vulnerability detection, malware analysis, and binary hardening, disassembly is crucial yet challenging. The fundamental challenge of disassembly is to identify instruction and function boundaries. Classic approaches rely on file-format assumptions and architecture-specific heuristics to guess the boundaries, resulting in incomplete and incorrect disassembly, especially when the binary is obfuscated. Recent advancements of disassembly ha…

CASCADE: LLM-Powered JavaScript Deobfuscator at Google
Shan Jiang, Pranoy Kovuri, David Tao, Zhixun Tan
https://arxiv.org/abs/2507.17691 https://

CASCADE: LLM-Powered JavaScript Deobfuscator at Google
Software obfuscation, particularly prevalent in JavaScript, hinders code comprehension and analysis, posing significant challenges to software testing, static analysis, and malware detection. This paper introduces CASCADE, a novel hybrid approach that integrates the advanced coding capabilities of Gemini with the deterministic transformation capabilities of a compiler Intermediate Representation (IR), specifically JavaScript IR (JSIR). By employing Gemini to identify critical prelude functions,…

Automated Code Review Using Large Language Models at Ericsson: An Experience Report
Shweta Ramesh, Joy Bose, Hamender Singh, A K Raghavan, Sujoy Roychowdhury, Giriprasad Sridhara, Nishrith Saini, Ricardo Britto
https://arxiv.org/abs/2507.19115

Automated Code Review Using Large Language Models at Ericsson: An Experience Report
Code review is one of the primary means of assuring the quality of released software along with testing and static analysis. However, code review requires experienced developers who may not always have the time to perform an in-depth review of code. Thus, automating code review can help alleviate the cognitive burden on experienced software developers allowing them to focus on their primary activities of writing code to add new features and fix bugs. In this paper, we describe our experience in…

BugScope: Learn to Find Bugs Like Human
Jinyao Guo, Chengpeng Wang, Dominic Deluca, Jinjie Liu, Zhuo Zhang, Xiangyu Zhang
https://arxiv.org/abs/2507.15671 …

BugScope: Learn to Find Bugs Like Human
Detecting software bugs remains a fundamental challenge due to the extensive diversity of real-world defects. Traditional static analysis tools often rely on symbolic workflows, which restrict their coverage and hinder adaptability to customized bugs with diverse anti-patterns. While recent advances incorporate large language models (LLMs) to enhance bug detection, these methods continue to struggle with sophisticated bugs and typically operate within limited analysis contexts. To address these…

We Urgently Need Privilege Management in MCP: A Measurement of API Usage in MCP Ecosystems
Zhihao Li, Kun Li, Boyang Ma, Minghui Xu, Yue Zhang, Xiuzhen Cheng
https://arxiv.org/abs/2507.06250

We Urgently Need Privilege Management in MCP: A Measurement of API Usage in MCP Ecosystems
The Model Context Protocol (MCP) has emerged as a widely adopted mechanism for connecting large language models to external tools and resources. While MCP promises seamless extensibility and rich integrations, it also introduces a substantially expanded attack surface: any plugin can inherit broad system privileges with minimal isolation or oversight. In this work, we conduct the first large-scale empirical analysis of MCP security risks. We develop an automated static analysis framework and sy…

Dealing with SonarQube Cloud: Initial Results from a Mining Software Repository Study
Sabato Nocera, Davide Fucci, Giuseppe Scanniello
https://arxiv.org/abs/2508.18816 https://

Dealing with SonarQube Cloud: Initial Results from a Mining Software Repository Study
Background: Static Code Analysis (SCA) tools are widely adopted to enforce code quality standards. However, little is known about how open-source projects use and customize these tools. Aims: This paper investigates how GitHub projects use and customize a popular SCA tool, namely SonarQube Cloud. Method: We conducted a mining study of GitHub projects that are linked through GitHub Actions to SonarQube Cloud projects. Results: Among 321 GitHub projects using SonarQube Cloud, 81% of them are corr…

deepSURF: Detecting Memory Safety Vulnerabilities in Rust Through Fuzzing LLM-Augmented Harnesses
Georgios Androutsopoulos, Antonio Bianchi
https://arxiv.org/abs/2506.15648

deepSURF: Detecting Memory Safety Vulnerabilities in Rust Through Fuzzing LLM-Augmented Harnesses
Although Rust ensures memory safety by default, it also permits the use of unsafe code, which can introduce memory safety vulnerabilities if misused. Unfortunately, existing tools for detecting memory bugs in Rust typically exhibit limited detection capabilities, inadequately handle Rust-specific types, or rely heavily on manual intervention. To address these limitations, we present deepSURF, a tool that integrates static analysis with Large Language Model (LLM)-guided fuzzing harness generat…

From Static to Intelligent: Evolving SaaS Pricing with LLMs
Francisco Javier Cavero, Juan C. Alonso, Antonio Ruiz-Cort\'es
https://arxiv.org/abs/2507.12104

From Static to Intelligent: Evolving SaaS Pricing with LLMs
The SaaS paradigm has revolutionized software distribution by offering flexible pricing options to meet diverse customer needs. However, the rapid expansion of the SaaS market has introduced significant complexity for DevOps teams, who must manually manage and evolve pricing structures, an approach that is both time-consuming and prone to errors. The absence of automated tools for pricing analysis restricts the ability to efficiently evaluate, optimize, and scale these models. This paper propos…

Assessing Reliability of Statistical Maximum Coverage Estimators in Fuzzing
Danushka Liyanage, Nelum Attanayake, Zijian Luo, Rahul Gopinath
https://arxiv.org/abs/2507.17093

Assessing Reliability of Statistical Maximum Coverage Estimators in Fuzzing
Background: Fuzzers are often guided by coverage, making the estimation of maximum achievable coverage a key concern in fuzzing. However, achieving 100% coverage is infeasible for most real-world software systems, regardless of effort. While static reachability analysis can provide an upper bound, it is often highly inaccurate. Recently, statistical estimation methods based on species richness estimators from biostatistics have been proposed as a potential solution. Yet, the lack of reliable be…

AI-Based Software Vulnerability Detection: A Systematic Literature Review
Samiha Shimmi, Hamed Okhravi, Mona Rahimi
https://arxiv.org/abs/2506.10280 https:…

AI-Based Software Vulnerability Detection: A Systematic Literature Review
Software vulnerabilities in source code pose serious cybersecurity risks, prompting a shift from traditional detection methods (e.g., static analysis, rule-based matching) to AI-driven approaches. This study presents a systematic review of software vulnerability detection (SVD) research from 2018 to 2023, offering a comprehensive taxonomy of techniques, feature representations, and embedding methods. Our analysis reveals that 91% of studies use AI-based methods, with graph-based models being th…

This https://arxiv.org/abs/2505.13229 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

PARF: An Adaptive Abstraction-Strategy Tuner for Static Analysis
We launch Parf - a toolkit for adaptively tuning abstraction strategies of static program analyzers in a fully automated manner. Parf models various types of external parameters (encoding abstraction strategies) as random variables subject to probability distributions over latticed parameter spaces. It incrementally refines the probability distributions based on accumulated intermediate results generated by repeatedly sampling and analyzing, thereby ultimately yielding a set of highly accurate …

On the need to perform comprehensive evaluations of automated program repair benchmarks: Sorald case study
Sumudu Liyanage, Sherlock A. Licorish, Markus Wagner, Stephen G. MacDonell
https://arxiv.org/abs/2508.15135

On the need to perform comprehensive evaluations of automated program repair benchmarks: Sorald case study
In supporting the development of high-quality software, especially necessary in the era of LLMs, automated program repair (APR) tools aim to improve code quality by automatically addressing violations detected by static analysis profilers. Previous research tends to evaluate APR tools only for their ability to clear violations, neglecting their potential introduction of new (sometimes severe) violations, changes to code functionality and degrading of code structure. There is thus a need for res…

REST in Pieces: RESTful Design Rule Violations in Student-Built Web Apps
Sergio Di Meglio, Valeria Pontillo, Luigi Libero Lucio Starace
https://arxiv.org/abs/2507.11689

REST in Pieces: RESTful Design Rule Violations in Student-Built Web Apps
In Computer Science Bachelor's programs, software quality is often underemphasized due to limited time and a focus on foundational skills, leaving many students unprepared for industry expectations. To better understand the typical quality of student code and inform both education and hiring practices, we analyze 40 full-stack web applications developed in a third-year Web Technologies course. Using an automated static analysis pipeline, we assess adherence to REST API design rules. Results rev…

RefModel: Detecting Refactorings using Foundation Models
Pedro Sim\~oes, Rohit Gheyi, Rian Melo, Jonhnanthan Oliveira, M\'arcio Ribeiro, Wesley K. G. Assun\c{c}\~ao
https://arxiv.org/abs/2507.11346

RefModel: Detecting Refactorings using Foundation Models
Refactoring is a common software engineering practice that improves code quality without altering program behavior. Although tools like ReExtractor+, RefactoringMiner, and RefDiff have been developed to detect refactorings automatically, they rely on complex rule definitions and static analysis, making them difficult to extend and generalize to other programming languages. In this paper, we investigate the viability of using foundation models for refactoring detection, implemented in a tool nam…

This https://arxiv.org/abs/2505.23674 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

Quantum-Based Software Engineering
Quantum computing has demonstrated potential for solving computationally intensive problems more efficiently than classical methods. Many software engineering tasks, such as test case selection, static analysis, code clone detection, and defect prediction, involve complex optimization, search, or classification, making them candidates for quantum enhancement. In this paper, we propose Quantum-Based Software Engineering (QBSE), a potential research direction for applying quantum computing to cla…