We prove that the classical set of moves for standard spines of 3-manifolds (i.e. the MP-move and the V-move) does not suffice to relate to each other any two standard skeleta of a 3-manifold with marked boundary. We also describe a condition on the 3-manifold with marked boundary that tells whether the generalised set of moves, made up of the MP-move and the L-move, suffices to relate to each other any two standard skeleta of the 3-manifold with marked boundary. For the 3-manifolds with marked boundary that do not fulfil this condition, we give three other moves: the CR-move, the T1-move and the T2-move. The first one is local and, with the MP-move and the L-move, suffices to relate to each other any two standard skeleta of a 3-manifold with marked boundary fulfilling another condition. For the universal case, we prove that the non-local T1-move and T2-move, with the MP-move and the L-move, suffice to relate to each other any two standard skeleta of a generic 3-manifold with marked boundary. As a corollary, we get that disc-replacements suffice to relate to each other any two standard skeleta of a 3-manifold with marked boundary.
Move is a research-oriented programming language designed for secure and verifiable smart contract development and has been widely used in managing billions of digital assets in blockchains, such as Sui and Aptos. Move features a strong static type system and explicit resource semantics to enforce safety properties such as the prevention of data races, invalid asset transfers, and entry vulnerabilities. However, smart contracts written in Move may still contain certain vulnerabilities that are beyond the reach of its type system. It is thus essential to validate Move smart contracts. Unfortunately, due to its strong type system, existing smart contract fuzzers are ineffective in producing syntactically or semantically valid transactions to test Move smart contracts. This paper introduces the first fuzzing framework, Belobog, for Move smart contracts. Belobog is type-aware and ensures that all generated and mutated transactions are well-typed. More specifically, for a target Move smart contract, Belobog first constructs a type graph based on Move's type system, and then generates or mutates a transaction based on the graph trace derived from the type graph. In order to overcome the
Understanding what makes tutoring effective requires methods for systematically analyzing tutors' instructional actions during learning interactions. This paper presents a tutor move taxonomy designed to support large-scale analysis of tutoring dialogue within the National Tutoring Observatory. The taxonomy provides a structured annotation framework for labeling tutors' instructional moves during one-on-one tutoring sessions. We developed the taxonomy through a hybrid deductive-inductive process. First, we synthesized research from cognitive science, the learning sciences, classroom discourse analysis, and intelligent tutoring systems to construct a preliminary framework of tutoring moves. We then refined the taxonomy through iterative coding of authentic tutoring transcripts conducted by expert annotators with extensive instructional and qualitative research experience. The resulting taxonomy organizes tutoring behaviors into four categories: tutoring support, learning support, social-emotional and motivational support, and logistical support. Learning support moves are further organized along a spectrum of student engagement, distinguishing between moves that elicit student reaso
In this paper, we describe early work on a specification inference tool for the Move Prover that combines a weakest-precondition (WP) analysis over Move bytecode with an agentic coding CLI such as Claude Code. Specification inference reduces the boilerplate of writing specifications in Move: in order to verify a high-level property such as a global state invariant, pre- and post-conditions for the supporting functions typically have to be written by hand, which is tedious. In our setting, a Model Context Protocol (MCP) service exposes the WP analysis and the prover itself to the coding agent. The WP analysis provides a sound, mechanical baseline for inference; the AI is used precisely where WP is weakest -- for loop invariants and high-level idiomatic specifications such as monotonicity, conservation, and structural invariants. The Move Prover serves as the oracle that decides whether the generated specs are valid, and the agent is equipped to generate proof hints and to refine the inferred specification until verification succeeds. The tool has been applied to a corpus of canonical Move code, including code that uses higher-order functions, dynamic dispatch, global state, referenc
The Move Prover (MVP) is a formal verifier for smart contracts written in the Move programming language. Recently, Move on Aptos was extended with higher-order functions: imperative functions as first-class values that can be passed around, stored in data structs, and kept in persistent storage, enabling dynamic dispatch. This paper describes the representation of function values in the Move specification language and their implementation in MVP. We introduce behavioral predicates which characterize Move functions (aborts and pre/post conditions) by single-state or two-state predicates. We also introduce state labels for naming intermediate memory states in which expressions are evaluated and which allow to compose behavioral predicates to describe sequences of state transitions. On SMT level, function values are encoded by discriminating over the possible function values reaching a call site: when the concrete function is known, its effect is accounted for directly; when it is unknown (for example, a function parameter, or a closure loaded from storage), its behavioral predicates describe the effect. Our approach goes beyond, for example, Dafny, by supporting imperative first-clas
Move structures have been studied in English for Specific Purposes (ESP) and English for Academic Purposes (EAP) for decades. However, there are few move annotation corpora for Research Article (RA) abstracts. In this paper, we introduce RAAMove, a comprehensive multi-domain corpus dedicated to the annotation of move structures in RA abstracts. The primary objective of RAAMove is to facilitate move analysis and automatic move identification. This paper provides a thorough discussion of the corpus construction process, including the scheme, data collection, annotation guidelines, and annotation procedures. The corpus is constructed through two stages: initially, expert annotators manually annotate high-quality data; subsequently, based on the human-annotated data, a BERT-based model is employed for automatic annotation with the help of experts' modification. The result is a large-scale and high-quality corpus comprising 33,988 annotated instances. We also conduct preliminary move identification experiments using the BERT-based model to verify the effectiveness of the proposed corpus and model. The annotated corpus is available for academic research purposes and can serve as essentia
The move structure represents a permutation $π$ of $[0,n)$ as a covering set of $O(r)$ disjoint intervals (contiguous subsets of $[0,n)$), where $r$ is the minimum number of intervals whose values permute together. Formally, $r = 1 + |\{i\in [1,n) : π(i) - 1 eq π(i-1)\}|$. The move structure takes $O(r)$ words of space. Given the index of the interval containing $i$, it allows computing $π(i)$ and the index of the interval containing $π(i)$ in $O(1)$-time. Therefore, for permutations where $r \ll n$, it allows their representation and navigation in significantly compressed space. The previous best $O(r)$-space move structure construction algorithm takes $O(r\log r)$-time. In this paper, we describe a construction algorithm achieving optimal $O(r)$-time and space. We also show that using our improved algorithm within a recent previous work allows the computation of the longest common prefix array in $O(r)$-working space and optimal $O(n)$-time given the run-length-encoded Burrows-Wheeler transform. Finally, we implement our improved move structure construction algorithm and find that it is faster than the previous best algorithm while using comparable memory.
Chomp was introduced by Gale in 1974 \cite{Gale1974}. In the same paper, Gale reported that the $3\times n$ games had been completely analyzed for $n\le 100$, with a unique winning first move in every case, and asked whether winning first moves are unique in general. Although the general uniqueness statement is false \cite[Section~7.1]{BrouwerEtAl2005}, we prove that the three-row uniqueness phenomenon suggested by Gale's computations holds for all $n$: every $3\times n$ Chomp rectangle has exactly one winning opening move. This settles the three-row case of Gale's 52-year-old first-move uniqueness question. The proof is carried out in the two-variable recurrence introduced by Brouwer, Horváth, Molnár-Sáska, and Szabó \cite{BrouwerEtAl2005} for the function $f(q,r)$ whose values encode the $P$-positions. The main local ingredient is a rightmost-hole principle: if a value $p$ is absent from the set $C(q,r)$ but belongs to all corresponding sets $C(t,r)$ for $q<t<p$, then all intermediate values $q+1,\ldots,p-1$ are forced to belong to $C(q,r)$. This separates the diagonal values from the starts of constant rows, and yields a partition of the positive integers into the two poss
Move is a smart-contract language used to execute transactions on the Aptos blockchain. Move programs execute in a sandboxed VM as typed bytecode. The VM statically verifies foundational safety properties like type safety and reference safety at code loading time. In principle, this design gives strong guarantees for Move. However, the static verification logic is complex and continually evolving with the language; like any software, it is not immune to bugs. In a live blockchain setting, a missed rule violation can translate directly into loss of assets, forged authority, or unrecoverable corruption of on-chain state. For this reason, Aptos relies on defense-in-depth runtime safety checks that independently verify the critical invariants during execution, providing protection against latent verifier bugs and malicious bytecode. This paper motivates and describes the runtime safety checks for Move on Aptos.
A delta-move is a local move on a link diagram. The delta-Gordian distance between links measures the minimum number of delta-moves needed to move between link diagrams. A self delta-move only involves a single component of a link whereas a mixed delta-move involves multiple (2 or 3) components. We prove that two links are mixed delta-equivalent precisely when they have the same pairwise linking number and same components; we also give a number of results on how (mixed/self) delta-moves relate to classical link invariants including the Arf invariant and crossing number. This allows us to produce a graph showing links related by a self delta-move for algebraically split links with up to 9-crossings. For these links we also introduce and calculate the delta-splitting number and mixed delta-splitting number, that is, the minimum number of delta-moves needed to separate the components of the link.
Wearable Augmented Reality (AR) is increasingly deployed in on-the-move contexts such as automated driving, cycling, and pedestrian navigation. To date, most systems rely on additive overlays that highlight hazards, intentions, or predictions without altering the scene itself. However, advances in head-mounted displays and computer vision now enable Diminished and Modified Reality techniques that suppress, transform, or substitute scene elements. These capabilities conceptually extend AR into Mediated Reality (MR), shifting the design space from "what to add" to "what is perceptually available." Because such mediation reshapes the evidential basis for situation awareness and trust calibration, it raises novel interaction challenges. This position paper argues that MR on the move must become governable, as users need mechanisms to configure, inspect, and understand mediation without compromising safety. Additionally, this position paper outlines design challenges related to governance granularity, epistemic signaling, and accountability, and frames MR on the move as a research agenda for governable perceptual mediation in dynamic, safety-critical environments.
AI research in chess has been primarily focused on producing stronger agents that can maximize the probability of winning. However, there is another aspect to chess that has largely gone unexamined: its aesthetic appeal. Specifically, there exists a category of chess moves called ``brilliant" moves. These moves are appreciated and admired by players for their high intellectual aesthetics. We demonstrate the first system for classifying chess moves as brilliant. The system uses a neural network, using the output of a chess engine as well as features that describe the shape of the game tree. The system achieves an accuracy of 79% (with 50% base-rate), a PPV of 83%, and an NPV of 75%. We demonstrate that what humans perceive as ``brilliant" moves is not merely the best possible move. We show that a move is more likely to be predicted as brilliant, all things being equal, if a weaker engine considers it lower-quality (for the same rating by a stronger engine). Our system opens the avenues for computer chess engines to (appear to) display human-like brilliance, and, hence, creativity.
The Matveev-Piergallini (MP) moves on spines of $3$-manifolds are well-known for their correspondence to the Pachner $2$-$3$ moves in dual ideal triangulations. Benedetti and Petronio introduced combinatorial descriptions of closed $3$-manifolds and combed $3$-manifolds by using branched spines and their equivalence relations, which involve MP moves with 16 distinct patterns of branchings. In this paper, we demonstrate that these 16 MP moves on branched spines are derived from a primary MP move, pure sliding moves, and their inverses. Consequently, we obtain simpler combinatorial descriptions for closed $3$-manifolds and combed $3$-manifolds. Furthermore, we extend these results to framed $3$-manifolds and spin $3$-manifolds. These descriptions are advantageous, particularly when constructing and studying quantum invariants of links and $3$-manifolds. In various constructions of quantum invariants using (ideal) triangulations, branching structures naturally arise to facilitate the assignment of non-symmetric algebraic objects to tetrahedra. In these frameworks, the primary MP move precisely corresponds to certain algebraic pentagon relations, such as the pentagon relation of the ca
In this paper, we study the unknotting operation for twisted knots, called arc shift move. First, we find a family of twisted knots with arc shift number $n$ for any given $n \in \mathbb{N}$. Then we define a new unknotting operation, called the region arc shift move for twisted knots and find family of twisted knots whose region arc shift number is less than or equal to $n$ for any given $n \in \mathbb{N}$. Later, we explore bounds for region arc shift number and forbidden number.
The growing adoption of formal verification for smart contracts has spurred the development of new verifiable languages like Move. However, the limited availability of training data for these languages hinders effective code generation by large language models (LLMs). This paper presents ConMover, a novel framework that enhances LLM-based code generation for Move by leveraging a knowledge graph of Move concepts and a small set of verified code examples. ConMover integrates concept retrieval, planning, coding, and debugging agents in an iterative process to refine generated code. Evaluations with various open-source LLMs demonstrate substantial accuracy improvements over baseline models. These results underscore ConMover's potential to address low-resource code generation challenges, bridging the gap between natural language descriptions and reliable smart contract development.
Recent Speech-to-Speech Translation (S2ST) systems achieve strong semantic accuracy yet consistently strip away non-verbal vocalizations (NVs), such as laughter and crying that convey pragmatic intent, which severely limits real-world utility. We address this via three contributions. First, we propose a synthesis pipeline for building scalable expressive datasets to overcome the data scarcity limitation. Second, we propose MoVE, a Mixture-of-LoRA-Experts architecture with expressive-specialized adapters and a soft-weighting router that blends experts for capturing hybrid expressive states. Third, we show pretrained AudioLLMs enable striking data efficiency: 30 minutes of curated data is enough for strong performance. On English-Chinese S2ST, while comparing with strong baselines, MoVE reproduces target NVs in 76% of cases and achieves the highest human-rated naturalness and emotional fidelity among all compared systems, where existing S2ST systems preserve at most 14% of NVs.
We present Wan-Move, a simple and scalable framework that brings motion control to video generative models. Existing motion-controllable methods typically suffer from coarse control granularity and limited scalability, leaving their outputs insufficient for practical use. We narrow this gap by achieving precise and high-quality motion control. Our core idea is to directly make the original condition features motion-aware for guiding video synthesis. To this end, we first represent object motions with dense point trajectories, allowing fine-grained control over the scene. We then project these trajectories into latent space and propagate the first frame's features along each trajectory, producing an aligned spatiotemporal feature map that tells how each scene element should move. This feature map serves as the updated latent condition, which is naturally integrated into the off-the-shelf image-to-video model, e.g., Wan-I2V-14B, as motion guidance without any architecture change. It removes the need for auxiliary motion encoders and makes fine-tuning base models easily scalable. Through scaled training, Wan-Move generates 5-second, 480p videos whose motion controllability rivals Klin
It is well known that any two diagrams representing the same oriented link are related by a finite sequence of Reidemeister moves O1, O2 and O3. Depending on orientations of fragments involved in the moves, one may distinguish 4 different versions of each of the O1 and O2 moves, and 8 versions of the O3 move. We introduce a minimal generating set of four oriented Reidemeister moves, which includes two O1 moves, one O2 move, and one O3 move. We then study which other sets of up to 5 oriented moves generate all moves, and show that only few of them do. Some commonly considered sets are shown not to be generating. An unexpected non-equivalence of different O3 moves is discussed.
The deduction game may be thought of as a variant on the classical game of cops and robber in which the cops (searchers) aim to capture an invisible robber (evader); each cop is allowed to move at most once, and cops situated on different vertices cannot communicate to co-ordinate their strategy. In this paper, we extend the deduction game to allow each searcher to make $k$ moves, where $k$ is a fixed positive integer. We consider the value of the $k$-move deduction number on several classes of graphs including paths, cycles, complete graphs, complete bipartite graphs, and Cartesian and strong products of paths.
This work addresses motion-guided few-shot video object segmentation (FSVOS), which aims to segment dynamic objects in videos based on a few annotated examples with the same motion patterns. Existing FSVOS datasets and methods typically focus on object categories, which are static attributes that ignore the rich temporal dynamics in videos, limiting their application in scenarios requiring motion understanding. To fill this gap, we introduce MOVE, a large-scale dataset specifically designed for motion-guided FSVOS. Based on MOVE, we comprehensively evaluate 6 state-of-the-art methods from 3 different related tasks across 2 experimental settings. Our results reveal that current methods struggle to address motion-guided FSVOS, prompting us to analyze the associated challenges and propose a baseline method, Decoupled Motion Appearance Network (DMA). Experiments demonstrate that our approach achieves superior performance in few shot motion understanding, establishing a solid foundation for future research in this direction.