Searcharxiv⌕ Search

arXiv subjects

Russell K. Standish

Publications and source records attributed to Russell K. Standish.

At least 19 recordsLinked to original sources
arXiv2026

Fragmentation is a diversity ratchet

A fragmented landscape reduces the impact of interspecies connectivity, leading to higher diversity levels than otherwise possible in a connected landscape. Reconnecting a previously fragmented landscape initiates an extinction event, preferentially weeding out more highly connected species. A sequence of fragmentation-coalescence events will drive the ecosystem to higher levels of diversity in a ratchet-like effect, than if the landscape continuously remained connected.

q-bio.PE↗
arXiv2026

An improved upper bound measure of star complexity of graphs

In \cite{Standish25c}, I explored the connection between star complexity and information based complexity. Because of the numerical difficulty in computing star complexity, I introduced a proxy measure that is an upper bound to star complexity, and showed a strong albeit non-linear relationship between the measures. In this paper, I introduce a tighter upper bound, by exploiting the well-known ABC package used to optimise logic circuits. In testing the new measure, I found that I had been computing the {\em formula complexity} variant of star complexity, rather than the tighter {\em circuit complexity} variant. Since Jukna clearly states the connection between star complexity and circuit complexity, I have modified the graph walking algorithm to capture circuit complexity rather than formula complexity. With this new ABC-based measure, applied to a set of 1000 500 vertex Erd\"os-Renyi graphs, a more linear relationship between star complexity and information based complexity is found.

cs.CC↗
arXiv2025

Is star complexity a proxy for information based complexity of graphs?

Information-based complexity (IBC) is a well-defined complexity measure of any object given a description in a language and a classifier that identifies those descriptions with the object. Of course, the exact numerical value will vary according to the descriptive language and classifier, but under certain universality conditions (eg the classifier identifies programs of a universal Turning machine that halt and output the same value), asymptotically, the complexity measure is independent of the classifier up to a constant of O(1). The hypothesis being investigated in this work that any practical IBC measure will similarly be asymptotically equivalent to any other practical IBC measure. Standish presented an IBC measure for graphs ${\cal C}$ that encoded graphs by their links, and identifies graphs as those that are automorphic to each other. An interesting alternate graph measure is {\em star complexity}, which is defined as the number of union and intersection operations of basic stars that can generate the original graph. Whilst not an IBC itself, it can be related to an IBC (called ${\cal C}^*$) that is strongly correlated with star complexity. In this paper, 10 and 22 vertex graphs are constructed up to a star complexity of 8, and the ${\cal C}^*$ compared emprically with ${\cal C}$. Finally, an easily computable upper bound of star complexity is found to be strongly related to ${\cal C}$.

cs.IT↗
arXiv2025

Dynamic Memory Management on GPUs with SYCL

Dynamic memory allocation is not traditionally available in kernels running on GPUs. This work aims to build on Ouroboros, an efficient dynamic memory management library for CUDA applications, by porting the code to SYCL, a cross-platform accelerator API. Since SYCL can be compiled to a CUDA backend, it is possible to compare the performance of the SYCL implementation with that of the original CUDA implementation, as well as test it on non-CUDA platforms such as Intel's Xe graphics.

cs.DC↗
arXiv2024

Fat API bindings of C++ objects into scripting languages

A fat API exposes nearly all of a C++ object's public attributes and methods to a consuming environment, such as a scripting language, or web client. This can be contrasted with a conventional, or thin API, where the API is defined up front, and the C++ object provides the implementation, most of which is private to the C++ layer. Obviously, reflection is required to expose C++ objects to a consuming layer like this -- this paper explores using the Classdesc system to implement reflection of C++ objects into a JavaScript/TypeScript environment via a RESTservice, and also via a Node.js API module.

cs.PL↗
arXiv2018

Rationality in the Theory of the Firm

We have previously presented a critique of the standard Marshallian theory of the firm, and developed an alternative formulation that better agreed with the results of simulation. An incorrect mathematical fact was used in our previous presentation. This paper deals with correcting the derivation of the Keen equilibrium, and generalising the result to the asymmetric case. As well, we discuss the notion of rationality employed, and how this plays out in a two player version of the game.

nlin.AO↗
arXiv2016

The Movie Graph Argument Revisited

In this paper, we reexamine the Movie Graph Argument, which demonstrates a basic incompatibility between computationalism and materialism. We discover that the incompatibility is only manifest in singular classical-like universes. If we accept that we live in a Multiverse, then the incompatibility goes away, but in that case another line of argument shows that with computationalism, the fundamental, or primitive materiality has no causal influence on what is observed, which must must be derivable from basic arithmetic properties.

cs.AI↗
arXiv2013

Comment on "On the proper behavior of atoms" by Paul Anglin

Paul Anglin criticised our analysis of the neoclassical theory of the firm, but makes a number of incorrect assertions about our assumptions. We correct these misunderstandings, but acknowledge that one criticism he makes is correct. We correct this flaw with a new argument that supersedes the flawed strategic reaction argument we presented in our previous paper.

nlin.AO↗
arXiv2013

Ants are not Conscious

Anthropic reasoning is a form of statistical reasoning based upon finding oneself a member of a particular reference class of conscious beings. By considering empirical distribution functions defined over animal life on Earth, we can deduce that the vast bulk of animal life is unlikely to be conscious.

physics.data-an↗
arXiv2012

SuperNOVA: a novel algorithm for graph automorphism calculations

The graph isomorphism problem is of practical importance, as well as being a theoretical curiosity in computational complexity theory in that it is not known whether it is $NP$-complete or $P$. However, for many graphs, the problem is tractable, and related to the problem of finding the automorphism group of the graph. Perhaps the most well known state-of-the art implementation for finding the automorphism group is Nauty. However, Nauty is particularly susceptible to poor performance on star configurations, where the spokes of the star are isomorphic with each other. In this work, I present an algorithm that explodes these star configurations, reducing the problem to a sequence of simpler automorphism group calculations.

cs.DS↗
arXiv2011

Complexity of Networks (reprise)

Network or graph structures are ubiquitous in the study of complex systems. Often, we are interested in complexity trends of these system as it evolves under some dynamic. An example might be looking at the complexity of a food web as species enter an ecosystem via migration or speciation, and leave via extinction. In a previous paper, a complexity measure of networks was proposed based on the {\em complexity is information content} paradigm. To apply this paradigm to any object, one must fix two things: a representation language, in which strings of symbols from some alphabet describe, or stand for the objects being considered; and a means of determining when two such descriptions refer to the same object. With these two things set, the information content of an object can be computed in principle from the number of equivalent descriptions describing a particular object. The previously proposed representation language had the deficiency that the fully connected and empty networks were the most complex for a given number of nodes. A variation of this measure, called zcomplexity, applied a compression algorithm to the resulting bitstring representation, to solve this problem. Unfortunately, zcomplexity proved too computationally expensive to be practical. In this paper, I propose a new representation language that encodes the number of links along with the number of nodes and a representation of the linklist. This, like zcomplexity, exhibits minimal complexity for fully connected and empty networks, but is as tractable as the original measure. ...

cs.IT↗
arXiv2010

Network Complexity of Foodwebs

In previous work, I have developed an information theoretic complexity measure of networks. When applied to several real world food webs, there is a distinct difference in complexity between the real food web, and randomised control networks obtained by shuffling the network links. One hypothesis is that this complexity surplus represents information captured by the evolutionary process that generated the network. In this paper, I test this idea by applying the same complexity measure to several well-known artificial life models that exhibit ecological networks: Tierra, EcoLab and Webworld. Contrary to what was found in real networks, the artificial life generated foodwebs had little information difference between itself and randomly shuffled versions.

nlin.AO↗
arXiv2008

Classdesc and Graphcode: support for scientific programming in C++

Object-oriented programming languages such as Java and Objective C have become popular for implementing agent-based and other object-based simulations since objects in those languages can {\em reflect} (i.e. make runtime queries of an object's structure). This allows, for example, a fairly trivial {\em serialisation} routine (conversion of an object into a binary representation that can be stored or passed over a network) to be written. However C++ does not offer this ability, as type information is thrown away at compile time. Yet C++ is often a preferred development environment, whether for performance reasons or for its expressive features such as operator overloading. In scientific coding, changes to a model's codes takes place constantly, as the model is refined, and different phenomena are studied. Yet traditionally, facilities such as checkpointing, routines for initialising model parameters and analysis of model output depend on the underlying model remaining static, otherwise each time a model is modified, a whole slew of supporting routines needs to be changed to reflect the new data structures. Reflection offers the advantage of the simulation framework adapting to the underlying model without programmer intervention, reducing the effort of modifying the model. In this paper, we present the {\em Classdesc} system which brings many of the benefits of object reflection to C++, {\em ClassdescMP} which dramatically simplifies coding of MPI based parallel programs and {\em Graphcode} a general purpose data parallel programming environment.

cs.MS↗
arXiv2008

Concept and Definition of Complexity

The term {\em complexity} is used informally both as a quality and as a quantity. As a quality, complexity has something to do with our ability to understand a system or object -- we understand simple systems, but not complex ones. On another level, {\em complexity} is used as a quantity, when we talk about something being more complicated than another. In this chapter, we explore the formalisation of both meanings of complexity, which happened during the latter half of the twentieth century.

nlin.AO↗
arXiv2006

Going Stupid with EcoLab

In 2005, Railsback et al. proposed a very simple model ({\em Stupid Model}) that could be implemented within a couple of hours, and later extended to demonstrate the use of common ABM platform functionality. They provided implementations of the model in several agent based modelling platforms, and compared the platforms for ease of implementation of this simple model, and performance. In this paper, I implement Railsback et al's Stupid Model in the EcoLab simulation platform, a C++ based modelling platform, demonstrating that it is a feasible platform for these sorts of models, and compare the performance of the implementation with Repast, Mason and Swarm versions.

cs.MA↗
arXiv2006

Profit Maximization, Industry Structure, and Competition: A critique of neoclassical theory

Neoclassical economics has two theories of competition between profit-maximizing firms (Marshallian and Cournot-Nash) that start from different premises about the degree of strategic interaction between firms, yet reach the same result, that market price falls as the number of firms in an industry increases. The Marshallian argument is strictly false. We integrate the different premises, and establish that the optimal level of strategic interaction between competing firms is zero. Simulations support our analysis and reveal intriguing emergent behaviors.

nlin.AO↗
arXiv2006

The influence of parsimony and randomness on complexity growth in Tierra

The issue of how to create open-ended evolution in an artificial system is one the open problems in artificial life. This paper examines two of the factors that have some bearing on this issue, using the Tierra artificial life system. {\em Parsimony pressure} is a tendency to penalise more complex organisms by the extra cost needed to reproduce longer genotypes, encouraging simplification to happen. In Tierra, parsimony is controlled by the \verb+SlicePow+ parameter. When full parsimony is selected, evolution optimises the ancestral organism to produce extremely simple organisms. With parsimony completely relaxed, organisms grow larger, but not more complex. They fill up with ``junk''. This paper looks at scanning a range of \verb+SlicePow+ from 0.9 to 1 to see if there is an optimal value for generating complexity. Tierra (along with most ALife systems) use pseudo random number generators. Algorithms can never create information, only destroy it. So the total complexity of the Tierra system is bounded by the initial complexity, implying that the individual organism complexity is bounded. Biological systems, however, have plenty of sources of randomness, ultimately dependent on quantum randomness, so do not have this complexity limit. Sources of real random numbers exist for computers called {\em entropy gatherers} -- this paper reports on the effect of changing Tierra's pseudo random number generator for an entropy gatherer.

nlin.AO↗