Computer Science and Mathematics

Abstract: diffct implements computed-tomography projection and reconstruction in PyTorch using Numba CUDA kernels. Its native forward model integrates a cell-constant attenuation field along rays defined by per-view acquisition geometry; the backprojector is the matched discrete adjoint. The same model supports parallel, fan and cone beams, non-circular trajectories, and parameterized detector surfaces. This report describes the implementation through release 2.2.1: the geometry and sampling conventions, Siddon traversal, data and first-order geometry derivatives, differentiable analytical FBP/FDK, and execution on one or several GPUs. We derive the ownership and reduction rules for distributed view and spatial partitions and explain how spatial, view and detector blocks extend native operations to CPU-backed and disk-backed data. Experiments include measured walnut cone-beam data, synthetic reconstruction and calibration, and a recorded 512³ scaling benchmark. On A100-SXM-64GB GPUs, eight GPUs on two nodes reduce forward projection from 493.05 to 73.18 ms and the amortized cost of a ten-step CGLS solve from 2054.36 to 373.38 ms per iteration. Analytical gathers have their own discrete transposes; differentiability does not make FDK an exact inverse. We distinguish numerical correctness, reconstruction quality and execution cost, and state the limits of each experiment.

Abstract: Live data migration across geographic regions in Internet-scale cloud services requires distributed locking—but a dedicated lock service adds infrastructure, a lock lookup on the request path, and an atomicity gap between lock release and location cutover. We describe an architectural alternative: embedding lock metadata in the routing records that services already read on every user request. The coordination primitives are standard—fencing tokens, leases, and conditional writes; what changes is where lock state lives. Deployed at a large-scale real-time messaging platform processing 6–10 million migrations per day, this placement lets lock checks ride the existing routing lookup, adding one point read only for the small, transient set of resources holding an active lock; it makes location swap and lock release a single atomic database write; and it propagates locks by passive cache expiry rather than active invalidation. Write-lock duration—the only user-impacting phase—holds at p99 under 20 seconds. We compare the design architecturally with Chubby, ZooKeeper, Redlock, and DynamoDB Lock Client, separate measured from inferred benefits, and discuss where infrastructure-embedded coordination applies.

Abstract: Relocating live data between geographic regions is difficult when one user-visible entity spans many independently owned services and storage backends. Copying the data is not enough: concurrent writes, deletes, and stale routing caches can lose updates, resurrect deleted data, or split write authority at cutover. This paper presents a four-phase migration protocol, deployed on a large-scale messaging platform, that keeps such migrations imperceptible to users. The protocol fences operations by class rather than by phase, so that only the final delta catch-up blocks writes; carries deletes as content-stripped tombstones, so that a paginated copy cannot resurrect deleted data; enforces locks through routing metadata that every request already reads; and cuts over through a single atomic routing update gated on end-to-end validation. We state a cutover-completeness invariant and four safety propositions with proof sketches. Over 30 days and 6–10 million migrations per day, the write lock lasted 13 s at the median and 19 s at the 99th percentile; 99.9% of migrations succeeded on the first attempt and all succeeded after retry; and fewer than one in 100 million message sends encountered the write lock, each succeeding on client retry. A trace-driven counterfactual analysis shows that blocking writes throughout historical copy would raise the 99.99th-percentile write-blocked window from 159 seconds to at least 873 minutes. Pre-cutover validation detected and rolled back the rare migrations in which a service’s export or import lagged behind its own schema changes.

Abstract: Composing mechanism models published separately across disciplines into one executable, optimizable simulation remains an open modeling and simulation problem. Existing model-exchange standards describe mechanisms within a single domain, and simulation-based optimization is usually attached afterward through bespoke scripts. Individual health decisions make the problem acute, since physiological, behavioral, psychological, social, and economic constraints, each supplied by a different discipline, have to be satisfied at once. This paper introduces LM format 1.0, an open YAML specification built around four structural blocks, variables, equations, simulation, and optimization, collectively VESO, which organize cross-disciplinary effect sizes, equations, thresholds, and constraints into an executable, optimizable system-science object. The specification ships with an open-source reference implementation, the LM Reference Engine. Two joint-simulation case studies demonstrate feasibility. A chronic kidney disease (CKD) protein-muscle tradeoff model connects nephrology and geriatric medicine, reproducing a classic cross-specialty guideline conflict. An aircrew cross-timezone scheduling model connects aviation medicine, chronobiology, and operations scheduling, jointly optimizing a decision frontier between operating cost and on-duty fatigue safety. Neither case constitutes a clinical or operational validation of the CKD treatment plan or the aircrew schedule itself.

Abstract: Digital-twin research on additive-manufacturing (AM) fleets needs experi-ments in which the physical process, the communication channel and thetwin’s synchronisation state can be manipulated and measured indepen-dently; existing tools cover only fragments. SimTwin is an open-sourcePython simulator that couples a lumped-parameter thermal plant withproportional–integral heater control, a per-device job and health state ma-chine, an explicit message-level transport with latency, jitter, loss, dupli-cation, outage and staleness-based discarding, and a twin registry writtenonly by delivered messages. Faults are injected as mechanisms acting onthe plant, not as scripted telemetry labels, so fault signatures emerge fromthe dynamics, and seeding gives byte-identical telemetry. Seven experimentsreport scalability to 1 000 printers, throughput to 70 363 msg s−1, twin stale-ness rising from 0.99 s to 6.99 s with loss, 10 of 11 fault families separable atCohen’s |d| ≥ 1.45, and QoS 1 holding 95th-percentile staleness at 1.2 s on areal broker where QoS 0 lets it grow 12.6-fold.

Abstract: Formalizing the transition from qualitative, phenomenological neuropsychological observations to quantitative clinical data structures remains a critical bottleneck in computational neuroscience. Existing methods either rely on scalar psychometric screening tools (e.g., MoCA, MMSE) that obscure the modular and network-level topography of cognitive deficits, or utilize stochastic large language models (LLMs) prone to diagnostic hallucination and predicate drift. This paper presents a deterministic expert core architecture that bridges network neuroscience and clinical practice by formalizing A.R. Luria’s theory of systemic-dynamic localization of higher mental functions into a production-rule predicate processor. The system converts an input 10-dimensional integer vector of multi-domain cognitive error scores [0-5] into standardized syndromic profiles using multi-level nested dictionary traversals and automated mapping onto the WHO International Classification of Functioning, Disability and Health (ICF) taxonomy (b, d, and e codes). To ensure morphosyntactic invariance across language localizations, an isolated regular expression inflection module handles gender agreement tags post-traversal. The computational runtime maintains strict algorithmic transparency, enforces cross-domain data integrity filters, and implements a deterministic interrupt for vector singularities, eliminating probabilistic inference and ensuring auditable, reproducible clinical decision-support reporting.

Abstract: This paper introduces highFIS, an open-source Python package for training and evaluating high-dimensional Takagi-Sugeno-Kang (TSK) neuro-fuzzy inference systems. TSK systems are widely appreciated for their local linear approximation capabilities and structural transparency, yet the classical product T-norm formulation suffers from exponential rule activation collapse and softmax saturation in high-dimensional spaces. The highFIS library addresses this limitation by unifying thirteen high-dimensional TSK estimator families and a baseline model under a single declarative, scikit-learn-compatible application programming interface (API). These estimators leverage modern mathematical strategies to mitigate the curse of dimensionality, including antecedent exponent re-formulation, differentiable softmin approximations, adaptive parametric T-norms, double groups of gates for sparse feature and rule selection, and head-based subspace decomposition. Every family is implemented with both a Classifier and a Regressor variant that integrate naturally with the meta-estimators and model evaluation frameworks of scikit-learn. Built on PyTorch, the package en-ables efficient gradient-based optimization with hardware acceleration, offers extensive introspection utilities to extract interpretable rule bases, and supports versioned checkpoints for model persistence. Usage is illustrated on a low-dimensional interpretability example and on real high-dimensional classification and regression datasets.

Abstract: Generative development is an open loop: a language model produces the code, and readiness is judged by an opinion. This work studies whether a transactional state machine external to the agent — owning the requirements canon, an executable checks table, a double run of every check, and a signed verdict — turns readiness into a reproducible fact. Field experiments ran on a battery of console-utility tasks spanning five task senses and five technology stacks: a three-hand experiment — top and budget models in the system, solo without it — with independent judges, and a September replication on the evolved machine. The system hands delivered verified-twice verdicts on every task, quality invariant to the model class; solo, cheaper on its own tokens, matched the byte-exact reference in a fifth of the judges’ rows — the divergence is freedom of interpreting the brief, not functional defects. Systemic fixes nearly halved the battery’s token cost, the methodology unchanged. On the full path, with the verifying operator priced in, the machine route is also the cheaper one, and the human leaves the loop on most tasks. The closed loop’s benefit is reconcilability, not token economy; an anti-entropy frame is proposed to interpret it.

Abstract: Software increasingly spans a continuum of independently owned services and heterogeneous stores across regions, and data residency rules force live data to move between regions without interrupting service. A single logical entity spans many services, and no component knows its full dependency graph in advance. An early design that centralized this knowledge reported success while silently omitting data it had never been taught about—a failure invisible to conventional health metrics. We rebuilt it into a contract-based migration platform for a messaging service, resting on three ideas: a stable five-API service contract that keeps domain knowledge with each service; typed dependency semantics that make declarations executable policy; and runtime graph expansion that guarantees completeness without knowing the full graph. It ran 6–10 million migrations per day at 99.9% first-attempt success, growing from 7 to 15 services with no contract change.

Abstract: Software architecture remains conceptually fragmented despite decades of influential definitions, standards, and methods. This study synthesizes this plurality into four recurring worldviews: Architectural Abstractionism, Architectural Multi-Levelism, Architectural Fundamentalism, and Architectural Consequentialism. Using an analytic-conceptual methodology, the schools are systematically characterized through the Meta-Architectural Descriptive (MAD) Framework and evaluated through the Software Architecture Conception Adequacy (SACA) Framework for descriptive, explanatory, practical, and teleological adequacy. The analysis finds that all four exhibit mixed adequacy: each contributes important insights but retains material deficiencies, and none is independently adequate or dominant. Their individual and collective inadequacies also have consequential implications for architectural scope, workmanship, governance, architecture-to-realization continuity, and professional formation. The findings support synthesis rather than selection among the schools and establish requirements for a coherent and comprehensive conception of software architecture that integrates their merits while resolving their respective deficiencies.

Abstract: Software architecture remains foundational to the design and evolution of complex software systems, yet no sufficiently unified conception establishes what architecture encompasses or where its boundaries lie. Rather than proposing another definition, this paper addresses the logically prior meta-conceptual problem: how alternative conceptions can be systematically articulated and evaluated before synthesis. It develops the Meta-Architectural Worldview (MAW), operationalized through the Meta-Architectural Descriptive (MAD) Framework and the Software Architecture Conception Adequacy (SACA) Framework. MAD reconstructs conceptions across eight interrelated dimensions: purpose and value, architectural objects, qualities, form, depth, context, boundary, and explanatory and justification. SACA evaluates conceptions for descriptive, explanatory, practical, and teleological adequacy, with teleological adequacy referenced to the shared disciplinary purpose of software architecture. MAD also yields the concepts of design span and architectural design span. Together, these constructs provide a first-principles foundation for evaluating existing worldviews and rigorously pursuing a more unified, coherent, holistic definition of software architecture.

Abstract: Wind resource assessment increasingly depends on integrating heterogeneous reanalysis, turbine data, geospatial operations, and persistent computational services. This article presents WindAnalysis, a containerized web framework for coastal wind studies in the Colombian Caribbean. Its novelty is architectural and operational: rather than introducing new wind models, the framework integrates scheduled ERA5 and MERRA-2 ingestion, persistent PostgreSQL storage, typed FastAPI services, an authenticated React geospatial interface, experiment retention, turbine-level power curves, and inverse-distance-weighted (IDW) interpolation within a single reproducible workflow. The evaluated database state comprised 32,633,302 ERA5 and 3,941,280 MERRA-2 records. Controlled benchmarks showed a 3962-fold acceleration for planner-based row counts and a 19.4-fold acceleration for 1% block-sampled mean queries, with 0.39% mean absolute relative error. Internal leave-one-grid-point-out IDW cross-validation yielded a 10 m wind-speed RMSE of 0.366 m/s for the deployed p = 2, 50 km configuration. The documented La Guajira case, using direct ERA5 wind at 100 m, produced a gross AEP of 8.901 GWh/year and a gross capacity factor of 61.58% for a Vestas V82 turbine. The evaluation further includes 2839 archived automated tests and release-level UI-to-runner parity. WindAnalysis therefore provides an inspectable, repeatable integration layer for regional wind-resource assessment while keeping computational reproducibility distinct from external physical validation.

Abstract: Software engineering coordination constitutes a substantial and growing proportion of development effort, yet coordination cost remains one of the least rigorously modelled, measured, or estimated aspects of software engineering. Despite decades of research in software development cost estimation and coordination theory, the field lacks a coherent and comprehensive engineering foundation that treats coordination cost as a measurable and analytically estimable quantity with its own theoretical constructs, standardized units, and analytical models. This paper establishes that foundation. It develops a generalized theory of coordination cost dynamics that distinguishes intra-team and inter-team coordination as fundamentally different organizational mechanisms. It introduces unit coordination cost parameters—empirically calibratable engineering parameters that abstract analytically intractable contextual complexity into measurable quantities. It derives closed-form estimation models expressing total coordination cost as a function of project size, team configuration, and unit coordination costs. It proposes standardized efficiency measures—Absolute, Internal Relative, and External Relative Coordination Efficiency, enabling benchmarking and comparative analysis across projects and organizations. The framework provides researchers with a coherent theoretical basis for empirical validation. For practicing project and engineering managers, software cost estimators, and IT quantity surveyors, it offers systematic methods for reliable cost estimation and planning, diagnosis of cost overheads, and coordination efficiency improvement. In so doing the paper lays the foundations for a rigorous specialized discipline of software development cost engineering.

Abstract: A long simulation that checkpoints its random generator and resumes on a different machine is relying on a property that std::mt19937 does not have. The C++ standard fixes the text format of an engine’s stream operators only partially, and the three major standard libraries disagree on both the numeric base of the digits and the order of the 624 state words. A checkpoint written under libstdc++ fails to load under the MSVC standard library, and loads without any diagnostic, at the wrong position,under libc++. This paper describes vphilox, a header-only C++20 library that removes the failure by changing what is stored. The generator is Philox4x32-10, a counter-based construction whose entire state is a key and a position, so a checkpoint is six 32-bit integers and a word offset, not a snapshot of engine internals. The same property gives constant-time seek and gives each worker an independent substream with no coordination, so a task draws the same numbers whatever the thread count and schedule. The cost of those properties is the question the design has to answer, because the earlier attempt to adopt Philox in a production machine-learning library was rejected on the grounds that scalar Philox runs at one tenth the speed of the Mersenne Twister. We report that the tenfold penalty did not reproduce on any of five processors measured, and that interleaving independent counters across SIMD lanes brings the generator to between 0.22× and 0.75× the cost per byte of std::mt19937 on the bulk path. Aggregate cost per byte is flat across thread counts, and the first parallel limit we find is hyperthread co-location, not the generator.

Abstract: Data preparation requires heterogeneous operations to be composed into coherent pipelines while respecting application-specific constraints. Existing approaches span interactive curation, automated pipeline search, provenance, and operator recommendation, yet a complementary need remains for systems that preserve human control while enforcing validity during composition. CAPPERI (Context-Aware data Preparation Pipelines through Explicit Reuse and human Interaction) is an open-source software-intensive framework based on reusable abstractions for context, object type, algorithm, and pipeline. Data types and transformations form a typed directed graph, while explicit hierarchical application contexts determine the admissible portion of the graph and enable reuse through specialization. Step-wise guidance exposes only transformations compatible with the current data state and context, while a modular architecture separates domain abstractions, composition logic, validation, persistence, and interaction. Unlike learned-context automated search, CAPPERI treats context as explicit domain knowledge and an active composition constraint, combining automatic validity enforcement with human intentionality.

Abstract: The European Digital Identity Wallet (EUDI Wallet) is reshaping digital identity management across Europe by enabling citizens to access, manage, and share verifiable digital credentials in a secure and interoperable manner. This paper presents a case study of the Italian digital identity wallet (IT-Wallet), one of the first national implementations of Regulation (EU) 2024/1183, and investigates the factors that enabled its rapid adoption at national scale. The study combines the analysis of regulatory and technical documentation, system architecture decisions, adoption statistics, and a GDPR-compliant telemetry framework integrated into the IO application. Results show that embedding wallet functionality within the widely adopted IO platform, reusing existing national digital infrastructures, and adopting open technical specifications facilitated the activation of more than 12 million wallets and the large-scale issuance of digital credentials. Telemetry data reveal high onboarding completion rates, sustained user engagement, and different usage patterns across credential types. Beyond adoption metrics, the study identifies six critical success factors related to platform integration, interoperability, governance, stakeholder collaboration, user experience, and progressive alignment with evolving European standards. The findings highlight how the success of national digital identity wallets depends not only on regulatory compliance and technical architecture but also on software-engineering decisions, deployment strategies, and ecosystem governance. The Italian experience provides practical lessons for Member States implementing interoperable digital identity ecosystems and demonstrates the value of empirical measurement in evaluating large-scale digital public infrastructures.

Abstract: Positional argument binding, in which f(x, y, z) assigns meaning by slot order, degrades as arity grows, and logic programming suffers it worst: each position's semantics must be remembered rather than read off the call site, and keyword arguments only trade this for a vocabulary that is local to each predicate. We present the Karaka Calling Convention (KCC): arguments are bound by a fixed vocabulary of six semantic roles (agent, object, instrument, recipient, source, locus), drawn from Paninian Sanskrit grammar and carried morphologically by each argument. Because the vocabulary is predicate-independent, a rewrite rule written once against a role applies across all predicates, a property that keyword arguments and PropBank framesets lack. A parsed statement is already a labeled-edge graph, so the same object compiles to Prolog facts and to property-graph writes with no lowering pass, and groundness alone decides whether a statement is an assertion or a query. Rule conflicts resolve by requirement-set subsumption (the Paninian utsarga/apavada discipline), with incomparable rules rejected at registration as ambiguous. We give a formal definition, a worked end-to-end example, and a tested reference implementation with optional real Astadhyayi morphology via vidyut-prakriya; a prior-art search found one contemporaneous system using Karaka roles as call-site labels, and we characterize the overlap from its source. Measured readability benefit is open work, stated as such.

Abstract: Gamified e-learning platforms and Artificial Intelligence (AI)-driven adaptive learning systems have each demonstrated potential for improving learner engagement, yet existing solutions rarely integrate both, and few provide learner-facing explanations for their adaptive decisions. This article addresses this gap by proposing LearnSpace, a hybrid AI–gamification framework incorporating Explainable Artificial Intelligence (XAI) for adaptive e-learning that extends a deterministic reward architecture with an Explanation Layer. The framework combines classical gamification mechanics with an AI personalization module governed by explicit weighted formulas for experience-point calculation, reward modulation, and dynamic difficulty adjustment. Positioned downstream of the Decision Layer, the Explanation Layer identifies the dominant contributing factor behind each adaptive decision and expresses it as a short, learner-facing justification. The framework was informed by a comparative analysis of 14 existing e-learning platforms and was instantiated in a working mobile prototype, LearnSpace, built with Expo/React Native and Supabase. An illustrative decision case demonstrates how the proposed explanation mechanism can expose the reasoning underlying adaptive outputs without modifying the original reward computation. The proposed architecture provides a transparent and interpretable basis for future empirical evaluation of adaptive gamified learning systems.

Abstract: Agentic Large Language Model (LLM) systems that turn wearable streams into daily workout plans need matched-backbone tests with shared post-processing. We compare four system configurations for daily workout generation—Baseline-LLM (raw chart, no precompute), Single Agent, Multi-Agent, and ReAct—on N = 50 matched user-days (5 users × 10 days) from longitudinal wearable data. Four blind LLM judges (claude-opus-4-5, gemini-3.1-pro-preview, GPT-4o, deepseek-chat) scored each plan on eight rubric criteria (0–10). Baseline-LLM had the lowest overall mean (6.23) and sat significantly below each scaffolded arm (Single 7.20, Multi 7.34, ReAct 7.18; Holm-adj. p ≤ 0.0034), so deterministic Sports Data Scientist / Movement Planner (SDS/MP) preprocessing improves same-model output. Among scaffolded configurations, overall differences were not significant after Holm correction even though latency and cost differed sharply. Fleiss’ κ ≈ 0.18 is slight inter-judge agreement; scores measure automated rubric compliance, not clinical ground truth. Put deterministic preprocessing and calculation kernels in place before expecting rubric gains from multi-agent orchestration.

Abstract: There are always repeatable functions like building similar CRUD workflows, implementing authentication layers, role based access control and admin interfaces for various projects on an enterprise web application, and different con-ventions can be used by different developers or code-bases. AI-powered coding tools recently emerged that promise to make this possible, but existing studies have shown that automated LLM-based code generation, vibe coding and free-running multi-agent pipelines have difficulty maintaining consistency between relational schemas, backend APIs, and frontend interfaces as applications grow in size, and become a maintenance night-mare. The main idea is that structural code which can be programmed from an application data model does not need to be probabilistic (only truly ambiguous decisions are language-model decisions such as interpreting the relational semantics, or resolving ambiguous requirements). We build this insight into a system called CodeCraft, where a Prisma schema and its Data Model Meta Format (DMMF) representation are the only source of truth for deterministic generators to generate backend APIs, frontend manifests, RBAC structures and database seeders, while a LangGraph six-agent multi-agent orchestration pipeline (from requirements engineering, schema design, orchestration, backend generation, frontend generation, and containerization) can only be used to clarify requirements, validate schema, and make decisions that cannot be made structurally. Generated systems have a consistent schema representation, as opposed to the prompt-driven tools which are used for each individual file. In all the applications it is demonstrated that schema validation slashes the number of automated iterations required to correct schemas to 2-4 and the end-to-end generation generates deploy-able, containerised applications after requirements and schema approval (no manual effort required). Comparative engineering indicates that the development effort is reduced by 70–80%, compared to manual implementation, but this has not yet been substantiated with a controlled external study.