Committee

arXiv:2511.18619v1 Announce Type: new Abstract: Language Models are extremely susceptible to performance collapse with even small changes to input prompt strings. Libraries such as DSpy (from Stanford NLP) avoid this problem through demonstration-based prompt optimisation. Inspired by this, I propose an alternative approach that treats prompt optimisation as a classical state-space search problem. I model the prompt space as a graph where nodes represent prompt states and edges correspond to deliberate transformations such as shortening, adding examples, or re- ordering content. Using beam search and random walk algorithms, I systematically explore this space, evaluating candidates on development sets and pruning unpromising branches. Across five NLP tasks (sentiment classification, question answering, summarisation, reason- ing, and natural language inference), I find that even shallow search configurations (beam width=2, depth=2) improve upon seed prompts on development sets. For instance, beam search achieves development accuracy gains from 0.40 to 0.80 on reasoning tasks, though test set improvements are more modest (0.20 to 0.50), indicating overfitting to the develop- ment heuristic. Analysis of successful optimisation paths reveals that transformations that make prompts concise appear most frequently, while verbosity operators are never selected. My results validate prompt optimization as a search problem and suggest that with greater computational resources and improved evaluation metrics, deeper exploration could yield more robust prompts that generalize beyond development sets. Code and implementation are available at [https://github.com/MaanasTaneja/PromptOptimiser].

arXiv:2505.12842v4 Announce Type: replace-cross Abstract: Graphical user interface (GUI) agents have recently emerged as an intriguing paradigm for human-computer interaction, capable of automatically executing user instructions to operate intelligent terminal devices. However, when encountering out-of-distribution (OOD) instructions that violate environmental constraints or exceed the current capabilities of agents, GUI agents may suffer task breakdowns or even pose security threats. Therefore, effective OOD detection for GUI agents is essential. Traditional OOD detection methods perform suboptimally in this domain due to the complex embedding space and evolving GUI environments. In this work, we observe that the in-distribution input semantic space of GUI agents exhibits a clustering pattern with respect to the distance from the centroid. Based on the finding, we propose GEM, a novel method based on fitting a Gaussian mixture model over input embedding distances extracted from the GUI agent that reflect its capability boundary. Evaluated on eight datasets spanning smartphones, computers, and web browsers, our method achieves an average accuracy improvement of 23.70% over the best-performing baseline while only increasing training time by 4.9% and testing time by 6.5%. We also experimentally demonstrate that GEM can improve the step-wise success rate by 9.40% by requesting assistance from the cloud model when encountering OOD samples. Analysis verifies the generalization ability of our method through experiments on nine different backbones. The codes are available at https://github.com/Wuzheng02/GEM-OODforGUIagents.

arXiv:2511.18622v1 Announce Type: new Abstract: We present OpenGloss, a synthetic encyclopedic dictionary and semantic knowledge graph for English that integrates lexicographic definitions, encyclopedic context, etymological histories, and semantic relationships in a unified resource. OpenGloss contains 537K senses across 150K lexemes, on par with WordNet 3.1 and Open English WordNet, while providing more than four times as many sense definitions. These lexemes include 9.1M semantic edges, 1M usage examples, 3M collocations, and 60M words of encyclopedic content. Generated through a multi-agent procedural generation pipeline with schema-validated LLM outputs and automated quality assurance, the entire resource was produced in under one week for under $1,000. This demonstrates that structured generation can create comprehensive lexical resources at cost and time scales impractical for manual curation, enabling rapid iteration as foundation models improve. The resource addresses gaps in pedagogical applications by providing integrated content — definitions, examples, collocations, encyclopedias, etymology — that supports both vocabulary learning and natural language processing tasks. As a synthetically generated resource, OpenGloss reflects both the capabilities and limitations of current foundation models. The dataset is publicly available on Hugging Face under CC-BY 4.0, enabling researchers and educators to build upon and adapt this resource.

In this tutorial, we demonstrate how to combine the strengths of symbolic reasoning with neural learning to build a powerful hybrid agent. We focus on creating a neuro-symbolic architecture that uses classical planning for structure, rules, and goal-directed behavior, while neural networks handle perception and action refinement. As we walk through the code, we see how both layers interact in real time, allowing us to navigate an environment, overcome uncertainty, and adapt intelligently. At last, we understand how neuro-symbolic systems bring interpretability, robustness, and flexibility together in a single agentic framework. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser import numpy as np import matplotlib.pyplot as plt from dataclasses import dataclass, field from typing import List, Dict, Tuple, Set, Optional from collections import deque import warnings warnings.filterwarnings(‘ignore’) @dataclass class State: robot_pos: Tuple[int, int] holding: Optional[str] = None visited: Set[Tuple[int, int]] = field(default_factory=set) objects_collected: Set[str] = field(default_factory=set) def __hash__(self): return hash((self.robot_pos, self.holding)) class SymbolicPlanner: def __init__(self, grid_size: int = 8): self.grid_size = grid_size self.actions = [‘up’, ‘down’, ‘left’, ‘right’, ‘pickup’, ‘drop’] def get_successors(self, state: State, obstacles: Set[Tuple[int, int]], objects: Dict[str, Tuple[int, int]]) -> List[Tuple[str, State]]: successors = [] x, y = state.robot_pos moves = {‘up’: (x, y-1), ‘down’: (x, y+1), ‘left’: (x-1, y), ‘right’: (x+1, y)} for action, new_pos in moves.items(): nx, ny = new_pos if (0 <= nx < self.grid_size and 0 <= ny < self.grid_size and new_pos not in obstacles): new_state = State(new_pos, state.holding, state.visited | {new_pos}, state.objects_collected.copy()) successors.append((action, new_state)) if state.holding is None: for obj_name, obj_pos in objects.items(): if state.robot_pos == obj_pos and obj_name not in state.objects_collected: new_state = State(state.robot_pos, obj_name, state.visited.copy(), state.objects_collected.copy()) successors.append((‘pickup’, new_state)) if state.holding is not None: new_state = State(state.robot_pos, None, state.visited.copy(), state.objects_collected | {state.holding}) successors.append((‘drop’, new_state)) return successors def heuristic(self, state: State, goal: Tuple[int, int]) -> float: return abs(state.robot_pos[0] – goal[0]) + abs(state.robot_pos[1] – goal[1]) def a_star_plan(self, start_state: State, goal: Tuple[int, int], obstacles: Set[Tuple[int, int]], objects: Dict[str, Tuple[int, int]]) -> List[str]: counter = 0 frontier = [(self.heuristic(start_state, goal), counter, 0, start_state, [])] visited = set() while frontier: frontier.sort() _, _, cost, state, plan = frontier.pop(0) counter += 1 if state.robot_pos == goal and len(state.objects_collected) >= len(objects): return plan state_key = (state.robot_pos, state.holding) if state_key in visited: continue visited.add(state_key) for action, next_state in self.get_successors(state, obstacles, objects): new_cost = cost + 1 new_plan = plan + [action] priority = new_cost + self.heuristic(next_state, goal) frontier.append((priority, counter, new_cost, next_state, new_plan)) counter += 1 return [] We lay the foundation for our symbolic reasoning system and define how states, actions, and transitions work. We implement classical planning logic using A* search to generate goal-directed, interpretable action sequences. As we build this part, we establish the rule-based backbone that guides the agent’s high-level decisions. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser class NeuralPerception: def __init__(self, grid_size: int = 8): self.grid_size = grid_size self.W1 = np.random.randn(grid_size * grid_size, 64) * 0.1 self.b1 = np.zeros(64) self.W2 = np.random.randn(64, 32) * 0.1 self.b2 = np.zeros(32) self.W3 = np.random.randn(32, grid_size * grid_size) * 0.1 self.b3 = np.zeros(grid_size * grid_size) def relu(self, x): return np.maximum(0, x) def sigmoid(self, x): return 1 / (1 + np.exp(-np.clip(x, -500, 500))) def perceive(self, noisy_grid: np.ndarray) -> np.ndarray: x = noisy_grid.flatten() h1 = self.relu(x @ self.W1 + self.b1) h2 = self.relu(h1 @ self.W2 + self.b2) out = self.sigmoid(h2 @ self.W3 + self.b3) return out.reshape(self.grid_size, self.grid_size) class NeuralPolicy: def __init__(self, state_dim: int = 4, action_dim: int = 4): self.W = np.random.randn(state_dim, action_dim) * 0.1 self.b = np.zeros(action_dim) self.action_map = [‘up’, ‘down’, ‘left’, ‘right’] def softmax(self, x): exp_x = np.exp(x – np.max(x)) return exp_x / exp_x.sum() def get_action_probs(self, state_features: np.ndarray) -> np.ndarray: logits = state_features @ self.W + self.b return self.softmax(logits) def select_action(self, state_features: np.ndarray, symbolic_action: str) -> str: probs = self.get_action_probs(state_features) if symbolic_action in self.action_map: sym_idx = self.action_map.index(symbolic_action) probs[sym_idx] += 0.7 probs = probs / probs.sum() return np.random.choice(self.action_map, p=probs) We introduce the neural components that allow our agent to sense and adapt. We design a lightweight neural network to denoise the environment and a simple policy network to refine actions based on features. As we integrate these elements, we ensure that our agent can handle uncertainty and adjust behavior dynamically. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser class NeuroSymbolicAgent: def __init__(self, grid_size: int = 8): self.grid_size = grid_size self.planner = SymbolicPlanner(grid_size) self.perception = NeuralPerception(grid_size) self.policy = NeuralPolicy() self.obstacles = {(3, 3), (3, 4), (4, 3), (5, 5), (6, 2)} self.objects = {‘key’: (2, 6), ‘gem’: (6, 6)} self.goal = (7, 7) def create_noisy_observation(self, true_grid: np.ndarray) -> np.ndarray: noise = np.random.randn(*true_grid.shape) * 0.2 return np.clip(true_grid + noise, 0, 1) def extract_state_features(self, pos: Tuple[int, int], goal: Tuple[int, int]) -> np.ndarray: return np.array([pos[0]/self.grid_size, pos[1]/self.grid_size, goal[0]/self.grid_size, goal[1]/self.grid_size]) def execute_mission(self, verbose: bool = True) -> Tuple[List, List]: start_state = State(robot_pos=(0, 0), visited={(0, 0)}) symbolic_plan = self.planner.a_star_plan(start_state, self.goal, self.obstacles, self.objects) if verbose: print(f” Symbolic Plan Generated: {len(symbolic_plan)} steps”) print(f” Plan: {symbolic_plan[:10]}{‘…’ if len(symbolic_plan) > 10 else ”}n”) true_grid = np.zeros((self.grid_size, self.grid_size)) for obs in self.obstacles: true_grid[obs[1], obs[0]] = 1.0 noisy_obs = self.create_noisy_observation(true_grid) perceived_grid = self.perception.perceive(noisy_obs) if verbose: print(f” Neural Perception: Denoised obstacle map”) print(f” Perception accuracy: {np.mean((perceived_grid > 0.5) == true_grid):.2%}n”) trajectory = [(0, 0)] current_pos = (0, 0) actions_taken = [] for i, sym_action in enumerate(symbolic_plan[:30]): features = self.extract_state_features(current_pos, self.goal) refined_action = self.policy.select_action(features, sym_action) if sym_action in [‘up’,’down’,’left’,’right’] else sym_action actions_taken.append(refined_action) if refined_action == ‘up’: current_pos = (current_pos[0], max(0, current_pos[1]-1)) elif refined_action == ‘down’: current_pos = (current_pos[0], min(self.grid_size-1, current_pos[1]+1)) elif refined_action == ‘left’: current_pos = (max(0, current_pos[0]-1), current_pos[1]) elif refined_action == ‘right’: current_pos = (min(self.grid_size-1, current_pos[0]+1), current_pos[1]) if current_pos not in self.obstacles: trajectory.append(current_pos) return trajectory, actions_taken We bring the symbolic and neural layers together into a unified agent. We generate a symbolic plan, perceive the environment through neural processing, and refine each planned action using the neural policy. As we execute the mission loop, we observe how both systems interact seamlessly to produce robust behavior. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def visualize_execution(agent: NeuroSymbolicAgent, trajectory: List, title: str = “Neuro-Symbolic Agent Execution”): fig, axes = plt.subplots(1, 2, figsize=(14, 6)) ax = axes[0] grid

arXiv:2511.17388v1 Announce Type: new Abstract: Position information is essential for language modeling. In softmax transformers, Rotary Position Embeddings (textit{RoPE}) encode positions through textit{fixed-angle} rotations, while in linear transformers, order is handled via input-dependent (selective) gating that decays past key-value associations. Selectivity has generally been shown to improve language-related tasks. Inspired by this, we introduce textit{Selective RoPE}, an textit{input-dependent} rotary embedding mechanism, that generalizes textit{RoPE}, and enables rotation in textit{arbitrary angles} for both linear and softmax transformers. We show that softmax attention already performs a hidden form of these rotations on query-key pairs, uncovering an implicit positional structure. We further show that in state-space models and gated linear transformers, the real part manages forgetting while the imaginary part encodes positions through rotations. We validate our method by equipping gated transformers with textit{Selective RoPE}, demonstrating that its input-dependent rotations improve performance in language modeling and on difficult sequence tasks like copying, state tracking, and retrieval.

arXiv:2511.17080v1 Announce Type: cross Abstract: Discrete fuzzy numbers, and in particular those defined over a finite chain $L_n = {0, ldots, n}$, have been effectively employed to represent linguistic information within the framework of fuzzy systems. Research on total (admissible) orderings of such types of fuzzy subsets, and specifically those belonging to the set $mathcal{D}_1^{L_nrightarrow Y_m}$ consisting of discrete fuzzy numbers $A$ whose support is a closed subinterval of the finite chain $L_n = {0, 1, ldots, n}$ and whose membership values $A(x)$, for $x in L_n$, belong to the set $Y_m = { 0 = y_1

arXiv:2511.16837v1 Announce Type: cross Abstract: Cognitive BASIC is a minimal, BASIC-style prompting language and in-model interpreter that structures large language model (LLM) reasoning into explicit, stepwise execution traces. Inspired by the simplicity of retro BASIC, we repurpose numbered lines and simple commands as an interpretable cognitive control layer. Modern LLMs can reliably simulate such short programs, enabling transparent multi-step reasoning inside the model. A natural-language interpreter file specifies command semantics, memory updates, and logging behavior. Our mental-model interpreter extracts declarative and procedural knowledge, detects contradictions, and produces resolutions when necessary. A comparison across three LLMs on a benchmark of knowledge extraction, conflict detection, and reasoning tasks shows that all models can execute Cognitive BASIC programs, with overall strong but not uniform performance.