arXiv subjects

Attila Egri-Nagy

Publications and source records attributed to Attila Egri-Nagy.

At least 19 recordsLinked to original sources

arXiv2026

What if we have 90 minutes only to teach programming?

Programming is about automation in a wide variety of domains. Developing itself is one of those. As a side-effect, progress in automated coding may make people less willing to learn computer programming. This could become an issue, if the skill of computational problem solving is not only for the immediate economic benefit, but an important part of our knowledge about the world. We suggest that weakened incentives can be countered by lowering the entry barrier. We plan to shorten learning time by reducing the accidental complexity of the programming language and its runtime system. We describe a session plan that introduces programming and computing fundamentals for novices, assuming only basic mathematical background. This requires a non-mainstream, functional and concatenative language. This language, CON-CAT, is a by-product of research in category theory. It provides direct access to fundamental ideas like recursion and advanced ones like Gödel-encoding in an entertaining puzzle-like manner.

cs.PL↗

arXiv2026

Measuring the Computational Power of Finite Patches of Cellular Automata

Computational power can be measured by assigning an algebraic structure to a computational device. Here, we convert a small patch of Conway's Game of Life into a transformation semigroup. The conversion captures not only time evolution but also interactive operations. In this way, the cellular automaton becomes directly programmable. Once this measurement is made, we apply hierarchical decompositions to the resulting algebraic object as a way of understanding it. These decompositions are based on a macro/micro-state division inspired by statistical mechanics. However, cellular automata have a large number of global states. Therefore, we focus on partitioning the state space and creating morphic images approximations that can serve as macro-level descriptions. The methods developed here are not limited to cellular automata; they apply more generally to discrete dynamical systems.

nlin.CG↗

arXiv2026

Computing Embeddings and Isomorphisms of Finite Semigroups

Semigroup theory is a branch of abstract algebra, and it provides mathematical tools for the theory of computation. Finite semigroups can describe state transition systems and thus they model physically realizable computers. Engineering questions like `What is the minimal number of states to realize a particular computation?' and `Which type of computation is more capable?' translate into the algebraic tasks of constructing isomorphisms and embeddings between semigroups of different representations. The underlying problem is (sub)graph isomorphism, which is computationally difficult in general. We describe variations of backtrack search algorithms that exploit the algebraic properties of semigroups, and we carry out computational experiments to extend our algebraic knowledge. In particular, we report new computational results on transformation semigroups and on the more general family of diagram semigroups. We study the minimal degree representation problem, count distinct embeddings and work on an open problem of embedding into 2-generated subsemigroups.

math.GR↗

arXiv2026

Skeleton Key: Subduction Classes in Finite Transformation Semigroups and Green's Relations

We establish key connections between Green's $\cal J$- and $\cal L$-relations on a finite semigroup and the subduction relation defined on the image sets of an action of the same semigroup when it acts faithfully on a finite set. The construction of the skeleton order, the partial order on equivalence classes of the subduction relation, is shown to depend in a functorial way on transformation semigroups and surjective morphisms, and to factor through the Green's $\leq_{\cal L}$-order and $\leq_{\cal J}$-order on the semigroup and through the inclusion order on image sets. For right regular representations, the correspondence between the $\cal J$-class order and the skeleton order is one of isomorphism. Finally, we characterize the relationship between natural subsystems of a transformation semigroup, permutator groups and the $\cal H$-relation.

math.GR↗

arXiv2025

Bringing Algebraic Hierarchical Decompositions to Concatenative Functional Languages

Programming languages tend to evolve over time to use more and more concepts from theoretical computer science. Still, there is a gap between programming and pure mathematics. Not all theoretical results have realized their promising applications. The algebraic decomposition of finite state automata (Krohn-Rhodes Theory) constructs an emulating hierarchical structure from simpler components for any computing device. These decompositions provide ways to understand and control computational processes, but so far the applications were limited to theoretical investigations. Here, we study how to apply algebraic decompositions to programming languages. We use recent results on generalizing the algebraic theory to the categorical level (from semigroups to semigroupoids) and work with the special class of concatenative functional programming languages. As a first application of semigroupoid decompositions, we start to design a family of programming languages with an explicit semigroupoid representation.

cs.FL↗

arXiv2025

Computational Exploration of Finite Semigroupoids

Recent algorithmic advances in algebraic automata theory drew attention to semigroupoids (semicategories). These are mathematical descriptions of typed computational processes, but they have not been studied systematically in the context of automata. Here, we use relational programming to explore finite semigroupoids to improve our mathematical intuition about these models of computation. We implement declarative solutions for enumerating abstract semigroupoids (partial composition tables), finding homomorphisms, and constructing (minimal) transformation representations. We show that associativity and consistent typing are different properties, distinguish between strict and more permissive homomorphisms, and systematically enumerate arrow-type semigroupoids (reified type structures).

cs.FL↗

arXiv2025

Morphisms (should be) everywhere

Morphisms, structure preserving maps, are everywhere in Mathematics as useful tools for thinking and problem solving, or as objects to study. Here, we argue that the idea of operations being compatible across two domains goes beyond its mathematical use: it is a fundamental mechanism of any intelligence. We precisely define morphisms, distinguish between dynamic morphisms (on operations, binary relations) and static ones (on $n$-ary relations), and describe how a flexible and pluralistic use of morphisms can serve as a general framework for understanding and explanation in a wide variety of fields.

math.HO↗

arXiv2025

The Attractor-Cycle Notation for Finite Transformations

We describe a new notation for finite transformations. This attractor-cycle notation extends the orbit-cycle notation for permutations and builds upon existing transformation notations. How the basins of attraction of a finite transformation flow into permuted orbit cycles is visible from the notation. It gives insight into the structure of transformations and reduces the length of expressions without increasing the number of types of symbols.

math.GR↗

arXiv2025

Representation Independent Decompositions of Computation

Constructing complex computation from simpler building blocks is a defining problem of computer science. In algebraic automata theory, we represent computing devices as semigroups. Accordingly, we use mathematical tools like products and homomorphisms to understand computation through hierarchical decompositions. To address the shortcomings of some of the existing decomposition methods, we generalize semigroup representations to semigroupoids by introducing types. On the abstraction level of category theory, we describe a flexible, iterative and representation independent algorithm. Moving from the specific state transition model to the abstract composition of arrows unifies seemingly different decomposition methods and clarifies the three algorithmic stages: collapse, copy and compress. We collapse some dynamics through a morphism to the top level; copy the forgotten details into the bottom level; and finally we apply compression there. The hierarchical connections are solely for locating the repeating patterns in the compression. These theoretical findings pave the way for more precise computer algebra tools and allow for understanding computation with other algebraic structures.

math.GR↗

arXiv2025

On Constructing Finite Automata by Relational Programming

We consider ways to construct a transducer for a given set of input word to output symbol pairs. This is motivated by the need for representing game playing programs in a low-level mathematical format that can be analyzed by algebraic tools. This is different from the classical applications of finite state automata, thus the usual optimization techniques are not directly applicable. Therefore, we use relational programming tools to find minimal transducers realizing a given set of input-output pairs.

cs.FL↗

arXiv2024

From Relation to Emulation and Interpretation: Computer Algebra Implementation of the Covering Lemma for Finite Transformation Semigroups

We give a practical computer algebra implementation of the Covering Lemma for finite transformation semigroups. The lemma states that given a surjective relational morphism $(X,S)\twoheadrightarrow(Y,T)$, we can establish emulation by a cascade product (subsemigroup of the wreath product): $(X,S)\hookrightarrow (Y,T)\wr (Z,U)$. The dependent component $(Z,U)$ contains the kernel of the morphism, the information lost in the map. The implementation complements the existing tools for the holonomy decomposition algorithm. It gives an incremental method to get a coarser decomposition when computing the complete skeleton for holonomy is not feasible. Here, we describe a simplified and generalized algorithm for the lemma and compare it to the holonomy method. Incidentally, the kernel-based method could be the easiest way of understanding the hierarchical decompositions of transformation semigroups and thus the celebrated Krohn-Rhodes theory.

math.GR↗

arXiv2022

The cost of passing -- using deep learning AIs to expand our understanding of the ancient game of Go

AI engines utilizing deep learning neural networks provide excellent tools for analyzing traditional board games. Here we are interested in gaining new insights into the ancient game of Go. For that purpose, we need to define new numerical measures based on the raw output of the engines. In this paper, we develop a numerical tool for automated move-by-move performance evaluation in a context-sensitive manner and for recognizing game features. We measure the urgency of a move by the cost of passing, which is the score value difference between the current configuration of stones and after a hypothetical pass in the same board position. Here we investigate the properties of this measure and describe some applications.

cs.AI↗

arXiv2021

Cascade Product of Permutation Groups

Motivated by computational efficiency in algebraic automata theory here we define the cascade product of permutation groups as an external product, as a generic extension. It is the most general hierarchical product that uses arbitrary total functions to combine a linearly ordered set of permutation groups. Algebraically speaking, cascade products are explicitly constructed substructures of the iterated wreath product. We show how direct, semidirect and wreath products can be described as cascade products and we also discuss examples of composite groups that can only be constructed exactly as generic extensions by cascade products. The cascade construction naturally generalizes to the transformation semigroup case by leaving out the details of defining inverse operations.

math.GR↗

arXiv2020

Derived metrics for the game of Go -- intrinsic network strength assessment and cheat-detection

The widespread availability of superhuman AI engines is changing how we play the ancient game of Go. The open-source software packages developed after the AlphaGo series shifted focus from producing strong playing entities to providing tools for analyzing games. Here we describe two ways of how the innovations of the second generation engines (e.g.~score estimates, variable komi) can be used for defining new metrics that help deepen our understanding of the game. First, we study how much information the search component contributes in addition to the raw neural network policy output. This gives an intrinsic strength measurement for the neural network. Second, we define the effect of a move by the difference in score estimates. This gives a fine-grained, move-by-move performance evaluation of a player. We use this in combating the new challenge of detecting online cheating.

cs.AI↗

arXiv2020

A path-deformation framework for determining weighted genome rearrangement distance

Measuring the distance between two bacterial genomes under the inversion process is usually done by assuming all inversions to occur with equal probability. Recently, an approach to calculating inversion distance using group theory was introduced, and is effective for the model in which only very short inversions occur. In this paper, we show how to use the group-theoretic framework to establish minimal distance for any weighting on the set of inversions, generalizing previous approaches. To do this we use the theory of rewriting systems for groups, and exploit the Knuth--Bendix algorithm, the first time this theory has been introduced into genome rearrangement problems. The central idea of the approach is to use existing group theoretic methods to find an initial path between two genomes in genome space (for instance using only short inversions), and then to deform this path to optimality using a confluent system of rewriting rules generated by the Knuth--Bendix algorithm.

math.CO↗

arXiv2018

|{Math, Philosophy, Programming, Writing}| = 1

Philosophical thinking has a side effect: by aiming to find the essence of a diverse set of phenomena, it often makes it difficult to see the differences between them. This can be the case with Mathematics, Programming, Writing and Philosophy itself. Their unified essence is having a shared understanding of the world helped by off-loading our cognitive efforts to suitable languages.

cs.CY↗

arXiv2017

The Algebraic View of Computation

We argue that computation is an abstract algebraic concept, and a computer is a result of a morphism (a structure preserving map) from a finite universal semigroup.

cs.LO↗

arXiv2017

Declarativeness: the work done by something else

Being declarative means that we do computer programming on higher levels of abstraction. This vague definition identifies declarativeness with the act of ignoring details, but it is a special case of abstraction. The unspecified part is some computational work. Automating computations and offloading mental processing are essentially the same concept, which is fundamental for both computational and mathematical thinking. This shows that declarativeness is not just a particular style, but it is the core idea of programming. Here we demonstrate this argument and examine its consequences for teaching by a systematic study of coding examples from an introductory programming course. The chosen language is Clojure, as it is proven to be accessible for novices.

cs.PL↗