Tootfinder

Replaced article(s) found for math.OC. https://arxiv.org/list/math.OC/new
[1/1]:
- A robust BFGS algorithm for unconstrained nonlinear optimization problems
Yaguang Yang
https://arxiv.org/abs/1212.5929
- Quantum computing and the stable set problem
Alja\v{z} Krpan, Janez Povh, Dunja Pucher
https://arxiv.org/abs/2405.12845 https://mastoxiv.page/@arXiv_mathOC_bot/112483516437815686
- Mean Field Game with Reflected Jump Diffusion Dynamics: A Linear Programming Approach
Zongxia Liang, Xiang Yu, Keyu Zhang
https://arxiv.org/abs/2508.20388 https://mastoxiv.page/@arXiv_mathOC_bot/115111048711698998
- Differential Dynamic Programming for the Optimal Control Problem with an Ellipsoidal Target Set a...
Sungjun Eom, Gyunghoon Park
https://arxiv.org/abs/2509.07546 https://mastoxiv.page/@arXiv_mathOC_bot/115179281556444440
- On the Moreau envelope properties of weakly convex functions
Marien Renaud, Arthur Leclaire, Nicolas Papadakis
https://arxiv.org/abs/2509.13960 https://mastoxiv.page/@arXiv_mathOC_bot/115224514482363803
- Automated algorithm design via Nevanlinna-Pick interpolation
Ibrahim K. Ozaslan, Tryphon T. Georgiou, Mihailo R. Jovanovic
https://arxiv.org/abs/2509.21416 https://mastoxiv.page/@arXiv_mathOC_bot/115286533597711930
- Optimal Control of a Bioeconomic Crop-Energy System with Energy Reinvestment
Othman Cherkaoui Dekkaki
https://arxiv.org/abs/2510.11381 https://mastoxiv.page/@arXiv_mathOC_bot/115372322896073250
- Point Convergence Analysis of the Accelerated Gradient Method for Multiobjective Optimization: Co...
Yingdong Yin
https://arxiv.org/abs/2510.26382 https://mastoxiv.page/@arXiv_mathOC_bot/115468018035252078
- History-Aware Adaptive High-Order Tensor Regularization
Chang He, Bo Jiang, Yuntian Jiang, Chuwen Zhang, Shuzhong Zhang
https://arxiv.org/abs/2511.05788
- Equivalence of entropy solutions and gradient flows for pressureless 1D Euler systems
Jos\'e Antonio Carrillo, Sondre Tesdal Galtung
https://arxiv.org/abs/2312.04932 https://mastoxiv.page/@arXiv_mathAP_bot/111560077272113052
- Kernel Modelling of Fading Memory Systems
Yongkang Huo, Thomas Chaffey, Rodolphe Sepulchre
https://arxiv.org/abs/2403.11945 https://mastoxiv.page/@arXiv_eessSY_bot/112121123836064435
- The Maximum Theoretical Ground Speed of the Wheeled Vehicle
Altay Zhakatayev, Mukatai Nemerebayev
https://arxiv.org/abs/2502.15341 https://mastoxiv.page/@arXiv_physicsclassph_bot/114057765769441123
- Hessian stability and convergence rates for entropic and Sinkhorn potentials via semiconcavity
Giacomo Greco, Luca Tamanini
https://arxiv.org/abs/2504.11133 https://mastoxiv.page/@arXiv_mathPR_bot/114346453424694503
- Optimizing the ground state energy of the three-dimensional magnetic Dirichlet Laplacian with con...
Matthias Baur
https://arxiv.org/abs/2504.21597 https://mastoxiv.page/@arXiv_mathph_bot/114431404740241516
- A localized consensus-based sampling algorithm
Arne Bouillon, Alexander Bodard, Panagiotis Patrinos, Dirk Nuyens, Giovanni Samaey
https://arxiv.org/abs/2505.24861 https://mastoxiv.page/@arXiv_mathNA_bot/114612580684567066
- A Novel Sliced Fused Gromov-Wasserstein Distance
Moritz Piening, Robert Beinert
https://arxiv.org/abs/2508.02364 https://mastoxiv.page/@arXiv_csLG_bot/114976243138728278
- Minimal Regret Walras Equilibria for Combinatorial Markets via Duality, Integrality, and Sensitiv...
Alo\"is Duguet, Tobias Harks, Martin Schmidt, Julian Schwarz
https://arxiv.org/abs/2511.09021 https://mastoxiv.page/@arXiv_csGT_bot/115541243299714775
toXiv_bot_toot

Patterns for Defensive Programming in #Rust
https://corrode.dev/blog/defensive-programming/

from my link log —
A C to Brainfuck compiler written in Rust.
https://iacgm.pages.dev/posts/c2bf/
saved 2025-10-13 https://dotat.at/:/OEPJB.html

r-charts.com provides example code for a variety of chart types, both in base R and ggplot: #rstats #ggplot…

R CHARTS | A collection of charts and graphs made with the R programming language
Over 1400 graphs with reproducible code divided in 8 big categories and over 50 chart types, in addition of tools to choose and create colors and color palettes

Detecting Gender Stereotypes in Scratch Programming Tutorials
Isabella Gra{\ss}l, Benedikt Fein, Gordon Fraser
https://arxiv.org/abs/2510.11064 https://arx…

Detecting Gender Stereotypes in Scratch Programming Tutorials
Gender stereotypes in introductory programming courses often go unnoticed, yet they can negatively influence young learners' interest and learning, particularly under-represented groups such as girls. Popular tutorials on block-based programming with Scratch may unintentionally reinforce biases through character choices, narrative framing, or activity types. Educators currently lack support in identifying and addressing such bias. With large language models~(LLMs) increasingly used to generate …

Sequence Variables: A Constraint Programming Computational Domain for Routing and Sequencing
Augustin Delecluse, Pierre Schaus, Pascal Van Hentenryck
https://arxiv.org/abs/2510.09373

Sequence Variables: A Constraint Programming Computational Domain for Routing and Sequencing
Constraint Programming (CP) offers an intuitive, declarative framework for modeling Vehicle Routing Problems (VRP), yet classical CP models based on successor variables cannot always deal with optional visits or insertion based heuristics. To address these limitations, this paper formalizes sequence variables within CP. Unlike the classical successor models, this computational domain handle optional visits and support insertion heuristics, including insertion-based Large Neighborhood Search. We…

Representations
Paul Brunet (UPEC UP12, LACL)
https://arxiv.org/abs/2510.11419 https://arxiv.org/pdf/2510.11419

Representations
The formal analysis of automated systems is an important and growing industry. This activity routinely requires new verification frameworks to be developed to tackle new programming features, or new considerations (bugs of interest). Often, one particular property can prove frustrating to establish: completeness of the logic with respect to the semantics. In this paper, we try and make such developments easier, with a particular attention on completeness. Towards that aim, we propose a formal (…

Concept-Based Generic Programming in C
Bjarne Stroustrup
https://arxiv.org/abs/2510.08969 https://arxiv.org/pdf/2510.08969…

Concept-Based Generic Programming in C++
We present programming techniques to illustrate the facilities and principles of C++ generic programming using concepts. Concepts are C++'s way to express constraints on generic code. As an initial example, we provide a simple type system that eliminates narrowing conversions and provides range checking without unnecessary notational or run-time overheads. Concepts are used throughout to provide user-defined extensions to the type system. The aim is to show their utility and the fundamental ide…

McMining: Automated Discovery of Misconceptions in Student Code
Erfan Al-Hossami, Razvan Bunescu
https://arxiv.org/abs/2510.08827 https://arxiv.org/pdf/251…

McMining: Automated Discovery of Misconceptions in Student Code
When learning to code, students often develop misconceptions about various programming language concepts. These can not only lead to bugs or inefficient code, but also slow down the learning of related concepts. In this paper, we introduce McMining, the task of mining programming misconceptions from samples of code from a student. To enable the training and evaluation of McMining systems, we develop an extensible benchmark dataset of misconceptions together with a large set of code samples wher…

I’ve been testing a theory: many people who are high on #AI and #LLMs are just new to automation and don’t realize you can automate processes with simple programming, if/then conditions, and API calls with zero AI involved.
So far it’s been working!
Whenever I’ve been asked to make an AI flow or find a way to implement AI in our work with a client, I’ve returned back with an automation flow that uses 0 AI.
Things like “when a new document is added here, add a link to it in this spreadsheet and then create a task in our project management software assigned to X with label Y”.
And the people who were frothing at the mouth at how I must change my mind on AI have (so far) all responded with resounding enthusiasm and excitement.
They think it’s the same thing. They just don’t understand how much automation is possible without any generative tools.

Are Large Reasoning Models Interruptible?
Tsung-Han Wu, Mihran Miroyan, David M. Chan, Trevor Darrell, Narges Norouzi, Joseph E. Gonzalez
https://arxiv.org/abs/2510.11713 https:…

Are Large Reasoning Models Interruptible?
Large Reasoning Models (LRMs) excel at complex reasoning but are traditionally evaluated in static, "frozen world" settings: model responses are assumed to be instantaneous, and the context of a request is presumed to be immutable over the duration of the response. While generally true for short-term tasks, the "frozen world" assumption breaks down in modern reasoning tasks such as assistive programming, where models may take hours to think through problems and code may change dramatically from…

google_web: Old Google web graph (2002)
A web graph representing a crawl of a portion of the general WWW, from a 2002 Google Programming contest.
This network has 916428 nodes and 5105039 edges.
Tags: Informational, Web graph, Unweighted
https://networks.skewed.de/net/google_web

These are three arguments for web dev serv. APIs, even if you have to take a critical look at them in detail:
»Speed Comparison: Benchmarking programming languages using the Leibniz formula for calculating π«
— 2025-12-12
📊 https://niklas-heer.github.io/speed-comparison/…

Sequential Convex Programming for 6-DoF Powered Descent Guidance with Continuous-Time Compound State-Triggered Constraints
Samet Uzun, Behcet Acikmese, John M. Carson III
https://arxiv.org/abs/2510.09610

Sequential Convex Programming for 6-DoF Powered Descent Guidance with Continuous-Time Compound State-Triggered Constraints
This paper presents a sequential convex programming (SCP) framework for ensuring the continuous-time satisfaction of compound state-triggered constraints, a subset of logical specifications, in the powered descent guidance (PDG) problem. The proposed framework combines the generalized mean-based smooth robustness measure (D-GMSR), a parameterization technique tailored for expressing discrete-time temporal and logical specifications through smooth functions, with the continuous-time successive c…

Remote Interference Mitigation through Null Precoding and Fractional Programming
Xuyang Sun, Hussein A. Ammar, Israfil Bahceci, Raviraj Adve, Gary Boudreau, Zehua Li
https://arxiv.org/abs/2510.09989

Remote Interference Mitigation through Null Precoding and Fractional Programming
With the rapid deployment of 5G systems, remote interference (RI) caused by atmospheric ducting has emerged as an occasional, but critical challenge. This phenomenon occurs when the downlink (DL) signals from distant base stations (BSs) propagate over long distances through tropospheric ducting, severely disrupting uplink (UL) reception at local BSs. To address this challenge, we analyze the effect of RI on network performance, including the channel estimation phase. We then develop a solution …

PROPL - Workshop on Programming for the Planet welcome by Dominic Orchard @… #icfpsplash25

from my link log —
Let's take esoteric programming languages seriously.
https://arxiv.org/abs/2505.15327
saved 2025-10-11 https://dotat.at/:/XKTKR.…

Let's Take Esoteric Programming Languages Seriously
Esoteric programming languages are challenging to learn, but their unusual features and constraints may serve to improve programming ability. From languages designed to be intentionally obtuse (e.g. INTERCAL) to others targeting artistic expression (e.g. Piet) or exploring the nature of computation (e.g. Fractan), there is rich variety in the realm of esoteric programming languages. This essay examines the counterintuitive appeal of esoteric languages and seeks to analyse reasons for this popul…

Barriers that Programming Instructors Face While Performing Emergency Pedagogical Design to Shape Student-AI Interactions with Generative AI Tools
Sam Lau (University of California San Diego), Kianoosh Boroojeni (Florida International University), Harry Keeling (Howard University), Jenn Marroquin (Google)
https://arxiv.org/abs/2510.09492…

Barriers that Programming Instructors Face While Performing Emergency Pedagogical Design to Shape Student-AI Interactions with Generative AI Tools
Generative AI (GenAI) tools are increasingly pervasive, pushing instructors to redesign how students use GenAI tools in coursework. We conceptualize this work as emergency pedagogical design: reactive, indirect efforts by instructors to shape student-AI interactions without control over commercial interfaces. To understand practices of lead users conducting emergency pedagogical design, we conducted interviews (n=13) and a survey (n=169) of computing instructors. These instructors repeatedly en…

Nice blog in the discussion about AI & coding,
"AI can replace most of programming, but programming isn’t the job.
Programming is a task. It’s one of many things you do as part of your work. But if you’re a software engineer, your actual job is more than typing code into an editor."
https://<…

AI Can Write Your Code. It Can’t Do Your Job.
The companies building AI are spending billions to acquire engineers, not replace them. Here’s why your job is safer than you think.

An $O(n\log n)$ Algorithm for Single-Item Capacitated Lot Sizing with a One-Breakpoint All-Units Discount and Non-Increasing Prices
Kleitos Papadopoulos
https://arxiv.org/abs/2510.11368

An $O(n\log n)$ Algorithm for Single-Item Capacitated Lot Sizing with a One-Breakpoint All-Units Discount and Non-Increasing Prices
This paper addresses the single-item capacitated lot sizing problem with a 1-breakpoint all-units quantity discount in a monotonic setting where the purchase prices are non-increasing over the planning horizon. For this case, we establish several novel properties of the optimal solution and develop a hybrid dynamic programming approach that maintains a compact representation of the solution space by storing only essential information about the states and using linear equations for intermediate …

Verification of Sequential Convex Programming for Parametric Non-convex Optimization
Rajiv Sambharya, Nikolai Matni, George Pappas
https://arxiv.org/abs/2511.10622 https://arxiv.org/pdf/2511.10622 https://arxiv.org/html/2511.10622
arXiv:2511.10622v1 Announce Type: new
Abstract: We introduce a verification framework to exactly verify the worst-case performance of sequential convex programming (SCP) algorithms for parametric non-convex optimization. The verification problem is formulated as an optimization problem that maximizes a performance metric (e.g., the suboptimality after a given number of iterations) over parameters constrained to be in a parameter set and iterate sequences consistent with the SCP update rules. Our framework is general, extending the notion of SCP to include both conventional variants such as trust-region, convex-concave, and prox-linear methods, and algorithms that combine convex subproblems with rounding steps, as in relaxing and rounding schemes. Unlike existing analyses that may only provide local guarantees under limited conditions, our framework delivers global worst-case guarantees--quantifying how well an SCP algorithm performs across all problem instances in the specified family. Applications in control, signal processing, and operations research demonstrate that our framework provides, for the first time, global worst-case guarantees for SCP algorithms in the parametric setting.
toXiv_bot_toot

Generative AI and the Transformation of Software Development Practices
Vivek Acharya
https://arxiv.org/abs/2510.10819 https://arxiv.org/pdf/2510.10819

Generative AI and the Transformation of Software Development Practices
Generative AI is reshaping how software is designed, written, and maintained. Advances in large language models (LLMs) are enabling new development styles - from chat-oriented programming and 'vibe coding' to agentic programming - that can accelerate productivity and broaden access. This paper examines how AI-assisted techniques are changing software engineering practice, and the related issues of trust, accountability, and shifting skills. We survey iterative chat-based development, multi-agen…

SR-Scientist: Scientific Equation Discovery With Agentic AI
Shijie Xia, Yuhan Sun, Pengfei Liu
https://arxiv.org/abs/2510.11661 https://arxiv.org/pdf/2510.…

SR-Scientist: Scientific Equation Discovery With Agentic AI
Recently, Large Language Models (LLMs) have been applied to scientific equation discovery, leveraging their embedded scientific knowledge for hypothesis generation. However, current methods typically confine LLMs to the role of an equation proposer within search algorithms like genetic programming. In this paper, we present SR-Scientist, a framework that elevates the LLM from a simple equation proposer to an autonomous AI scientist that writes code to analyze data, implements the equation as co…

A Multilingual Python Programming Language
Saad Ahmed Bazaz, Mirza Omer Beg
https://arxiv.org/abs/2510.09591 https://arxiv.org/pdf/2510.09591

A Multilingual Python Programming Language
All widely used and useful programming languages have a common problem. They restrict entry on the basis of knowledge of the English language. The lack of knowledge of English poses a major hurdle to many newcomers who do not have the resources, in terms of time and money, to learn the English language. Studies show that people learn better in their own language. Therefore, we propose a language transpiler built on top of the Python programming language, called UniversalPython, which allows one…

Elastic Rod Origami (RodOri) for Programming Static and Dynamic Mechanical Properties
Sophie Leanza, Jeseung Lee, Ruike Renee Zhao
https://arxiv.org/abs/2510.11568 https://

Elastic Rod Origami (RodOri) for Programming Static and Dynamic Mechanical Properties
Reconfigurable mechanical systems enable precise programmable control over structural properties, opening new opportunities in architected materials, adaptive devices, and multifunctional structures. Here, we introduce elastic rod origami (RodOri), a platform that exploits remarkably simple elements (pre-stressed, naturally curved rods) into a system with an extraordinary degree of multistability and configurational richness. For example, a single 6-rod RodOri unit can easily access 11 distinct…

Replaced article(s) found for cs.NE. https://arxiv.org/list/cs.NE/new
[1/1]:
- Enabling Population-Level Parallelism in Tree-Based Genetic Programming for GPU Acceleration
Zhihong Wu, Lishuang Wang, Kebin Sun, Zhuozhao Li, Ran Cheng

Optimal annuitization with labor income under age-dependent force of mortality
Criscent Birungi, Cody Hyndman
https://arxiv.org/abs/2510.10371 https://arxi…

Optimal annuitization with labor income under age-dependent force of mortality
We consider the problem of optimal annuitization with labour income, where an agent aims to maximize utility from consumption and labour income under age-dependent force of mortality. Using a dynamic programming approach, we derive closed-form solutions for the value function and the optimal consumption, portfolio, and labor supply strategies. Our results show that before retirement, investment behavior increases with wealth until a threshold set by labor supply. After retirement, agents tend t…

AI-assisted Programming May Decrease the Productivity of Experienced Developers by Increasing Maintenance Burden
Feiyang (Amber), Xu, Poonacha K. Medappa, Murat M. Tunc, Martijn Vroegindeweij, Jan C. Fransoo
https://arxiv.org/abs/2510.10165

AI-assisted Programming May Decrease the Productivity of Experienced Developers by Increasing Maintenance Burden
Generative AI solutions like GitHub Copilot have been shown to increase the productivity of software developers. Yet prior work remains unclear on the quality of code produced and the challenges of maintaining it in software projects. If quality declines as volume grows, experienced developers face increased workloads reviewing and reworking code from less-experienced contributors. We analyze developer activity in Open Source Software (OSS) projects following the introduction of GitHub Copilot.…

Between #Matlab and #Python, which one would you recommend to learn, for a student who wants to learn programming (from scratch) to do data analysis? And why?
I am conflicted because I think Matlab is maybe slightly more straightforward to learn, but Python should be more useful in the long …

#RedHat Enterprise #Linux 10.1 is out. It among others brings:
* Soft-reboots. This new systemd capability cuts downtime by letting administrators alter system state without fully rebooting.
* Reproducible builds for container tools in image mode.
* Cloud-crossing consistency w…

Quantum Alternating Direction Method of Multipliers for Semidefinite Programming
Hantao Nie, Dong An, Zaiwen Wen
https://arxiv.org/abs/2510.10056 https://a…

Quantum Alternating Direction Method of Multipliers for Semidefinite Programming
Semidefinite programming (SDP) is a fundamental convex optimization problem with wide-ranging applications. However, solving large-scale instances remains computationally challenging due to the high cost of solving linear systems and performing eigenvalue decompositions. In this paper, we present a quantum alternating direction method of multipliers (QADMM) for SDPs, building on recent advances in quantum computing. An inexact ADMM framework is developed, which tolerates errors in the iterates …

RegexPSPACE: A Benchmark for Evaluating LLM Reasoning on PSPACE-complete Regex Problems
Hyundong Jin, Joonghyuk Hahn, Yo-Sub Han
https://arxiv.org/abs/2510.09227 https://…

RegexPSPACE: A Benchmark for Evaluating LLM Reasoning on PSPACE-complete Regex Problems
Large language models (LLMs) show strong performance across natural language processing (NLP), mathematical reasoning, and programming, and recent large reasoning models (LRMs) further emphasize explicit reasoning. Yet their computational limits, particularly spatial complexity constrained by finite context windows, remain poorly understood. While recent works often focus on problems within the NP complexity class, we push the boundary by introducing a novel benchmark grounded in two PSPACE-com…

Playing with Java bytecode
#java #lowlevel_programming

GitHub - SylvainJuge/agent-smith
Contribute to SylvainJuge/agent-smith development by creating an account on GitHub.

DebugTA: An LLM-Based Agent for Simplifying Debugging and Teaching in Programming Education
Lingyue Fu, Haowei Yuan, Datong Chen, Xinyi Dai, Qingyao Li, Weinan Zhang, Weiwen Liu, Yong Yu
https://arxiv.org/abs/2510.11076

DebugTA: An LLM-Based Agent for Simplifying Debugging and Teaching in Programming Education
In programming education, Debugging and Teaching (DT) task is a common scenario where students receive assistance in correcting their erroneous code. The task involves multiple inputs, including erroneous code, error messages, reference solutions, and the question description, with the goal of generating modification suggestions to the erroneous code. However, two key challenges hinder the effectiveness of existing approaches. Firstly, the complexity and heterogeneity of inputs inherent in DT t…

Consume some more #retro #BIOS stuff for your Sunday!
https://int10h.org/blog/2025/11/lost-i

Programming peaked
#javascript #k8s

Great expectations: Unifying Statistical Theory and Programming
Bradley Saul
https://arxiv.org/abs/2510.09853 https://arxiv.org/pdf/2510.09853

Great expectations: Unifying Statistical Theory and Programming
Beginning in the 1970s, statistician-cum-logician Per Martin-Löf wrote a series of papers developing what became Martin-Löf type theory, realizing a system where the distinction between mathematics and programming disappears. Inspired by this vision, this paper introduces dependent type theory (of which Martin-Löf type theory is an example) to a statistical audience. Examples from statistics and probability theory demonstrate how dependent type theory and an algebraic perspective can unify t…

Locally Linear Convergence for Nonsmooth Convex Optimization via Coupled Smoothing and Momentum
Reza Rahimi Baghbadorani, Sergio Grammatico, Peyman Mohajerin Esfahani
https://arxiv.org/abs/2511.10239 https://arxiv.org/pdf/2511.10239 https://arxiv.org/html/2511.10239
arXiv:2511.10239v1 Announce Type: new
Abstract: We propose an adaptive accelerated smoothing technique for a nonsmooth convex optimization problem where the smoothing update rule is coupled with the momentum parameter. We also extend the setting to the case where the objective function is the sum of two nonsmooth functions. With regard to convergence rate, we provide the global (optimal) sublinear convergence guarantees of O(1/k), which is known to be provably optimal for the studied class of functions, along with a local linear rate if the nonsmooth term fulfills a so-call locally strong convexity condition. We validate the performance of our algorithm on several problem classes, including regression with the l1-norm (the Lasso problem), sparse semidefinite programming (the MaxCut problem), Nuclear norm minimization with application in model free fault diagnosis, and l_1-regularized model predictive control to showcase the benefits of the coupling. An interesting observation is that although our global convergence result guarantees O(1/k) convergence, we consistently observe a practical transient convergence rate of O(1/k^2), followed by asymptotic linear convergence as anticipated by the theoretical result. This two-phase behavior can also be explained in view of the proposed smoothing rule.
toXiv_bot_toot

A Trace-based Approach for Code Safety Analysis
Hui Xu
https://arxiv.org/abs/2510.10410 https://arxiv.org/pdf/2510.10410

A Trace-based Approach for Code Safety Analysis
Rust is a memory-safe programming language that disallows undefined behavior. Its safety guarantees have been extensively examined by the community through empirical studies, which has led to its remarkable success. However, unsafe code remains a critical concern in Rust. By reviewing the safety design of Rust and analyzing real-world Rust projects, this paper establishes a systematic framework for understanding unsafe code and undefined behavior, and summarizes the soundness criteria for Rust …

Beyond Revenue and Welfare: Counterfactual Analysis of Spectrum Auctions with Application to Canada's 3800MHz Allocation
Sara Jalili Shani, Kris Joseph, Michael B. McNally, James R. Wright
https://arxiv.org/abs/2512.08106 https://arxiv.org/pdf/2512.08106 https://arxiv.org/html/2512.08106
arXiv:2512.08106v1 Announce Type: new
Abstract: Spectrum auctions are the primary mechanism through which governments allocate scarce radio frequencies, with outcomes that shape competition, coverage, and innovation in telecommunications markets. While traditional models of spectrum auctions often rely on strong equilibrium assumptions, we take a more parsimonious approach by modeling bidders as myopic and straightforward: in each round, firms simply demand the bundle that maximizes their utility given current prices. Despite its simplicity, this model proves effective in predicting the outcomes of Canada's 2023 auction of 3800 MHz spectrum licenses. Using detailed round-by-round bidding data, we estimate bidders' valuations through a linear programming framework and validate that our model reproduces key features of the observed allocation and price evolution. We then use these estimated valuations to simulate a counterfactual auction under an alternative mechanism that incentivizes deployment in rural and remote regions, aligning with one of the key objectives set out in the Canadian Telecommunications Act. The results show that the proposed mechanism substantially improves population coverage in underserved areas. These findings demonstrate that a behavioral model with minimal assumptions is sufficient to generate reliable counterfactual predictions, making it a practical tool for policymakers to evaluate how alternative auction designs may influence future outcomes. In particular, our study demonstrates a method for counterfactual mechanism design, providing a framework to evaluate how alternative auction rules could advance policy goals such as equitable deployment across Canada.
toXiv_bot_toot

"Working with AI is kinda painful, like working with a 200 IQ dementia patient"
- Vince P.
#programming #ai #claudecode

Computations and ML for surjective rational maps
Ilya Karzhemanov
https://arxiv.org/abs/2510.08093 https://arxiv.org/pdf/2510.08093

Computations and ML for surjective rational maps
The present note studies \emph{surjective rational endomorphisms} $f: \mathbb{P}^2 \dashrightarrow \mathbb{P}^2$ with \emph{cubic} terms and the indeterminacy locus $I_f \ne \emptyset$. We develop an experimental approach, based on some Python programming and Machine Learning, towards the classification of such maps; a couple of new explicit $f$ is constructed in this way. We also prove (via pure projective geometry) that a general non-regular cubic endomorphism $f$ of $\mathbb{P}^2$ is surject…

Validation of collision-free spheres of Stewart-Gough platforms for constant orientations using the Application Programming Interface of a CAD software
Bibekananda Patra, Rajeevlochana G. Chittawadigi, Sandipan Bandyopadhyay
https://arxiv.org/abs/2510.08408

Validation of collision-free spheres of Stewart-Gough platforms for constant orientations using the Application Programming Interface of a CAD software
This paper presents a method of validation of the size of the largest collision-free sphere (CFS) of a 6-6 Stewart-Gough platform manipulator (SGPM) for a given orientation of its moving platform (MP) using the Application Programming Interface (API) of a CAD software. The position of the MP is updated via the API in an automated manner over a set of samples within a shell enclosing the surface of the CFS. For each pose of the manipulator, each pair of legs is investigated for mutual collisions…

Running on the battle-tested #Erlang virtual machine that powers planet-scale systems such as WhatsApp and Ericsson, #Gleam is ready for workloads of any size.
https://gleam…

Automatically Generating Questions About Scratch Programs
Florian Oberm\"uller, Gordon Fraser
https://arxiv.org/abs/2510.11658 https://arxiv.org/pdf/2…

Automatically Generating Questions About Scratch Programs
When learning to program, students are usually assessed based on the code they wrote. However, the mere completion of a programming task does not guarantee actual comprehension of the underlying concepts. Asking learners questions about the code they wrote has therefore been proposed as a means to assess program comprehension. As creating targeted questions for individual student programs can be tedious and challenging, prior work has proposed to generate such questions automatically. In this p…

#icfpsplash25 Journal of Functional Programming leaves Cambridge University Press and becomes "scientist owned".

Progress towards generalized Nash-Williams' conjecture on $K_4$-decompositions
Menglong Zhang, Gennian Ge
https://arxiv.org/abs/2510.07783 https://arxi…

Progress towards generalized Nash-Williams' conjecture on $K_4$-decompositions
A $K_4$-decomposition of a graph is a partition of its edges into $K_4$s. A fractional $K_4$-decomposition is an assignment of a nonnegative weight to each $K_4$ in a graph such that the sum of the weights of the $K_4$s containing any given edge is one. Formulating a nonlinear programming and reducing the number of variables slowly, we prove that every graph on $n$ vertices with minimum degree at least $\frac{31}{33}n$ has a fractional $K_4$-decomposition. This improves a result of Montgomery t…

from my link log —
Gleam programming language tour.
https://tour.gleam.run/everything/
saved 2025-10-07 https://dotat.at/:/72CWQ.html

Everything! - The Gleam Language Tour
An interactive introduction and reference to the Gleam programming language.

Allen Media's free streaming app Local Now adds the FAST version of Fox Sports, Fox Weather, LiveNow from Fox, Fox Soul, and a channel re-airing TMZ episodes (Matthew Keys/TheDesk.net)
https://thedesk.net/2025/10/local-now-adds-free-content-streams-f…

Local Now adds free content streams from Fox Corporation
Local Now has expanded its live entertainment and news programming by onboarding new content streams from Fox Corporation.

Automated Repeatable Adversary Threat Emulation with Effects Language (EL)
Suresh K. Damodaran, Paul D. Rowe
https://arxiv.org/abs/2510.06420 https://arxiv…

Automated Repeatable Adversary Threat Emulation with Effects Language (EL)
The emulation of multi-step attacks attributed to advanced persistent threats is valuable for training defenders and evaluating defense tools. In this paper, we discuss the numerous challenges and desired attributes associated with such automation. Additionally, we introduce the use of Effects Language (EL), a visual programming language with graph-based operational semantics, as a solution to address many of these challenges and requirements. We formally define the execution semantics of EL, a…

I did not know the Semble logo was a cairn.
Now I want a pet rock mascot. With googly eyes.
(I should make sure we have googly eyes at the conference)
Also a very good post by @wesleyfinck.org on naming in interfaces and products.
https://notes.wesleyfinck.org/3m6mpbihiy22o

PyMigTool: a tool for end-to-end Python library migration
Mohayeminul Islam, Ajay Kumar Jha, May Mahmoud, Sarah Nadi
https://arxiv.org/abs/2510.08810 https://

PyMigTool: a tool for end-to-end Python library migration
Library migration is the process of replacing a library with a similar one in a software project. Manual library migration is time consuming and error prone, as it requires developers to understand the Application Programming Interfaces (API) of both libraries, map equivalent APIs, and perform the necessary code transformations. Due to the difficulty of the library migration process, most of the existing automated techniques and tooling stop at the API mapping stage or support a limited set of …

LiveOIBench: Can Large Language Models Outperform Human Contestants in Informatics Olympiads?
Kaijian Zou, Aaron Xiong, Yunxiang Zhang, Frederick Zhang, Yueqi Ren, Jirong Yang, Ayoung Lee, Shitanshu Bhushan, Lu Wang
https://arxiv.org/abs/2510.09595

LiveOIBench: Can Large Language Models Outperform Human Contestants in Informatics Olympiads?
Competitive programming problems increasingly serve as valuable benchmarks to evaluate the coding capabilities of large language models (LLMs) due to their complexity and ease of verification. Yet, current coding benchmarks face limitations such as lack of exceptionally challenging problems, insufficient test case coverage, reliance on online platform APIs that limit accessibility. To address these issues, we introduce LiveOIBench, a comprehensive benchmark featuring 403 expert-curated Olympiad…

Reverse Supply Chain Network Design of a Polyurethane Waste Upcycling System
Dalga Merve \"Ozkan, Sergio Lucia, Sebastian Engell
https://arxiv.org/abs/2510.08097 https://…

Reverse Supply Chain Network Design of a Polyurethane Waste Upcycling System
This paper presents a general mathematical programming framework for the design and optimization of supply chain infrastructures for the upcycling of plastic waste. For this purpose, a multi-product, multi-echelon, multi-period mixed-integer linear programming (MILP) model has been formulated. The objective is to minimize the cost of the entire circular supply chain starting from the collection of post-consumer plastic waste to the production of virgin-equivalent high value polymers, satisfying…

Poll: "I'm a server application programmer with a Fediverse account." This means that I mainly develop server-side applications.
Please consider quoting, or boosting for a more statistically significant result.
#programming #backend

HUGR: A Quantum-Classical Intermediate Representation
Mark Koch, Agust\'in Borgna, Seyon Sivarajah, Alan Lawrence, Alec Edgington, Douglas Wilson, Craig Roy, Luca Mondada, Lukas Heidemann, Ross Duncan
https://arxiv.org/abs/2510.11420

HUGR: A Quantum-Classical Intermediate Representation
We introduce the Hierarchical Unified Graph Representation (HUGR): a novel graph based intermediate representation for mixed quantum-classical programs. HUGR's design features high expressivity and extensibility to capture the capabilities of near-term and forthcoming quantum computing devices, as well as new and evolving abstractions from novel quantum programming paradigms. The graph based structure is machine-friendly and supports powerful pattern matching based compilation techniques. Inspi…

Future of Privacy Forum Appoints Matthew Reisman as Vice President of U.S. Policy
https://fpf.org/press-releases/future-of-privacy-forum-appoints-matthew-reisman-as-vice-president-of-u-s-policy/

»Introduction to CSS if() Statements and Conditional Logic«
CSS will probably become logically structurable after a long time. It's not a programming language and that's why it's all the more exciting.
🖌️ https://markodenic.com/introduction-to

Introduction to CSS if Statements and Conditional Logic
Conditional logic is a familiar concept to anyone who has written a programming language. Languages like JavaScript or Python use if/else statements to evaluate expressions and execute different blocks of code depending on whether the condition is true or false.

Cracking CodeWhisperer: Analyzing Developers' Interactions and Patterns During Programming Tasks
Jeena Javahar, Tanya Budhrani, Manaal Basha, Cleidson R. B. de Souza, Ivan Beschastnikh, Gema Rodriguez-Perez
https://arxiv.org/abs/2510.11516

Cracking CodeWhisperer: Analyzing Developers' Interactions and Patterns During Programming Tasks
The use of AI code-generation tools is becoming increasingly common, making it important to understand how software developers are adopting these tools. In this study, we investigate how developers engage with Amazon's CodeWhisperer, an LLM-based code-generation tool. We conducted two user studies with two groups of 10 participants each, interacting with CodeWhisperer - the first to understand which interactions were critical to capture and the second to collect low-level interaction data using…

Geoffrion's theorem beyond finiteness and rationality
Santanu S. Dey, Fr\'ed\'eric Meunier, Diego Moran Ramirez
https://arxiv.org/abs/2510.10966 https://

Geoffrion's theorem beyond finiteness and rationality
Geoffrion's theorem is a fundamental result from mathematical programming assessing the quality of Lagrangian relaxation, a standard technique to get bounds for integer programs. An often implicit condition is that the set of feasible solutions is finite or described by rational linear constraints. However, we show through concrete examples that the conclusion of Geoffrion's theorem does not necessarily hold when this condition is dropped. We then provide sufficient conditions ensuring the vali…

Typestate via Revocable Capabilities
Songlin Jia, Craig Liu, Siyuan He, Haotian Deng, Yuyan Bao, Tiark Rompf
https://arxiv.org/abs/2510.08889 https://arxiv…

Typestate via Revocable Capabilities
Managing stateful resources safely and expressively is a longstanding challenge in programming languages, especially in the presence of aliasing. While scope-based constructs such as Java's synchronized blocks offer ease of reasoning, they restrict expressiveness and parallelism. Conversely, imperative, flow-sensitive management enables fine-grained control but demands sophisticated typestate analyses and often burdens programmers with explicit state tracking. In this work, we present a novel…

I'm a well-known functional programing booster, but this article about the failure of web frameworks is spot on.
https://alfy.blog/2025/10/04/how-functional-programming-shaped-modern-frontend.html

#Python 3.14.0
https://www.python.org/downloads/release/python-3140/

On the Strength of Linear Relaxations in Ordered Optimization
V\'ictor Blanco, Diego Laborda, Miguel Mart\'inez-Ant\'on
https://arxiv.org/abs/2510.09166 https://

On the Strength of Linear Relaxations in Ordered Optimization
We study the conditions under which the convex relaxation of a mixed-integer linear programming formulation for ordered optimization problems, where sorting is part of the decision process, yields integral optimal solutions. Thereby solving the problem exactly in polynomial time. Our analysis identifies structural properties of the input data that influence the integrality of the relaxation. We show that incorporating ordered components introduces additional layers of combinatorial complexity t…

Cost-Efficient Long Code Translation using LLMs while Leveraging Identifier Replacements
Manojit Chakraborty, Madhusudan Ghosh, Rishabh Gupta
https://arxiv.org/abs/2510.09045 ht…

Cost-Efficient Long Code Translation using LLMs while Leveraging Identifier Replacements
In the domain of software development, LLMs have been utilized to automate tasks such as code translation, where source code from one programming language is translated to another while preserving its functionality. However, LLMs often struggle with long source codes that don't fit into the context window, which produces inaccurate translations. To address this, we propose a novel zero-shot code translation method that incorporates identifier replacement. By substituting user-given long identif…

google_web: Old Google web graph (2002)
A web graph representing a crawl of a portion of the general WWW, from a 2002 Google Programming contest.
This network has 916428 nodes and 5105039 edges.
Tags: Informational, Web graph, Unweighted
https://networks.skewed.de/net/google_web<…

Exploring Student Choice and the Use of Multimodal Generative AI in Programming Learning
Xinying Hou, Ruiwei Xiao, Runlong Ye, Michael Liut, John Stamper
https://arxiv.org/abs/2510.05417

Exploring Student Choice and the Use of Multimodal Generative AI in Programming Learning
The broad adoption of Generative AI (GenAI) is impacting Computer Science education, and recent studies found its benefits and potential concerns when students use it for programming learning. However, most existing explorations focus on GenAI tools that primarily support text-to-text interaction. With recent developments, GenAI applications have begun supporting multiple modes of communication, known as multimodality. In this work, we explored how undergraduate programming novices choose and w…

LLMs are All You Need? Improving Fuzz Testing for MOJO with Large Language Models
Linghan Huang, Peizhou Zhao, Huaming Chen
https://arxiv.org/abs/2510.10179 https://

LLMs are All You Need? Improving Fuzz Testing for MOJO with Large Language Models
The rapid development of large language models (LLMs) has revolutionized software testing, particularly fuzz testing, by automating the generation of diverse and effective test inputs. This advancement holds great promise for improving software reliability. Meanwhile, the introduction of MOJO, a high-performance AI programming language blending Python's usability with the efficiency of C and C++, presents new opportunities to enhance AI model scalability and programmability. However, as a new l…

Grid Restoration Under Uncertainty Considering Coupled Transportation-Power Networks
Harshal D. Kaushik, Roshni Anna Jacob, Souma Chowdhury, Jie Zhang
https://arxiv.org/abs/2510.10399

Grid Restoration Under Uncertainty Considering Coupled Transportation-Power Networks
A stochastic mixed-integer programming model is developed to address the power distribution system repair and restoration following failures caused by extreme events such as natural disasters. This model addresses the complex challenge of efficiently assigning and dispatching repair crews to minimize both downtime and the extent of outages, following the crew sequence constraints. By incorporating a realistic transportation network, our model accounts for uncertainties in repair times, repair d…

Oh fun find, there was actually something called Oxide in the history of #Rust already - a formalization attempt:
https://arxiv.org/abs/1903.00982 🦀
cc @…

Oxide: The Essence of Rust
Rust claims to advance industrial programming by bridging the gap between low-level systems programming and high-level application programming. At the heart of the argument that this enables programmers to build more reliable and efficient software is the borrow checker - a novel approach to ownership that aims to balance type system expressivity with usability. And yet, to date there is no core type system that captures Rust's notion of ownership and borrowing, and hence no foundation for rese…

On Dynamic Programming Theory for Leader-Follower Stochastic Games
Jilles Steeve Dibangoye, Thibaut Le Marre, Ocan Sankur, Fran\c{c}ois Schwarzentruber
https://arxiv.org/abs/2512.05667 https://arxiv.org/pdf/2512.05667 https://arxiv.org/html/2512.05667
arXiv:2512.05667v1 Announce Type: new
Abstract: Leader-follower general-sum stochastic games (LF-GSSGs) model sequential decision-making under asymmetric commitment, where a leader commits to a policy and a follower best responds, yielding a strong Stackelberg equilibrium (SSE) with leader-favourable tie-breaking. This paper introduces a dynamic programming (DP) framework that applies Bellman recursion over credible sets-state abstractions formally representing all rational follower best responses under partial leader commitments-to compute SSEs. We first prove that any LF-GSSG admits a lossless reduction to a Markov decision process (MDP) over credible sets. We further establish that synthesising an optimal memoryless deterministic leader policy is NP-hard, motivating the development of {\epsilon}-optimal DP algorithms with provable guarantees on leader exploitability. Experiments on standard mixed-motive benchmarks-including security games, resource allocation, and adversarial planning-demonstrate empirical gains in leader value and runtime scalability over state-of-the-art methods.
toXiv_bot_toot

End-to-end Compositional Verification of Program Safety through Verified and Verifying Compilation
Jinhua Wu, Yuting Wang, Liukun Yu, Linglong Meng
https://arxiv.org/abs/2510.10015

End-to-end Compositional Verification of Program Safety through Verified and Verifying Compilation
Program safety (i.e., absence of undefined behaviors) is critical for correct operation of computer systems. It is usually verified at the source level (e.g., by separation logics) and preserved to the target by verified compilers (e.g., CompCert), thereby achieving end-to-end verification of safety. However, modern safe programming languages like Rust pose new problems in achieving end-to-end safety. Because not all functionalities can be implemented in the safe language, mixing safe and unsaf…

Interoperability From OpenTelemetry to Kieker: Demonstrated as Export from the Astronomy Shop
David Georg Reichelt, Shinhyung Yang, Wilhelm Hasselbring
https://arxiv.org/abs/2510.11179

Interoperability From OpenTelemetry to Kieker: Demonstrated as Export from the Astronomy Shop
The observability framework Kieker provides a range of analysis capabilities, but it is currently only able to instrument a smaller selection of languages and technologies, including Java, C, Fortran, and Python. The OpenTelemetry standard aims for providing reference implementations for most programming languages, including C# and JavaScript, that are currently not supported by Kieker. In this work, we describe how to transform OpenTelemetry tracing data into the Kieker framework. Thereby, it …

The Branch-and-Bound Tree Closure
Marius Roland, Nagisa Sugishita, Alexandre Forel, Youssouf Emine, Ricardo Fukasawa, Thibaut Vidal
https://arxiv.org/abs/2510.11497 https://

The Branch-and-Bound Tree Closure
This paper investigates the a-posteriori analysis of Branch-and-Bound~(BB) trees to extract structural information about the feasible region of mixed-binary linear programs. We introduce three novel outer approximations of the feasible region, systematically constructed from a BB tree. These are: a tight formulation based on disjunctive programming, a branching-based formulation derived from the tree's branching logic, and a mixing-set formulation derived from the on-off properties inside the t…

An Efficient Solution Method for Solving Convex Separable Quadratic Optimization Problems
Shaoze Li, Junhao Wu, Cheng Lu, Zhibin Deng, Shu-Cherng Fang
https://arxiv.org/abs/2510.11554

An Efficient Solution Method for Solving Convex Separable Quadratic Optimization Problems
Convex separable quadratic optimization problems occur in many practical applications. In this paper, based on an iterative resolution scheme of the KKT system, we develop an efficient method for solving a quadratic programming problem with a convex separable objective function subject to multiple convex separable constraints. We show that the proposed approach leads to a dual coordinate ascent algorithm and provide a convergence proof. Numerical experiments support the superior performance of …

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- When Lifetimes Liberate: A Type System for Arenas with Higher-Order Reachability Tracking
Siyuan He, Songlin Jia, Yuyan Bao, Tiark Rompf

The purpose of an ORM is to use an SQL database without benefiting from SQL database.
#ORM #SQL #Programming

CodeWatcher: IDE Telemetry Data Extraction Tool for Understanding Coding Interactions with LLMs
Manaal Basha, Aime\^e M. Ribeiro, Jeena Javahar, Cleidson R. B. de Souza, Gema Rodr\'iguez-P\'erez
https://arxiv.org/abs/2510.11536

CodeWatcher: IDE Telemetry Data Extraction Tool for Understanding Coding Interactions with LLMs
Understanding how developers interact with code generation tools (CGTs) requires detailed, real-time data on programming behavior which is often difficult to collect without disrupting workflow. We present \textit{CodeWatcher}, a lightweight, unobtrusive client-server system designed to capture fine-grained interaction events from within the Visual Studio Code (VS Code) editor. \textit{CodeWatcher} logs semantically meaningful events such as insertions made by CGTs, deletions, copy-paste action…

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- PolyVer: A Compositional Approach for Polyglot System Modeling and Verification
Chen, Lin, Godbole, Singh, Polgreen, Lee, Seshia

from my link log —
The Gleam programming language is my new obsession.
https://ericcodes.io/blog/gleam-my-new-obsession.html
saved 2025-10-07 ht…

Crosslisted article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- Which Is Better For Reducing Outdated and Vulnerable Dependencies: Pinning or Floating?
Imranur Rahman, Jill Marley, William Enck, Laurie Williams

google_web: Old Google web graph (2002)
A web graph representing a crawl of a portion of the general WWW, from a 2002 Google Programming contest.
This network has 916428 nodes and 5105039 edges.
Tags: Informational, Web graph, Unweighted
https://networks.skewed.de/net/google_web

Crosslisted article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- Hound: Relation-First Knowledge Graphs for Complex-System Reasoning in Security Audits
Bernhard Mueller
…

from my link log —
Optimizing triangles for a full-screen shader pass.
https://wallisc.github.io/rendering/2021/04/18/Fullscreen-Pass.html
saved 2025-09-29

Inductive Learning for Possibilistic Logic Programs Under Stable Models
Hongbo Hu, Yisong Wang, Yi Huang, Kewen Wang
https://arxiv.org/abs/2510.07069 https://

Inductive Learning for Possibilistic Logic Programs Under Stable Models
Possibilistic logic programs (poss-programs) under stable models are a major variant of answer set programming (ASP). While its semantics (possibilistic stable models) and properties have been well investigated, the problem of inductive reasoning has not been investigated yet. This paper presents an approach to extracting poss-programs from a background program and examples (parts of intended possibilistic stable models). To this end, the notion of induction tasks is first formally defined, its…

ConstraintLLM: A Neuro-Symbolic Framework for Industrial-Level Constraint Programming
Weichun Shi, Minghao Liu, Wanting Zhang, Langchen Shi, Fuqi Jia, Feifei Ma, Jian Zhang
https://arxiv.org/abs/2510.05774

ConstraintLLM: A Neuro-Symbolic Framework for Industrial-Level Constraint Programming
Constraint programming (CP) is a crucial technology for solving real-world constraint optimization problems (COPs), with the advantages of rich modeling semantics and high solving efficiency. Using large language models (LLMs) to generate formal modeling automatically for COPs is becoming a promising approach, which aims to build trustworthy neuro-symbolic AI with the help of symbolic solvers. However, CP has received less attention compared to works based on operations research (OR) models. We…

from my link log —
The IMP programming language and compiler.
https://www.ancientgeek.org.uk/EMAS/EMAS_Papers/The_IMP_language_and_compiler.pdf
saved 2025-12-07

The Functional Machine Calculus III: Control
Willem Heijltjes
https://arxiv.org/abs/2510.07851 https://arxiv.org/pdf/2510.07851

The Functional Machine Calculus III: Control
The Functional Machine Calculus (Heijltjes 2022) is a new approach to unifying the imperative and functional programming paradigms. It extends the lambda-calculus, preserving the key features of confluent reduction and typed termination, to embed computational effects, evaluation strategies, and control flow operations. The first instalment modelled sequential higher-order computation with global store, input/output, probabilities, and non-determinism, and embedded both the call-by-name and cal…

AutoMLGen: Navigating Fine-Grained Optimization for Coding Agents
Shangheng Du, Xiangchao Yan, Dengyang Jiang, Jiakang Yuan, Yusong Hu, Xin Li, Liang He, Bo Zhang, Lei Bai
https://arxiv.org/abs/2510.08511

AutoMLGen: Navigating Fine-Grained Optimization for Coding Agents
Large language models (LLMs) have shown impressive performance in general programming tasks. However, in Machine Learning Engineering (MLE) scenarios such as AutoML and Kaggle competitions, achieving high performance depends heavily on expert intervention and repeated adjustments rather than simply generating correct code. When applied directly to these tasks, LLMs often lack fine-grained domain priors, and existing MLE approaches that use linear or tree-structured searches limit knowledge tran…

“ALGOL 68 — A language specification intended as an improvement on ALGOL 60 that seemed to make everyone involved in the effort unhappy.”
https://cacm.acm.org/article/lessons-from-pl-i-a-most-ambitious-programming-language/

A combinatorial approach to Ramana's exact dual for semidefinite programming
Gabor Pataki
https://arxiv.org/abs/2510.07271 https://arxiv.org/pdf/2510.0…

A combinatorial approach to Ramana's exact dual for semidefinite programming
Thirty years ago, in a seminal paper Ramana derived an exact dual for Semidefinite Programming (SDP). Ramana's dual has the following remarkable features: i) it is an explicit, polynomial size semidefinite program ii) it does not assume that the primal is strictly feasible, nor does it make any other regularity assumptions iii) yet, it has strong duality with the primal. The complexity implications of Ramana's dual are fundamental, and to date still the best known. The most important of these i…

RustAssure: Differential Symbolic Testing for LLM-Transpiled C-to-Rust Code
Yubo Bai, Tapti Palit
https://arxiv.org/abs/2510.07604 https://arxiv.org/pdf/25…

RustAssure: Differential Symbolic Testing for LLM-Transpiled C-to-Rust Code
Rust is a memory-safe programming language that significantly improves software security. Existing codebases written in unsafe memory languages, such as C, must first be transpiled to Rust to take advantage of Rust's improved safety guarantees. RustAssure presents a system that uses Large Language Models (LLMs) to automatically transpile existing C codebases to Rust. RustAssure uses prompt engineering techniques to maximize the chances of the LLM generating idiomatic and safe Rust code. Moreove…

from my link log —
Thinking with Types: type-level programming in Haskell.
https://thinkingwithtypes.com/
saved 2019-05-26 https://dotat.at/:/PZEX4.html

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- Weak-Linear Types
Hector Gramaglia
https://arxiv.org/abs/2402…

Inverse Mixed-Integer Programming: Learning Constraints then Objective Functions
Akira Kitaoka
https://arxiv.org/abs/2510.04455 https://arxiv.org/pdf/2510.…

Inverse Mixed-Integer Programming: Learning Constraints then Objective Functions
In mixed-integer linear programming, data-driven inverse optimization that learns the objective function and the constraints from observed data plays an important role in constructing appropriate mathematical models for various fields, including power systems and scheduling. However, to the best of our knowledge, there is no known method for learning both the objective functions and the constraints. In this paper, we propose a two-stage method for a class of problems where the objective functio…

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- Types, equations, dimensions and the Pi theorem
Nicola Botta, Patrik Jansson, Guilherme Horta Alvares Da Silva

A Sequential Quadratic Programming Perspective on Optimal Control
Abhijeet, Suman Chakravorty
https://arxiv.org/abs/2510.03475 https://arxiv.org/pdf/2510.0…

A Sequential Quadratic Programming Perspective on Optimal Control
This paper offers a unified perspective on different approaches to the solution of optimal control problems through the lens of constrained sequential quadratic programming. In particular, it allows us to find the relationships between Newton's method, the iterative LQR (iLQR), and Differential Dynamic Programming (DDP) approaches to solve the problem. It is shown that the iLQR is a principled SQP approach, rather than simply an approximation of DDP by neglecting the Hessian terms, to solve opt…

PLSEMANTICSBENCH: Large Language Models As Programming Language Interpreters
Aditya Thimmaiah, Jiyang Zhang, Jayanth Srinivasa, Junyi Jessy Li, Milos Gligoric
https://arxiv.org/abs/2510.03415

PLSEMANTICSBENCH: Large Language Models As Programming Language Interpreters
As large language models (LLMs) excel at code reasoning, a natural question arises: can an LLM execute programs (i.e., act as an interpreter) purely based on a programming language's formal semantics? If so, it will enable rapid prototyping of new programming languages and language features. We study this question using the imperative language IMP (a subset of C), formalized via small-step operational semantics (SOS) and rewriting-based operational semantics (K-semantics). We introduce three ev…

Generalized Multi-Constraint Extremum Seeking
Alan Williams, Jorge Cort\'es, Alexander Scheinker
https://arxiv.org/abs/2510.06403 https://arxiv.org/pdf…

Generalized Multi-Constraint Extremum Seeking
We generalize the Safe Extremum Seeking algorithm to address the minimization of an unknown objective function subject to multiple unknown inequality and equality constraints, relying on recent results of gradient flow systems. These constraints may represent safety or other critical conditions. The proposed ES algorithm functions as a general nonlinear programming tool, offering practical maintenance of all constraints and semiglobal practical asymptotic stability, utilizing a Lyapunov argumen…

Type, Ability, and Effect Systems: Perspectives on Purity, Semantics, and Expressiveness
Yuyan Bao, Tiark Rompf
https://arxiv.org/abs/2510.07582 https://ar…

Type, Ability, and Effect Systems: Perspectives on Purity, Semantics, and Expressiveness
Programming benefits from a clear separation between pure, mathematical computation and impure, effectful interaction with the world. Existing approaches to enforce this separation include monads, type-and-effect systems, and capability systems. All share a tension between precision and usability, and each one has non-obvious strengths and weaknesses. This paper aims to raise the bar in assessing such systems. First, we propose a semantic definition of purity, inspired by contextual equivalen…