Modern infrastructure depends on externally maintained artifacts such as package-registry dependencies, CI/CD actions, container images, Terraform providers and modules, developer extensions, model artifacts, and AI tool servers. These artifacts are easy to fetch but difficult for institutions to admit, govern, and revoke. This paper proposes the Custody Envelope Threshold, an authority-scaled model of artifact admission. It argues that direct institutional admission is defensible only when object identity, ingress path, and revocation capacity are sufficiently closed relative to the execution authority delegated to the artifact. When this threshold is not met, institutions tend to proxy, policy-mediate, vendor-mediate, internalize, quarantine, or reject the artifact. The framework is operationalized as a four-condition ordinal instrument and connected to reference-monitor reasoning, least privilege, and transaction cost economics. It is applied to package dependencies, GitHub Actions, container images, Terraform providers and modules, developer extensions, and open model artifacts, with Model Context Protocol (MCP) servers treated as held-out evidence. The paper also specifies a validation design, deterministic prediction function, and OSF replication package for testing whether high-scrutiny institutions converge toward stronger custody closure for high-authority artifacts.

In this short experience paper, we present Pomona, a lightweight agentic tool that utilises agent skills for continuous automated code quality improvement. Inspired by the philosophy of Kaizen(TM), Pomona automates a cycle of discovery and incremental repair: a Scanning skill identifies improvement tasks (e.g., linting violations, technical debt markers, and test gaps) and prioritises them in a structured backlog, while a Repair skill generates tiny pull requests (PRs) targeting ~10 lines of diff. This human-in-the-loop design enables frequent, low-risk improvements while maintaining engineer trust and productivity and reducing technical debt. We evaluated Pomona through a one-month deployment in a team and a questionnaire distributed to 10 senior engineers. Our preliminary results are promising: 15 of 17 generated PRs were successfully merged with a median time-to-close of under 2 hours. Furthermore, 8/10 of surveyed engineers expressed a desire to adopt Pomona, praising small diff sizes and Pomona's focus on improving code quality. We conclude by discussing actionable insights for researchers and practitioners on strategies for effective agentic deployment in industry.

When a distributed training job slows down, the hard part is knowing where to look. Synchronization hides the cause: a stall on one rank shows up as a wait on the others, so a data delay on a single rank can surface as backward time across the group. The cheap dashboards that run all the time -- per-stage averages and maxima -- misread this, double-counting the same exposed delay or burying the slow rank in an average, while full profilers see it clearly but are far too heavy to leave on. StageFrontier is an always-on signal that closes this gap. Each rank reports only a short ordered vector of coarse stage durations -- data, forward, backward, and so on -- timed with CPU wall-clock, with no synchronized clocks and no kernel tracing. At each stage boundary, StageFrontier takes the cumulative time of whichever rank is furthest along; the increments of this frontier form an exact, additive accounting of the step's exposed time and point to the stage and rank where group-visible delay first appears, telling an operator where to aim a heavy profiler, not which fix to make. The accounting is exact, but the coarse signal alone cannot tell whether a leading stage truly caused the slowdown or merely ran alongside it; StageFrontier labels the windows where that distinction needs more evidence instead of guessing. A PyTorch implementation adds under 0.2% throughput overhead through 128 ranks on Gloo and NCCL, places injected faults among its top two suspects on all 50 rows of a hidden-rank DDP test, and recovers the same top-stage routing as PyTorch Profiler, HTA, and Nsight Systems once their traces are reduced to the same coarse stages -- from a 0.11 MB summary instead of a 15.81 GB trace.

Deep learning (DL) compilers such as TVM and ONNX-MLIR lower tensor computation graphs into optimized executables for target backends. Testing these AI compilers has made substantial progress in generating well-formed inputs in the context of fuzzing; however, such generation alone does not catch semantic drifts from algebraic invariants that graph transformations and optimizations are expected to preserve. While tensor algebra has been studied for decades, it has not been transformed into executable property-based tests (PBTs) for DL compilers because doing so requires jointly constructing operators, inputs, and test oracles. The central challenge is no longer generating well-formed inputs for fuzzing DL compilers, but bootstrapping executable PBTs with such inputs and oracles based on tensor algebra. We realize this vision in Propilot, an LLM-driven agentic property-based testing framework for DL compilers with GPT 5.5. First, Propilot represents tensor algebra knowledge as reusable property skeletons, each coupled with operator constraints, shape and value rules, and oracle templates. Second, given a target compiler, Propilot instantiates these skeletons into executable PBTs by generating paired tensor computation graphs, concrete tensor inputs, and expected semantic relations as oracles. Next, to prevent generated tests from degenerating into invalid or uninformative PBTs, Propilot validates each PBT candidate before execution for applicability and safety. Validation feedback, execution results, and coverage signals guide subsequent generation. We evaluate Propilot on TVM with 212 operators and 20 property skeletons, generating 4,579 PBTs. Compared with direct LLM-based PBT generation, Propilot reduces redundancy by 49% and eliminates invalid tests through explicit property skeletons. This effectiveness translates into finding semantic errors and numerical discrepancies.

Configuring network access control policies in large, complex networks is error-prone and requires significant expert effort. LLMs offer a promising interface for expressing such policies in natural language, but their capability for translating user requests into access policies, and the system architectures best suited to leverage LLMs, remain underexplored. We present an architecture for natural-language access control (NLAC) that uses LLMs to translate user requests into access policies, and introduce NLACBench, a benchmark for evaluating LLM-based intent translation systems in large-scale networks. Our evaluation across multiple state-of-the-art models shows that top-performing LLMs achieve up to 96.9% accuracy in small-network settings, but performance degrades substantially (below 20% for some models) as network size increases. To address this limitation, we identify relevant network components via embedding similarity and construct compact subgraphs that are passed to the LLM. This approach enables scaling to larger networks with up to 98.7% accuracy, while simultaneously reducing inference time, hardware requirements, and operating costs to a constant resource budget. Finally, a case study indicates that top-performing models exhibit largely complementary error patterns, suggesting that intent translation accuracy may be further improved through multi-LLM architectures.

This paper develops the Dynamic Gaussian Process (DGP), a framework for estimating functions governed by integro-difference equations (IDEs). IDEs model continuous functions that evolve with discrete-time dynamics and arise naturally from time-discretization of linear partial differential equations (PDEs). The DGP extends Gaussian process regression to time-varying functions and extends Kalman filtering to infinite-dimensional states. The DGP posterior remains a Gaussian process with closed-form mean and covariance updates, and separable kernel structure reduces the problem to a finite-dimensional Kalman filter on basis function coefficients. This paper extends the DGP to vector-valued states, enabling the treatment of higher-order PDEs, and provides a stability and approximation error analysis for the basis function approximation. The functional L2 estimation error decomposes exactly into in-subspace and out-of-subspace contributions, and all approximation errors vanish as the number of basis functions grows. The framework is demonstrated on the heat equation and on the wave equation, the latter with a vector-valued state. Code is available at https://github.com/JvHulst/Dynamic_Gaussian_Processes.

This paper examines what happens when GenAI tools are fully embedded in the drafting of an academic paper rather than confined to late-stage polishing. To investigate how an intensive multi-tool GenAI workflow differs from conventional academic writing, I drafted this paper from the first sentence in parallel with three GenAI tools - Claude, ChatGPT, and Gemini - comparing their outputs against my own intended contribution. Across this process, a recurring pattern took shape that I call adversarial co-thinking: using past peer reviews to calibrate the tools, then setting their outputs against one another to be tested rather than deferred to. I argue that surfacing genuine critique from tools that default to praise is a central practical challenge of working with these tools, and that the skill at stake is evaluative rather than generative. Adversarial co-thinking is a high-skill epistemic practice: it can amplify expertise where it exists, but it can also mask its absence. I further argue that current disclosure frameworks are poorly equipped to capture this shift. The paper offers four propositions for workshop discussion concerning autonomy, supervision, equity of access, and disclosure.

Proof-of-work (PoW) blockchains rely on computational expenditure to secure a ledger supporting a native cryptocurrency. In existing systems such as Bitcoin, this expenditure is intentionally useless: the computation secures consensus but produces no external economic output. An emerging alternative -- proof of useful work (PoUW) -- enables the same computation to simultaneously secure the blockchain and generate economically valuable output. However, PoUW is often criticized on economic grounds: if the work is useful, attackers might be "paid to attack," potentially weakening security. We develop a competitive-equilibrium model of a PoUW blockchain in which compute can be allocated across pure mining, pure useful work -- instantiated as machine-learning inference -- or "duplex" work that produces both with computational overheads. We provide a complete closed-form characterization of equilibrium allocations and prices as a function of the duplex overheads and a single economic parameter -- the token-inference ratio -- measuring token adoption relative to the inference market. This characterization reveals three regimes: "Bitconia," in which the economy reduces to classical PoW; "Fortessia," in which duplex replaces mining, increasing security while useful output remains unchanged; and "Duplexia," in which token rewards subsidize inference, lowering prices and expanding inference supply. Contrary to the common strawman argument, PoUW does not make attacks economically cheap: once equilibrium prices are taken into account, the economic cost of a majority attack remains tied to the block reward. Moreover, in Duplexia, block rewards act as rebates on inference prices, generating additional socially useful computation that would not arise without the blockchain -- an expansion monotonically increasing in token adoption and technological efficiency.

Modern GPU applications increasingly interact with storage systems, network devices, vendor libraries, and GPU-resident services rather than executing only isolated compute kernels. This shift creates a need for operating-system-like protection around GPU services, where service metadata, device queues, memory-mapped I/O regions, and library-internal state should not be directly exposed to untrusted application kernels. However, today's CUDA programming model, by default, still gives each application direct ownership of its CUDA context, device pointers, runtime handles, module loading path, and kernel launches, leaving protected GPU services to build their own ad hoc interfaces and isolation mechanisms. This paper presents the initial design and prototype scope of AgileOS, a GPU operating-system layer for protected CUDA services. AgileOS virtualizes CUDA at the library boundary: applications link against client-side CUDA Runtime, Driver, and selected library shims, while a trusted runtime worker owns the real CUDA context and mediates supported operations. To protect service state and module interfaces, AgileOS also defines a GPU memory-management model that separates user allocations from protected module/MMIO ranges, using pointer validation and memory access guards via PTX injection. AgileOS is modularized and flexible, supporting a range of protected services and existing libraries such as cuFFT and PyTorch. The prototype includes client-side interceptors, worker-side CUDA handlers, virtualized CUDA object tables, protected AgileOS modules, a GPU memory manager that separates user allocations from protected module/MMIO ranges, selected trusted library adapters, and the PTX-level kernel memory guard.

Motivated by the critical need for energy-efficient scheduling in cloud computing, this paper investigates Span Minimization, a fundamental variant of the well-studied BusyTime problem. In the general BusyTime problem, $n$ jobs characterized by release times, deadlines, and processing times must be partitioned into bundles of capacity $B$, where the objective is to minimize the total active duration of the virtual machines. Span minimization addresses the specific case of unbounded capacity ($B = \infty$), a problem that serves as a vital precursor for achieving high-performance approximation guarantees in more complex scheduling environments. While previous research established a deterministic $2$-approximation for interval jobs and a $3$-approximation for the general BusyTime problem, the online landscape of span minimization remains less explored. In this paper, we focus on the online version of span minimization. We demonstrate that randomization can be leveraged to break the known deterministic competitive barrier of $2$. For uniform-length jobs, we derive a randomized competitive upper bound of $\frac{1}{\ln{2}}\approx 1.443$ and a lower bound of $\frac{\sqrt{3}+1}{2}\approx 1.366$. Furthermore, we show that by introducing the ability to restart jobs, we can achieve an optimal competitive ratio equal to the golden ratio ($ϕ\approx 1.618$). Our results provide new insights into the power of randomization and flexibility in online energy-aware scheduling.

AI agents are beginning to interact not only with people, but also with one another. We investigate what happens to sentiment in such an AI-only social network: does negativity spread, or do replies calm it down? We study MOLTBOOK, a social network made up of autonomous language-model agents, using almost 2.9 million posts and 1.5 million comments. Negative posts receive many more replies than neutral or positive posts, so negativity still attracts attention. However, replies to negative content usually do not stay negative. They most often become neutral, and there is meager evidence that negative sentiment spreads across days. The main pattern is therefore not a cycle of negativity, but negative attention followed by neutralisation. These findings suggest that AI-agent networks may behave differently from human social networks: they may dampen emotional extremes, while still depending strongly on how interactions are organised.

Modern software development relies on CI/CD pipelines to automate testing, building, and deployment operations. Configuring DevOps pipelines is challenging and time-consuming, as developers must understand platform-specific syntax and manually create configuration files. This complexity can lead to configuration errors and reduced productivity, especially for developers with limited DevOps experience. This paper introduces the AutoPipelineAI system, which generates CI/CD pipeline configurations using natural language descriptions. The proposed solution uses large language models (LLMs) to translate developer intent, analyze repository structures, and create specific pipeline scripts for environments like GitHub Actions and GitLab CI/CD. It integrates repository-aware analysis, automated validation systems, and a feedback mechanism that confirms the accuracy and usability of the created pipelines. We present the system architecture, its implementation, and an assessment framework designed to measure generation precision, configuration validity, and reduction in setup effort compared to manual pipeline creation. AutoPipelineAI illustrates how LLMs can simplify the complexity of DevOps configuration and enhance developer access to continuous delivery methods. Evaluation results provide early evidence that repository-aware, natural-language-driven CI/CD generation is a viable and promising paradigm for reducing the complexity of DevOps configuration and enabling more accessible software delivery automation.

We present LinkNav, an enhanced experience for reading academic papers which makes explicit connections between related but non-adjacent passages. To create the experience, we instruct a language model to generate questions that may arise while reading a passage and then search for answer passages elsewhere in the document, forming intra-document connections when answers are found. We confirm that these building blocks work well to power the experience, with an answer detection pipeline that works with high precision, resulting in a reasonable number of connections being made for a document. On a dataset of academic papers, we find that connected passages are on average ten segments away from each other, making explicit connections that a reader may have otherwise missed.

This work provides a comparative review of three different numerical methods generally used to discretize continuous-time non-linear equations appearing in model predictive control problems: direct multiple shooting, direct collocation and successive linearizations. An overview of the characteristics of each method is given and the performance of each method is evaluated through the simulation of two test cases.

We analyze competing auctions in intermediated markets, where a seller selects among parallel mechanisms for the sale of a single good, most prominently the relay-and-protocol architecture of proposer-builder separation in Ethereum. When the intermediary can enforce single-homing on its bidders, sealed-bid second-price intermediary auctions fully unravel into the sealed first-price principal auction; open bidding-format intermediaries unravel only partially, collapsing into first-price in equilibrium under symmetric latency and sorting fast bidders to the intermediary under asymmetric latency. Any last-look advantage is removed through the availability of a credible sealed bidding channel. These results extend to multi-plexing environments (no enforcement by the intermediary). While the unraveling result indicates that the availability of a sealed first-price bidding channel pushes the overall market to the same auction structure, the very assumption of the credibility of such channel is problematic, as the seller may have an incentive to leak information: a first-price auction is leakage-resistant in the presence of a single ``fast'' bidder but not against two or more. However, if the seller can credibly commit to not leak bids, it is optimal for them to do so. A main motivation is the forthcoming Glamsterdam update of Ethereum: our analysis suggests that the availability of an in-protocol (first-price) bidding channel severely limits the design space for out-of-protocol auctions by relays and other intermediaries.

The present study provides a closed-form characterisation of Nash equilibria in N-player binary games with unidirectional dependencies. While general network games are PPAD-complete, prior work has established that trees or paths admit polynomial-time solutions via dynamic programming. We provide a deterministic characterisation for the subclass of directed cycle graphical games, demonstrating that non-zero boundary incentives linearize the topology into a feed-forward propagation. Under this Robust Incentive Structure, resolution is achieved in O(N) time: strict dominance guarantees a unique equilibrium; in its absence, pure strategy equilibria are governed by the Parity Condition, while a unique fully mixed equilibrium is guaranteed via induced payoff indifference. For non-robust regimes, we deliver branching rules. The transition-matrix formulation evaluates the search tree size beforehand. This transparency enables the inverse design of target equilibria in circular networks, making explicit the mechanics that remain opaque in numerical solvers.

We present RTLScout, an autonomous system that combines LLM-driven agentic design with circuit-level synthesis optimization and arithmetic architecture sweeps. An LLM agent iteratively writes, evaluates, and refines RTL designs using tool calls, guided by quantitative PPA (power, performance, area) feedback from Yosys and OpenROAD. We introduce a multi-run elite pool framework, where the best designs and lessons learned seed subsequent agent runs. The pipeline comprises four complementary phases: agentic code optimization, agentic gate-level rewriting, arithmetic architecture sweeps, and an optional high-effort gate-level refinement pass. On an IEEE-754-compliant 16-bit floating-point multiplier with subnormal support, RTLScout reduces area by 35% and delay by 45% relative to a starting design synthesized in ASAP7 technology. Each phase provides distinct improvements, and high-effort gate-level optimization is most effective as a refinement of already well-optimized designs rather than a substitute for earlier stages. The resulting Pareto front outperforms a commercial-tool reference design on the same technology.

In resource-constrained small-satellite settings, AI inference must operate under tight size, power, and payload budgets, which tend to limit onboard compute capability and data handling. These conditions motivate establishing a clear baseline for quantized AI inference under bounded compute and memory resources. To instantiate this baseline, a representative embedded-vision neural-network workload serves as the reference case. With this motivation, this paper presents a measurement-based characterization of quantized execution for this AI workload on highly constrained embedded platforms (for instance, Cortex-M), grounded as a lower-bound operating point. In this regime, scaling tends to rely on explicit orchestration rather than OS-managed, transparent multicore scheduling, and timing behavior is shaped by instruction efficiency and memory movement. As a result, the characterization provides a structured reference for estimating execution time across orchestrated configurations (e.g., multiple cores and/or devices), treating orchestration and architectural variation as explicit design choices. We report latency metrics alongside data-movement observations, and interpret these measurements in light of ALU/SIMD utilization under quantized arithmetic for the Cortex-M. Finally, we outline how this baseline provides a reference point for positioning the results against more space-typical embedded processor classes (e.g., LEON/NOEL-V).

Several elegant inductive proofs of Dilworth's theorem can be found in the literature. In this note, I present another inductive proof with an algorithmic flavor based on a merging lemma.

Obtaining intersection-freeness or global injectivity is important in computer graphics. However, it is challenging, especially for the non-oriented deformation primitives. Most methods often rely on an intersection-free initialization and track the continuous trajectory to keep the legitimacy and cannot be used for the task without such an initialization. For the latter one in 3D space, we introduce a novel second-order differentiable energy defined from the 3D triangle-triangle intersection testing, and a GPU-based inexact Newton optimization route. We show that intersection can be efficiently resolved integrated with our method, requiring no user interaction, history information or a valid initialization.

Geant4 Monte Carlo simulation relies on the Constructive Solid Geometry (CSG) method for complex geometric modeling. This method has low efficiency and a high application threshold. Importing triangular facet formats such as STL/OBJ via CADmesh is a promising alternative, but systematic evaluations of format compatibility, geometric accuracy, and physical simulation deviations are lacking. Construct open-source experimental environment based on Geant4 11.0, CADmesh 1.3.0 and FreeCAD 1.0. We design high and low precision gradient test cases using simple geometric bodies and complex engineering models, and systematically evaluate the import success rate, facet loss rate, volume error, and particle transport dose deviation for STL and OBJ formats.The results show a 100% import success rate for both formats; the volume error rate is <= 0.018% for high-precision models and <= 0.288% for low-precision models. The two formats share the same vertex facet data structure. This study designs a general adaptive interface. The interface reduces the number of parsing code lines by about 70% and maintains geometric accuracy.Furthermore, the tetrahedral mesh loading takes 3.1 times longer than tessellated solids, but the simulation time can be reduced from 15194.3 s to 77.28 s.

As large language models (LLMs) are increasingly trained on scraped web corpora without authorisation, content owners require forensic methods to prove that their documents were included in a model's training set. We propose \textbf{SIGIL} (\textbf{S}ubtle \textbf{I}njection for \textbf{G}round-truth \textbf{I}nference of \textbf{L}LM training data), a framework that embeds imperceptible \emph{canary sequences} into protected text and code such that any LLM trained on those documents exhibits statistically detectable behavioural signatures when probed with targeted queries. SIGIL defines five canary strategies -- lexical-rare, lexical-phrase, syntactic, semantic, and code-pattern -- and a \emph{Membership Inference Score} (MIS) grounded in the Neyman-Pearson hypothesis testing framework with formal false-positive rate (FPR) control. Simulator parameters are calibrated against the empirical membership inference literature, yielding realistic heterogeneous results across $36{,}000$ trials: overall AUC $= 0.892$, rising from $0.831$ at $0.1\%$ injection to $0.947$ at $10\%$. Detection rates range from $33\%$ to $78\%$ across model-size and injection-rate conditions. Code Pattern canaries achieve the highest AUC ($0.903$, Cohen's $d = 1.84$); Syntactic Structure the lowest ($0.875$, $d = 1.63$). All four experimental factors -- injection rate, model size, canary strategy, and mixture ratio -- have significant independent effects on MIS ($p < 0.001$). SIGIL maintains AUC $> 0.86$ even under $100\%$ paraphrasing ($\text{AUC} = 0.864$), confirming robustness through semantic leakage that survives surface-level rewriting.

The advancement of malware poses obstacles for cybersecurity, necessitating the development of advanced detection techniques. This paper proposes an approach to enhance malware detection through the use of a generative artificial intelligence model. Specifically, variational autoencoders (VAEs) are used with the random forest, XGBoost and sequential model machine learning classifiers. Generated synthetic malware samples are used to address the critical issue of data scarcity for new or less common malware types. This approach can be used to augment datasets to improve classifier robustness. The proposed methodology uses VAEs to create high-quality diverse synthetic datasets that closely mimic real-world malware data. The effectiveness of these augmented datasets is evaluated by comparing the performance of the machine learning classifiers when they are trained with the original data and when they are trained with the synthetic data-augmented datasets. The results demonstrate a notable improvement in the accuracy, precision, recall and F1-scores of the classifiers, when they are trained using the augmented datasets. The enhanced performance for detecting various malware classes shows the potential of this approach to facilitate adaptation to evolving malware threats effectively. This work demonstrates the utility of generative AI for cybersecurity. It also provides a foundation for future research aimed at developing more resilient and adaptive malware detection systems.

Lattice structures are of growing importance in additive manufacturing, where complex internal geometries are increasingly required for lightweight, high surface-to-volume ratios, multifunctionality, and other superior mechanical properties. Conventional lattice modeling methods typically represent struts with simple primitives, such as cylinders or cones, limiting geometric diversity and the design space. Although recent efforts have increased strut-shape complexity to address this issue, they often do so at the expense of computational efficiency and modeling robustness. As a result, achieving both rich geometric expressiveness and efficient computation remains a challenging problem. In this paper, we present an implicit modeling method that expands the design and optimization space of lattice structures while preserving the modeling robustness and efficiency of implicit representations. In our method, each strut is defined as a convolution surface over a skeletal graph, and its profile shape is controlled by a cubic Hermite curve. By exploiting the polynomial structure of both the convolution kernel and the cubic Hermite curve-controlled profile, we derive analytical expressions for efficient field evaluation, avoiding costly and unstable numerical computation. Four case studies have been conducted to validate the proposed method in terms of profile shape diversity, graded lattice modeling, as well as slicing robustness and efficiency.

Springer fibers are subvarieties of the flag variety parameterized by nilpotent matrices. They are central objects of study in geometry representation theory. This paper focuses on two-row Springer fibers, those corresponding to nilpotent matrices with two Jordan blocks. Irreducible components of two-row Springer fibers are in bijection with two-row standard Young tableaux and also with noncrossing matchings. Inspired by the combinatorial commutative algebra of matrix Schubert varieties, we define a polynomial ideal for each noncrossing matching and prove that these ideals define the corresponding components of the Springer fiber. Our proofs leverage geometric descriptions of Springer fibers established by Fung, Stroppel--Webster, Fresse, and Goldwasser--Nadeem--Sun--Tymoczko. Using these ideals to compute examples, we give two conjectural formulas for the cohomology class of each component of a two-row Springer fiber. We apply commutative algebra techniques to prove these conjectures for a specific family of two-row tableaux.

In this paper we construct numerically a new class of unstable self-similar solutions of the incompressible Navier-Stokes equations in $\mathbb{R}^3$. Our solutions are axially symmetric and homogeneous of degree $-1$ at $\infty$, and are unstable in the sense that the linearization around these solutions contains unstable modes. Solutions of this type have been discovered numerically by Guillod and Šverák and Hou, Wang, and Yang, and have applications to proving non-uniqueness results. The main novelty in this paper is that we discover the existence of such solutions in the space of axially symmetric swirl-free (ASSF) vector fields. These approximate solutions are defined on all of $\mathbb R^3$ and achieve global pointwise residuals of order $10^{-10}$. We discuss the numerical construction of these solutions in detail, as well as their relevance to the problem of non-uniqueness of solutions of the incompressible Navier-Stokes equations in 3D, in the space of ASSF solutions.

We derive asymptotic multivariate normal limits and explicit non-asymptotic normal approximation bounds for group sequential quasi-maximum likelihood estimators under possible model misspecification and within-group dependence. The bounds, obtained using Stein's method, have known constants and apply to a class of dependent-data estimating problems in which the likelihood used for estimation may differ from the true data-generating mechanism. We compute the limiting covariance structure and finite-sample bound explicitly for a Poisson generalized linear mixed model with random group effects and illustrate the results using data from an epilepsy clinical trial.

We compare two cluster algebras related to a positive element $\mathtt{b}$ in the braid group of finite $ADE$ type. One is the localized bosonic extension ${\widetilde{\mathbb{A}}}_\mathbb{C}(\mathtt{b})$ equipped with an initial seed arising from an admissible chain $\mathfrak{C}$ of $i$-boxes, which is deeply connected to monoidal categorification. The other is the coordinate ring $\mathbb{C}[X({\underlineΔ} {\boldsymbol{i}})]$ of the braid variety $X({\underlineΔ} {\boldsymbol{i}})$ equipped with an initial seed arising from a Demazure weave $\mathfrak{W}$, where ${\boldsymbol{i}}$ and ${\underlineΔ}$ are expression sequences of $\mathtt{b}$ and the half twist $Δ$, respectively. We explicitly construct a Demazure weave $\mathfrak{W}_{\underlineΔ}(\mathfrak{C})$ for each admissible chain $\mathfrak{C}$ associated with ${\boldsymbol{i}}$, and prove that there exists an algebra isomorphism $φ_{\boldsymbol{i}}\colon {\widetilde{\mathbb{A}}}_\mathbb{C}(\mathtt{b})\to\mathfrak{C}[X({\underlineΔ} {\boldsymbol{i}})]$ which is compatible with the two seeds arising from $\mathfrak{C}$ and $\mathfrak{W}_{\underlineΔ}(\mathfrak{C})$. Moreover, the isomorphism $φ_{\boldsymbol{i}}$ sends the PBW vectors ${\overline{\mathsf{p}}}_{\boldsymbol{i},k} \in {\widetilde{\mathbb{A}}}_\mathbb{C}(\mathtt{b})$ to the coordinates $z_k \in \mathfrak{C}[X({\underlineΔ} {\boldsymbol{i}})]$ indexed by the letters of ${\boldsymbol{i}}$. As applications, we investigate a connection between Demazure weaves and signed words via the $i$-boxes and interpret the isomorphism $φ_{\boldsymbol{i}}$ from the viewpoint of monoidal categorification using Hernandez--Leclerc categories.

The singular cohomology ring of a matroid is an algebraic invariant which generalizes the Chow ring of a matroid. We study combinatorial and Lefschetz properties of the singular cohomology ring of a uniform matroid. Combinatorially, we construct an explicit basis for the singular cohomology ring in terms of Koszul homology. From this basis we derive multiple formulas for the Hodge numbers of the cohomology ring that recover and extend known formulas for the Chow polynomial of a uniform matroid. We also use this basis to show that the singular cohomology ring of a uniform matroid satisfies the "quasi-projective strong Lefschetz property" -- a slight weakening of the Hard Lefschetz property found in the Chow ring of a matroid.

We address two open questions in the rough volatility literature. First, we prove finite positive moments for the rough Bergomi price process, and for a wider class of Gaussian Volterra Bergomi models, in the whole subcritical range under negative correlation. More precisely, if \(ρ\in[-1,0)\), then \(\E[S_T^p]<\infty\) for every \(0<p<p_ρ\), where \(p_{-1}=\infty\) and \(p_ρ=(1-ρ^2)^{-1}\) for \(-1<ρ<0\). For the fractional rough Bergomi kernel, this gives the finite side of the sharp critical moment threshold, complementing the known explosion result above the threshold. Second, we prove that the rough Heston variance process, equivalently the scalar Volterra square-root process with fractional kernel \(K_α(t)=t^{α-1}/Γ(α)\) and \(α\in(1/2,1)\), has a positive atom at zero at every positive time. Consequently, zero is hit with positive probability before every positive time horizon. This rules out any Feller-type condition making the zero boundary inaccessible in the fractional rough Heston model.