All your bases are belong to us : listing all bases of a matroid by greedy exchanges

You provide us with a matroid and an initial base. We say that a subset of the bases "belongs to us" if we can visit each one via a sequence of base exchanges starting from the initial base. It is well-known that "All your base are belong to us". We refine this classic result by showing that it can be done by a simple greedy algorithm. For example, the spanning trees of a graph can be generated by edge exchanges using the following greedy rule: Minimize the larger label of an edge that enters or exits the current spanning tree and which creates a spanning tree that is new (i.e., hasn't been visited already). Amazingly, this works for any graph, for any labeling of its edges, for any initial spanning tree, and regardless of how you choose the edge with the smaller label in each exchange. Furthermore, by maintaining a small amount of information, we can generate each successive spanning tree without storing the previous trees. In general, for any matroid, we can greedily compute a listing of all its bases matroid such that consecutive bases differ by a base exchange. Our base exchange Gray codes apply a prefix-exchange on a prefix-minor of the matroid, and we can generate these orders using "history-free" iterative algorithms. More specifically, we store O(m) bits of data, and use O(m) time per base assuming O(1) time independence and coindependence oracles. Our work generalizes and extends a number of previous results. For example, the bases of the uniform matroid are combinations, and they belong to us using homogeneous transpositions via an Eades-McKay style order. Similarly, the spanning trees of fan graphs belong to us via face pivot Gray codes, which extends recent results of Cameron, Grubb, and Sawada [Pivot Gray Codes for the Spanning Trees of a Graph ft. the Fan, COCOON 2021]

On Two Ways of Enumerating Ordered Trees

The middle-levels graph $M_k$ ($0<k\in\mathbb{Z}$) has a dihedral quotient pseudograph $R_k$ whose vertices are the $k$-edge ordered trees $T$, each $T$ encoded as a $(2k+1)$-string $F(T)$ formed via $\rightarrow$DFS by: {\bf(i)} ($\leftarrow$BFS-assigned) Kierstead-Trotter lexical colors $0,\ldots,k$ for the descending nodes; {\bf(ii)} asterisks $*$ for the $k$ ascending edges. Two ways of corresponding a restricted-growth $k$-string $\alpha$ to each $T$ exist, namely one Stanley's way and a novel way that assigns $F(T)$ to $\alpha$ via nested substring-swaps. These swaps permit to sort $V(R_k)$ as an ordered tree that allows a lexical visualization of $M_k$ as well as the Hamilton cycles of $M_k$ constructed by P. Gregor, T. M\"utze and J. Nummenpalo.Comment: 26 pages, 8 figures, 10 table

Automated extraction of mutual independence patterns using Bayesian comparison of partition models

Mutual independence is a key concept in statistics that characterizes the structural relationships between variables. Existing methods to investigate mutual independence rely on the definition of two competing models, one being nested into the other and used to generate a null distribution for a statistic of interest, usually under the asymptotic assumption of large sample size. As such, these methods have a very restricted scope of application. In the present manuscript, we propose to change the investigation of mutual independence from a hypothesis-driven task that can only be applied in very specific cases to a blind and automated search within patterns of mutual independence. To this end, we treat the issue as one of model comparison that we solve in a Bayesian framework. We show the relationship between such an approach and existing methods in the case of multivariate normal distributions as well as cross-classified multinomial distributions. We propose a general Markov chain Monte Carlo (MCMC) algorithm to numerically approximate the posterior distribution on the space of all patterns of mutual independence. The relevance of the method is demonstrated on synthetic data as well as two real datasets, showing the unique insight provided by this approach.Comment: IEEE Transactions on Pattern Analysis and Machine Intelligence (in press

Flora: a framework for decomposing software architecture to introduce local recovery

The decomposition of software architecture into modular units is usually driven by the required quality concerns. In this paper we focus on the impact of local recovery concern on the decomposition of the software system. For achieving local recovery, the system needs to be decomposed into separate units that can be recovered in isolation. However, it appears that this required decomposition for recovery is usually not aligned with the decomposition based on functional concerns. Moreover, introducing local recovery to a software system, while preserving the existing decomposition, is not trivial and requires substantial development and maintenance effort. To reduce this effort we propose a framework that supports the decomposition and implementation of software architecture for local recovery. The framework provides reusable abstractions for defining recoverable units and the necessary coordination and communication protocols for recovery. We discuss our experiences in the application and evaluation of the framework for introducing local recovery to the open-source media player called MPlayer. Copyright 2009 John Wiley & Sons, Ltd

LIPIcs, Volume 248, ISAAC 2022, Complete Volume

LIPIcs, Volume 248, ISAAC 2022, Complete Volum

Les codes Gray pour les idéaux d'un poset et pour d'autres objets combinatoires

Pruesse et Ruskey ont trouvé un code Gray pour les idéaux d'un ensemble partiellement ordonné (poset) et un algorithme récursif pour les engendrer. Dans ce mémoire, un algorithme non-récursif qui engendre la même liste d'idéaux est présenté. De plus, plusieurs autres codes Gray classiques majoritairement reliés aux posets et leurs implantations\ud sont étudiés. Plus particulièrement, les codes Gray de Chase et de Ruskey pour les combinaisons, celui de Ruskey et Proskurowski pour les mots de Dyck et celui de Walsh pour les involutions sans point fixe sont étudiés. Le code Gray de Chase est présenté sous forme d'un programme FORTRAN. Vajnovszki et Walsh ont trouvé une implantation plus simple sans en donner une preuve formelle; une telle preuve est présentée dans ce mémoire. ______________________________________________________________________________ MOTS-CLÉS DE L’AUTEUR : Code Gray, Idéal, Ensemble partiellement ordonné (poset), Extension linéaire, Poset forêt, Algorithme, Non-récursif, Sans-boucle, Temps constant amorti (CAT)

Optimizing decomposition of software architecture for local recovery

Cataloged from PDF version of article.The increasing size and complexity of software systems has led to an amplified number of potential failures and as such makes it harder to ensure software reliability. Since it is usually hard to prevent all the failures, fault tolerance techniques have become more important. An essential element of fault tolerance is the recovery from failures. Local recovery is an effective approach whereby only the erroneous parts of the system are recovered while the other parts remain available. For achieving local recovery, the architecture needs to be decomposed into separate units that can be recovered in isolation. Usually, there are many different alternative ways to decompose the system into recoverable units. It appears that each of these decomposition alternatives performs differently with respect to availability and performance metrics. We propose a systematic approach dedicated to optimizing the decomposition of software architecture for local recovery. The approach provides systematic guidelines to depict the design space of the possible decomposition alternatives, to reduce the design space with respect to domain and stakeholder constraints and to balance the feasible alternatives with respect to availability and performance. The approach is supported by an integrated set of tools and illustrated for the open-source MPlayer software

Simple combinatorial Gray codes constructed by reversing sublists

. We present three related results about simple combinatorial Gray codes constructed recursively by reversing certain sublists. First, we show a bijection between the list of compositions of Knuth and the list of combinations of Eades and McKay. Secondly, we provide a short description of a list of combinations satisfying a more restrictive closeness criteria of Chase. Finally, we develop a new, simply described, Gray code list of the partitions of a set into a fixed number of blocks, as represented by restricted growth sequences. In each case the recursive definition of the list is easily translatable into an algorithm for generating the list in time proportional to the number of elements in the list; i.e., each object is produced in O(1) amortized time by the algorithm. 1 Introduction Frank Gray patented the Binary Reflected Gray Code (BRGC) in 1953 for use in &quot;pulse code communication&quot;, but the underlying construction of the code existed for centuries as the solution of a puzzle th..