Search

We study the spectral implications of re-weighting a graph by the $\ell_\infty$-Lewis weights of its edges. Our main motivation is the ER-Minimization problem (Saberi et al., SIAM'08): Given an undirected graph $G$, the goal is to find positive normalized edge-weights $w\in \mathbb{R}_+^m$ which minimize the sum of pairwise \emph{effective-resistances} of $G_w$ (Kirchhoff's index). By contrast, $\ell_\infty$-Lewis weights minimize the \emph{maximum} effective-resistance of \emph{edges}, but are much cheaper to approximate, especially for Laplacians. With this algorithmic motivation, we study the ER-approximation ratio obtained by Lewis weights. Our first main result is that $\ell_\infty$-Lewis weights provide a constant ($\approx 3.12$) approximation for ER-minimization on \emph{trees}. The proof introduces a new technique, a local polarization process for effective-resistances ($\ell_2$-congestion) on trees, which is of independent interest in electrical network analysis. For general graphs, we prove an upper bound $\alpha(G)$ on the approximation ratio obtained by Lewis weights, which is always $\leq \min\{ \text{diam}(G), \kappa(L_{w_\infty})\}$, where $\kappa$ is the condition number of the weighted Laplacian. All our approximation algorithms run in \emph{input-sparsity} time $\tilde{O}(m)$, a major improvement over Saberi et al.'s $O(m^{3.5})$ SDP for exact ER-minimization. Finally, we demonstrate the favorable effects of $\ell_\infty$-LW reweighting on the \emph{spectral-gap} of graphs and on their \emph{spectral-thinness} (Anari and Gharan, 2015). En-route to our results, we prove a weighted analogue of Mohar's classical bound on $\lambda_2(G)$, and provide a new characterization of leverage-scores of a matrix, as the gradient (w.r.t weights) of the volume of the enclosing ellipsoid.

A feedback vertex set of a graph is a set of nodes with the property that every cycle contains at least one vertex from the set i.e. the removal of all vertices from a feedback vertex set leads to an acyclic graph. In this short paper, we describe the algorithm for finding a minimum directed feedback vertex set used by the _UAIC_ANDREIARHIRE_ solver, submitted to the heuristic track of the 2022 PACE challenge., Comment: Second best student submission of Heuristic Track of the Feedback Vertex Set Challenge at PACE 2022, https://pacechallenge.org/ https://github.com/AndreiiArhire/PACE2022

Calculating the probability of an individual solution being selected under lexicase selection is an important problem in attempts to develop a deeper theoretical understanding of lexicase selection, a state-of-the art parent selection algorithm in evolutionary computation. Discovering a fast solution to this problem would also have implications for efforts to develop practical improvements to lexicase selection. Here, I prove that this problem, which I name lex-prob, is NP-Hard. I achieve this proof by reducing SAT, a well-known NP-Complete problem, to lex-prob in polynomial time. This reduction involves an intermediate step in which a popular variant of lexicase selection, epsilon-lexicase selection, is reduced to standard lexicase selection. This proof has important practical implications for anyone needing a fast way of calculating the probabilities of individual solutions being selected under lexicase selection. Doing so in polynomial time would be incredibly challenging, if not all-together impossible. Thus, finding approximation algorithms or practical optimizations for speeding up the brute-force solution is likely more worthwhile. This result also has deeper theoretical implications about the relationship between epsilon-lexicase selection and lexicase selection and the relationship between lex-prob and other NP-Hard problems.

The equation of state with quantum statistics corrections is used for particle number fluctuations $\omega$ of isotopically symmetric nuclear matter with interparticle van der Waals and Skyrme local density interactions. The fluctuations, $\omega\propto 1/\mathcal{K}$, are analytically derived through the isothermal incompressibility $\mathcal{K}$ at first order over a small quantum-statistics parameter. Our approximate analytical results appear to be in good agreement with the results of accurate numerical calculations. These results are also close to those obtained by using more accurate Tolman and Rowlinson expansions of the incompressibility $\mathcal{K}$ near the critical point. A more general formula for fluctuations $\omega$, improved at the critical point, was obtained for a finite particle-number average $\langle N \rangle$ by neglecting, for simplicity, small quantum statistics effects. It is shown that for a large dimensionless parameter, $\alpha \propto \mathcal{K}^2\langle N \rangle/\mathcal{K}^{\prime\prime} $, where $\mathcal{K}^{\prime\prime}$ is the second derivative of the incompressibility $\mathcal{K}$ as function of the average particle density $n$, far from the critical point ($\alpha \gg 1$), one finds the traditional asymptote, $\omega\propto 1/\mathcal{K}$, for the fluctuations $\omega$. For a small parameter, $\alpha \ll 1$, near the critical point, where $\mathcal{K}=0$ and $\alpha=0$, one obtains another asymptote of $\omega$. These fluctuations, having a maximum near the critical point as function of the average density $n$, for finite values of $\langle N \rangle$ are finite and relatively small, in contrast to the results of the traditional calculations., Comment: 22 pages, 10 figures, 2 tables

We consider algorithms for finding and counting small, fixed graphs in sparse host graphs. In the non-sparse setting, the parameters treedepth and treewidth play a crucial role in fast, constant-space and polynomial-space algorithms respectively. We discover two new parameters that we call matched treedepth and matched treewidth. We show that finding and counting patterns with low matched treedepth and low matched treewidth can be done asymptotically faster than the existing algorithms when the host graphs are sparse for many patterns. As an application to finding and counting fixed-size patterns, we discover $\otilde(m^3)$-time \footnote{$\otilde$ hides factors that are logarithmic in the input size.}, constant-space algorithms for cycles of length at most $11$ and $\otilde(m^2)$-time, polynomial-space algorithms for paths of length at most $10$.

Random graph models with community structure have been studied extensively in the literature. For both the problems of detecting and recovering community structure, an interesting landscape of statistical and computational phase transitions has emerged. A natural unanswered question is: might it be possible to infer properties of the community structure (for instance, the number and sizes of communities) even in situations where actually finding those communities is believed to be computationally hard? We show the answer is no. In particular, we consider certain hypothesis testing problems between models with different community structures, and we show (in the low-degree polynomial framework) that testing between two options is as hard as finding the communities. In addition, our methods give the first computational lower bounds for testing between two different `planted' distributions, whereas previous results have considered testing between a planted distribution and an i.i.d. `null' distribution., Comment: Accepted to Innovations in Theoretical Computer Science (ITCS) 2023

We design new polynomial-time algorithms for recovering planted cliques in the semi-random graph model introduced by Feige and Kilian 2001. The previous best algorithms for this model succeed if the planted clique has size at least $n^{2/3}$ in a graph with $n$ vertices (Mehta, Mckenzie, Trevisan 2019 and Charikar, Steinhardt, Valiant 2017). Our algorithms work for planted-clique sizes approaching $n^{1/2}$ -- the information-theoretic threshold in the semi-random model (Steinhardt 2017) and a conjectured computational threshold even in the easier fully-random model. This result comes close to resolving open questions by Feige 2019 and Steinhardt 2017. Our algorithms are based on higher constant degree sum-of-squares relaxation and rely on a new conceptual connection that translates certificates of upper bounds on biclique numbers in unbalanced bipartite Erd\H{o}s--R\'enyi random graphs into algorithms for semi-random planted clique. The use of a higher-constant degree sum-of-squares is essential in our setting: we prove a lower bound on the basic SDP for certifying bicliques that shows that the basic SDP cannot succeed for planted cliques of size $k =o(n^{2/3})$. We also provide some evidence that the information-computation trade-off of our current algorithms may be inherent by proving an average-case lower bound for unbalanced bicliques in the low-degree-polynomials model., Comment: 51 pages, the arxiv landing page contains a shortened abstract

This is a review of recent research exploring and extending present-day quantum computing capabilities for fusion energy science applications. We begin with a brief tutorial on both ideal and open quantum dynamics, universal quantum computation, and quantum algorithms. Then, we explore the topic of using quantum computers to simulate both linear and nonlinear dynamics in greater detail. Because quantum computers can only efficiently perform linear operations on the quantum state, it is challenging to perform nonlinear operations that are generically required to describe the nonlinear differential equations of interest. In this work, we extend previous results on embedding nonlinear systems within linear systems by explicitly deriving the connection between the Koopman evolution operator, the Perron-Frobenius evolution operator, and the Koopman-von Neumann evolution (KvN) operator. We also explicitly derive the connection between the Koopman and Carleman approaches to embedding. Extension of the KvN framework to the complex-analytic setting relevant to Carleman embedding, and the proof that different choices of complex analytic reproducing kernel Hilbert spaces depend on the choice of Hilbert space metric are covered in the appendices. Finally, we conclude with a review of recent quantum hardware implementations of algorithms on present-day quantum hardware platforms that may one day be accelerated through Hamiltonian simulation. We discuss the simulation of toy models of wave-particle interactions through the simulation of quantum maps and of wave-wave interactions important in nonlinear plasma dynamics., Comment: 42 pages; 12 figures; invited paper at the 2021-2022 International Sherwood Fusion Theory Conference

Consider the $n$-cube graph with vertices $\{-1,1\}^n$ and edges connecting vertices with hamming distance $1$. How many hyperplanes in $\mathbb{R}^n$ are needed in order to dissect all edges? We show that at least $\widetilde{\Omega}(n^{2/3})$ are needed, which improves the previous bound of $\Omega(n^{0.51})$ by Yehuda and Yehudayoff., Comment: 10 pages; A few inaccuracies corrected

Equation-based modelling is a powerful approach to tame the complexity of large-scale simulation problems. Equation-based tools automatically translate models into imperative languages. When confronted with nowadays' problems, however, well assessed model translation techniques exhibit scalability issues, that are particularly severe when models contain very large arrays. In fact, such models can be made very compact by enclosing equations into looping constructs, but reflecting the same compactness into the translated imperative code is not trivial. In this paper, we face this issue by concentrating on a key step of equations-to-code translation, the equation/variable matching. We first show that an efficient translation of models with (large) arrays needs awareness of their presence, by defining a figure of merit to measure how much the looping constructs are preserved along the translation. We then show that the said figure of merit allows to define an optimal array-aware matching, and as our main result, that the so stated optimal array-aware matching problem is NP-complete. As an additional result, we propose a heuristic algorithm capable of performing array-aware matching in polynomial time. The proposed algorithm can be proficiently used by model translator developers in the implementation of efficient tools for large-scale system simulation.

Studying algorithms admitting nontrivial symmetries is a prospective way of constructing new short algorithms of matrix multiplication. The main result of the article is that if there exists an algorithm of multiplicative length $l\leq22$ for multuplication of $3\times3$ matrices then its automorphism group is isomorphic to a subgroup of $S_l\times S_3$., Comment: 11 pp. To be submitted to European J. Math

It is proved that there is no an algorithm for multiplication of $3\times3$ matrices of multiplicative length $\leq23$ that is invariant under a certain group isomorphic to $S_4\times S_3$. The proof makes use of description of the orbits of this group on decomposable tensors in the tensor cube $(M_3({\mathbb C}))^{\otimes3}$ which was obtained earlier., Comment: 13 pp. Accepted for publication in Proceedings of the Institute of Mathematics of Academy of Sciences of Belarus

Recent progress on robust clustering led to constant-factor approximations for Robust Matroid Center. After a first combinatorial $7$-approximation that is based on a matroid intersection approach, two tight LP-based $3$-approximations were discovered, both relying on the Ellipsoid Method. In this paper, we show how a carefully designed, yet very simple, greedy selection algorithm gives a $5$-approximation. An important ingredient of our approach is a well-chosen use of Rado matroids. This enables us to capture with a single matroid a relaxed version of the original matroid, which, as we show, is amenable to straightforward greedy selections., Comment: To appear at SOSA 2023

One of prospective ways to find new fast algorithms of matrix multiplication is to study algorithms admitting nontrivial symmetries. In the work possible algorithms for multiplication of $3\times3$ matrices, admitting a certain group $G$ isomorphic to $S_4\times S_3$, are investigated. It is shown that there exist no such algorithms of length $\leq23$. In the first part of the work, which is the content of the present article, we describe all orbits of length $\leq23$ of $G$ on the set of decomposable tensors in the space $M\otimes M\otimes M$, where $M=M_3({\mathbb C})$ is the space of complex $3\times3$ matrices. In the second part of the work this description will be used to prove that a short algorithm with the above-mentioned group does not exist., Comment: 19 pp. Accepted for publication in Proceedings of the Institute of mathematics (of Academy of Sciences of Belarus)

As the availability of imagery data continues to swell, so do the demands on transmission, storage and processing power. Processing requirements to handle this plethora of data is quickly outpacing the utility of conventional processing techniques. Transitioning to quantum processing and algorithms that offer promising efficiencies over conventional methods can address some of these issues. However, to make this transformation possible, fundamental issues of implementing real time Quantum algorithms must be overcome for crucial processes needed for intelligent analysis applications. For example, consider edge detection tasks which require time-consuming acquisition processes and are further hindered by the complexity of the devices used thus limiting feasibility for implementation in real-time applications. Convolution is another example of an operation that is essential for signal and image processing applications, where the mathematical operations consist of an intelligent mixture of multiplication and addition that require considerable computational resources. This paper studies a new paired transform-based quantum representation and computation of one-dimensional and 2-D signals convolutions and gradients. A new visual data representation is defined to simplify convolution calculations making it feasible to parallelize convolution and gradient operations for more efficient performance. The new data representation is demonstrated on multiple illustrative examples for quantum edge detection, gradients, and convolution. Furthermore, the efficiency of the proposed approach is shown on real-world images., Comment: 11 pages, 11 figures

By an {\em isotropy group} of a tensor $t\in V_1 \otimes V_2\otimes V_3=\widetilde V$ we mean the group of all invertible linear transformations of $\widetilde V$ that leave $t$ invariant and are compatible (in an obvious sense) with the structure of tensor product on~$\widetilde V$. We consider the case where $t$ is the structure tensor of multiplication map of rectangular matrices. The isotropy group of this tensor was studied in 1970s by de Groote, Strassen, and Brockett-Dobkin. In the present work we enlarge, make more precise, expose in the language of group actions on tensor spaces, and endow with proofs the results previously known. This is necessary for studying the algorithms of fast matrix multiplication admitting symmetries. The latter seems to be a promising new way for constructing fast algorithms., Comment: 14 pages. arXiv admin note: text overlap with arXiv:1508.01110

The top tree data structure is an important and fundamental tool in dynamic graph algorithms. Top trees have existed for decades, and today serve as an ingredient in many state-of-the-art algorithms for dynamic graphs. In this work, we give a new direct proof of the existence of top trees, facilitating simpler and more direct implementations of top trees, based on ideas from splay trees. This result hinges on new insights into the structure of top trees, and in particular the structure of each root path in a top tree., Comment: 27 pages, 6 figures, published at SOSA'23, license information updated

Distributed ledger networks, chiefly those based on blockchain technologies, currently are heralding a next generation of computer systems that aims to suit modern users' demands. Over the recent years, several technologies for blockchains, off-chaining strategies, as well as decentralised and respectively self-sovereign identity systems have shot up so fast that standardisation of the protocols is lagging behind, severely hampering the interoperability of different approaches. Moreover, most of the currently available solutions for distributed ledgers focus on either home users or enterprise use case scenarios, failing to provide integrative solutions addressing the needs of both. Herein we introduce the OpenDSU platform that allows to interoperate generic blockchain technologies, organised - and possibly cascaded in a hierarchical fashion - in domains. To achieve this flexibility, we seamlessly integrated a set of well conceived OpenDSU components to orchestrate off-chain data with granularly resolved and cryptographically secure access levels that are nested with sovereign identities across the different domains. Employing our platform to PharmaLedger, an inter-European network for the standardisation of data handling in the pharmaceutical industry and in healthcare, we demonstrate that OpenDSU can cope with generic demands of heterogeneous use cases in both, performance and handling substantially different business policies. Importantly, whereas available solutions commonly require a pre-defined and fixed set of components, no such vendor lock-in restrictions on the blockchain technology or identity system exist in OpenDSU, making systems built on it flexibly adaptable to new standards evolving in the future., Comment: 18 pages, 8 figures

Given a set $P$ of points in the plane, a point burning process is a discrete time process to burn all the points of $P$ where fires must be initiated at the given points. Specifically, the point burning process starts with a single burnt point from $P$, and at each subsequent step, burns all the points in the plane that are within one unit distance from the currently burnt points, as well as one other unburnt point of $P$ (if exists). The point burning number of $P$ is the smallest number of steps required to burn all the points of $P$. If we allow the fire to be initiated anywhere, then the burning process is called an anywhere burning process, and the corresponding burning number is called anywhere burning number. Computing the point and anywhere burning number is known to be NP-hard. In this paper we show that both these problems admit PTAS in one dimension. We then show that in two dimensions, point burning and anywhere burning are $(1.96296+\varepsilon)$ and $(1.92188+\varepsilon)$ approximable, respectively, for every $\varepsilon>0$, which improves the previously known $(2+\varepsilon)$ factor for these problems. We also observe that a known result on set cover problem can be leveraged to obtain a 2-approximation for burning the maximum number of points in a given number of steps. We show how the results generalize if we allow the points to have different fire spreading rates. Finally, we prove that even if the burning sources are given as input, finding a point burning sequence itself is NP-hard.

The "Curse of Dimensionality" induced by the rapid development of information science, might have a negative impact when dealing with big datasets. In this paper, we propose a variant of the sparrow search algorithm (SSA), called Tent L\'evy flying sparrow search algorithm (TFSSA), and use it to select the best subset of features in the packing pattern for classification purposes. SSA is a recently proposed algorithm that has not been systematically applied to feature selection problems. After verification by the CEC2020 benchmark function, TFSSA is used to select the best feature combination to maximize classification accuracy and minimize the number of selected features. The proposed TFSSA is compared with nine algorithms in the literature. Nine evaluation metrics are used to properly evaluate and compare the performance of these algorithms on twenty-one datasets from the UCI repository. Furthermore, the approach is applied to the coronavirus disease (COVID-19) dataset, yielding the best average classification accuracy and the average number of feature selections, respectively, of 93.47% and 2.1. Experimental results confirm the advantages of the proposed algorithm in improving classification accuracy and reducing the number of selected features compared to other wrapper-based algorithms.

One of the first application of the recently introduced technique of \emph{flow-augmentation} [Kim et al., STOC 2022] is a fixed-parameter algorithm for the weighted version of \textsc{Directed Feedback Vertex Set}, a landmark problem in parameterized complexity. In this note we explore applicability of flow-augmentation to other weighted graph separation problems parameterized by the size of the cutset. We show the following. -- In weighted undirected graphs \textsc{Multicut} is FPT, both in the edge- and vertex-deletion version. -- The weighted version of \textsc{Group Feedback Vertex Set} is FPT, even with an oracle access to group operations. -- The weighted version of \textsc{Directed Subset Feedback Vertex Set} is FPT. Our study reveals \textsc{Directed Symmetric Multicut} as the next important graph separation problem whose parameterized complexity remains unknown, even in the unweighted setting., Comment: 17 pages, 1 figure

We investigate efficient ways for the incorporation of liquid democracy into election settings in which voters submit cumulative ballots, i.e., when each voter is assigned a virtual coin that she can then distribute as she wishes among the available election options. In particular, we are interested in fine-grained liquid democracy, meaning that voters are able to designate a partial coin to a set of election options and delegate the decision on how to further split this partial coin among those election options to another voter of her choice. The fact that we wish such delegations to be transitive -- combined with our aim at fully respecting such delegations -- means that inconsistencies and cycles can occur, thus we set to find computationally-efficient ways of resolving voter delegations. To this aim we develop a theory based fixed-point theorems and mathematical programming techniques and we show that for various variants of definitions regarding how to resolve such transitive delegations, there is always a feasible resolution; and we identify under which conditions such solutions are efficiently computable., Comment: 15 pages, 1 table

This paper studies parallel algorithms for the longest increasing subsequence (LIS) problem. Let $n$ be the input size and $k$ be the LIS length of the input. Sequentially, LIS is a simple problem that can be solved using dynamic programming (DP) in $O(n\log n)$ work. However, parallelizing LIS is a long-standing challenge. We are unaware of any parallel LIS algorithm that has optimal $O(n\log n)$ work and non-trivial parallelism (i.e., $\tilde{O}(k)$ or $o(n)$ span). This paper proposes a parallel LIS algorithm that costs $O(n\log k)$ work, $\tilde{O}(k)$ span, and $O(n)$ space, and is much simpler than the previous parallel LIS algorithms. We also generalize the algorithm to a weighted version of LIS, which maximizes the weighted sum for all objects in an increasing subsequence. To achieve a better work bound for the weighted LIS algorithm, we designed parallel algorithms for the van Emde Boas (vEB) tree, which has the same structure as the sequential vEB tree, and supports work-efficient parallel batch insertion, deletion, and range queries. We also implemented our parallel LIS algorithms. Our implementation is light-weighted, efficient, and scalable. On input size $10^9$, our LIS algorithm outperforms a highly-optimized sequential algorithm (with $O(n\log k)$ cost) on inputs with $k\le 3\times 10^5$. Our algorithm is also much faster than the best existing parallel implementation by Shen et al. (2022) on all input instances., Comment: to be published in Proceedings of the 35th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA '23)

Given a set $P$ of points and a set $U$ of axis-parallel unit squares in the Euclidean plane, a minimum ply cover of $P$ with $U$ is a subset of $U$ that covers $P$ and minimizes the number of squares that share a common intersection, called the minimum ply cover number of $P$ with $U$. Biedl et al. [Comput. Geom., 94:101712, 2020] showed that determining the minimum ply cover number for a set of points by a set of axis-parallel unit squares is NP-hard, and gave a polynomial-time 2-approximation algorithm for instances in which the minimum ply cover number is constant. The question of whether there exists a polynomial-time approximation algorithm remained open when the minimum ply cover number is $\omega(1)$. We settle this open question and present a polynomial-time $(8+\varepsilon)$-approximation algorithm for the general problem, for every fixed $\varepsilon>0$.

In the Directed Steiner Network problem, the input is a directed graph G, a subset T of k vertices of G called the terminals, and a demand graph D on T. The task is to find a subgraph H of G with the minimum number of edges such that for every edge (s,t) in D, the solution H contains a directed s to t path. In this paper we investigate how the complexity of the problem depends on the demand pattern when G is planar. Formally, if \mathcal{D} is a class of directed graphs closed under identification of vertices, then the \mathcal{D}-Steiner Network (\mathcal{D}-SN) problem is the special case where the demand graph D is restricted to be from \mathcal{D}. For general graphs, Feldmann and Marx [ICALP 2016] characterized those families of demand graphs where the problem is fixed-parameter tractable (FPT) parameterized by the number k of terminals. They showed that if \mathcal{D} is a superset of one of the five hard families, then \mathcal{D}-SN is W[1]-hard parameterized by k, otherwise it can be solved in time f(k)n^{O(1)}. For planar graphs an interesting question is whether the W[1]-hard cases can be solved by subexponential parameterized algorithms. Chitnis et al. [SICOMP 2020] showed that, assuming the ETH, there is no f(k)n^{o(k)} time algorithm for the general \mathcal{D}-SN problem on planar graphs, but the special case called Strongly Connected Steiner Subgraph can be solved in time f(k) n^{O(\sqrt{k})} on planar graphs. We present a far-reaching generalization and unification of these two results: we give a complete characterization of the behavior of every $\mathcal{D}$-SN problem on planar graphs. We show that assuming ETH, either the problem is (1) solvable in time 2^{O(k)}n^{O(1)}, and not in time 2^{o(k)}n^{O(1)}, or (2) solvable in time f(k)n^{O(\sqrt{k})}, but not in time f(k)n^{o(\sqrt{k})}, or (3) solvable in time f(k)n^{O(k)}, but not in time f(k)n^{o({k})}., Comment: 87 pages, 18 figures

The quality of the inverse approach in electroencephalography (EEG) source analysis is - among other things - depending on the accuracy of the forward modeling approach, i.e., the simulation of the electric potential for a known dipole source in the brain. Here, we use multilayer sphere modeling scenarios to investigate the performance of three different finite element method (FEM) based EEG forward approaches - subtraction, Venant and partial integration - in the presence of tissue conductivity anisotropy in the source space. In our studies, the effect of anisotropy on the potential is related to model errors when ignoring anisotropy and to numerical errors, convergence behavior and computational speed of the different FEM approaches. Three different source space anisotropy models that best represent adult, child and premature baby volume conduction scenarios, are used. Major findings of the study include (1) source space conductivity anisotropy has a significant effect on electric potential computation: The effect increases with increasing anisotropy ratio; (2) with numerical errors far below anisotropy effects, all three FEM approaches are able to model source space anisotropy accordingly, with the Venant approach offering the best compromise between accuracy and computational speed; (3) FE meshes have to be fine enough in the subdomain between the source and the sensors that capture its main activity. We conclude that, especially for the analysis of cortical development, but also for more general applications using EEG source analysis techniques, source space conductivity anisotropy should be modeled and the FEM Venant approach is an appropriate method., Comment: 20 pages, 4 figures, 5 tables

The leafage of a chordal graph G is the minimum integer l such that G can be realized as an intersection graph of subtrees of a tree with l leaves. We consider structural parameterization by the leafage of classical domination and cut problems on chordal graphs. Fomin, Golovach, and Raymond [ESA 2018, Algorithmica 2020] proved, among other things, that Dominating Set on chordal graphs admits an algorithm running in time $2^{O(l^2)} n^{O(1)}$. We present a conceptually much simpler algorithm that runs in time $2^{O(l)} n^{O(1)}$. We extend our approach to obtain similar results for Connected Dominating Set and Steiner Tree. We then consider the two classical cut problems MultiCut with Undeletable Terminals and Multiway Cut with Undeletable Terminals. We prove that the former is W[1]-hard when parameterized by the leafage and complement this result by presenting a simple $n^{O(l)}$-time algorithm. To our surprise, we find that Multiway Cut with Undeletable Terminals on chordal graphs can be solved, in contrast, in $n^{O(1)}$-time., Comment: 48 pages, 3 figures, 1 table

The paper is devoted to an approach to solving a problem of the efficiency of parallel computing. The theoretical basis of this approach is the concept of a $Q$-determinant. Any numerical algorithm has a $Q$-determinant. The $Q$-determinant of the algorithm has clear structure and is convenient for implementation. The $Q$-determinant consists of $Q$-terms. Their number is equal to the number of output data items. Each $Q$-term describes all possible ways to compute one of the output data items based on the input data. We also describe a software $Q$-system for studying the parallelism resource of numerical algorithms. This system enables to compute and compare the parallelism resources of numerical algorithms. The application of the $Q$-system is shown on the example of numerical algorithms with different structures of $Q$-determinants. Furthermore, we suggest a method for designing of parallel programs for numerical algorithms. This method is based on a representation of a numerical algorithm in the form of a $Q$-determinant. As a result, we can obtain the program using the parallelism resource of the algorithm completely. Such programs are called $Q$-effective. The results of this research can be applied to increase the implementation efficiency of numerical algorithms, methods, as well as algorithmic problems on parallel computing systems.

We prove that the well-studied triangulation flip walk on a convex point set mixes in time O(n^3 log^3 n), the first progress since McShine and Tetali's O(n^5 log n) bound in 1997. In the process we give lower and upper bounds of respectively Omega(1/(sqrt n log n)) and O(1/sqrt n) -- asymptotically tight up to an O(log n) factor -- for the expansion of the associahedron graph K_n. The upper bound recovers Molloy, Reed, and Steiger's Omega(n^{3/2}) bound on the mixing time of the walk. To obtain these results, we introduce a framework consisting of a set of sufficient conditions under which a given Markov chain mixes rapidly. This framework is a purely combinatorial analogue that in some circumstances gives better results than the projection-restriction technique of Jerrum, Son, Tetali, and Vigoda. In particular, in addition to the result for triangulations, we show quasipolynomial mixing for the k-angulation flip walk on a convex point set, for fixed k >= 4.

In the literature of algorithms, the specific computation model is often not explicit as it is assumed that the model of computation is the RAM (Random Access Machine) model. However, the RAM model itself is ill-founded in the literature, with disparate definitions and no unified results. The ambition of this paper is to found the RAM model from scratch by exhibiting a RAM model that enjoys interesting algorithmic properties and the robustness of its complexity classes, notably LIN, the class of linear-time computable problems, or the now well-known CONST-DELAY-lin class of enumeration problems computable with constant delay after linear-time preprocessing, The computation model that we define is a RAM whose contents and addresses of registers are $O(N)$, where $N$ is the size (number of registers) of the input, and where the time cost of each instruction is 1 (unit cost criterion). The key to the foundation of our RAM model will be to prove that even if addition is the only primitive operation, such a RAM can still compute all the basic arithmetic operations in constant time after a linear-time preprocessing. Moreover, while the RAM handles only $O(N)$ integers in each register, we will show that our RAM can handle $O(N^d)$ integers, for any fixed d, by storing them on $O(d)$ registers and we will have surprising algorithms that computes many operations acting on these "polynomial" integers -- addition, subtraction, multiplication, division, exponential, integer logarithm, integer square root (or $c$-th root, for any integer $c$), bitwise logical operations, and, more generally, any operation computable in linear time on a cellular automaton -- in constant time after a linear-time preprocessing.

This paper deals with the maximum independent set (M.I.S.) problem, also known as the stable set problem. The basic mathematical programming model that captures this problem is an Integer Program (I.P.) with zero-one variables $x_j$ and only the \textit{edge inequalities} with an objective function value of the form $~\textstyle \sum_{j=1}^N x_j~$ where $N$ is the number of vertices in the input. We consider $LP(k)$, which is the Linear programming (LP) relaxation of the I.P. with an additional constraint $\textstyle \sum_{j=1}^N x_j = k ~~ (0 \le k \le N). ~~ $ We then consider a convex programming variant $CP(k)$ of $LP(k)$, which is the same as $LP(k)$, except that the objective function is a nonlinear convex function (which we minimise). $~$The M.I.S. problem can be solved by solving $CP(k)$ for every value of $k$ in the interval $~0 \le k \le N~$ where the convex function is minimised using a \it{bin packing} type of approach. In this paper, we present efforts to developing a convex function for $CP(k)$.. However, in the latest version, in the absence of a convex function, we have introduced a new function; and for a certain instance, when we provide partial solutions (that is, for 5 vertices out of 150), the frequency of hitting an optimal complete integer solution increases significantly., Comment: Introduced an approach that connects binary search, convex programming and bin packing; introduced a new type of function

The main goal of this paper is to provide a complete answer to the Problem 22 of Narkiewicz \cite{Nar} for any sextic number field $K$ generated by a complex root $\alpha$ of a monic irreducible trinomial $F(x) = x^6+ax^5+b \in \mathbb{Z}[x]$. Namely we calculate the index of the field $K$. In particular, if $i(K)\neq 1$, then $K$ is not mongenic. Finally, we illustrate our results by some computational examples., Comment: submitted. arXiv admin note: text overlap with arXiv:2204.03226

Stick graphs are defined as follows. Let A (respectively B) be a set of vertical (respectively horizontal) segments in the plane such that the bottom endpoints of the segments in A and the left endpoints of the segments in B lie on the same ground straight line with slope -1. The Stick graph defined by A and B, which is necessarily bipartite, is the intersection graph of the segments in A with the segments in B. We answer an open problem by showing that recognizing Stick graphs is NP-complete. This result allows us to easily solve two other open problems, namely the recognition of BipHook graphs and of max point-tolerance graphs. We show that both of them are NP-complete problems., Comment: 24 pages, 12 figures

The burning process on a graph $G$ starts with a single burnt vertex, and at each subsequent step, burns the neighbors of the currently burnt vertices, as well as one other unburnt vertex. The burning number of $G$ is the smallest number of steps required to burn all the vertices of the graph. In this paper, we examine the problem of computing the burning number in a geometric setting. The input is a set of points $P$ in the Euclidean plane. The burning process starts with a single burnt point, and at each subsequent step, burns all the points that are within a distance of one unit from the currently burnt points and one other unburnt point. The burning number of $P$ is the smallest number of steps required to burn all the points of $P$. We call this variant \emph{point burning}. We consider another variant called \emph{anywhere burning}, where we are allowed to burn any point of the plane. We show that point burning and anywhere burning problems are both NP-complete, but $(2+\varepsilon)$ approximable for every $\varepsilon>0$. Moreover, if we put a restriction on the number of burning sources that can be used, then the anywhere burning problem becomes NP-hard to approximate within a factor of $\frac{2}{\sqrt{3}}-\varepsilon$.

We study the relationship between the underlying structure of posets and the spectral and combinatorial properties of their higher-order random walks. While fast mixing of random walks on hypergraphs has led to myriad breakthroughs throughout theoretical computer science in the last five years, many other important applications (e.g. locally testable codes, 2-2 games) rely on the more general non-simplicial structures. These works make it clear that the global expansion properties of posets depend strongly on their underlying architecture (e.g. simplicial, cubical, linear algebraic), but the overall phenomenon remains poorly understood. In this work, we quantify the advantage of different architectures, highlighting how structural regularity controls the spectral decay and edge-expansion of corresponding random walks. In particular, we show the spectra of walks on expanding posets (Dikstein, Dinur, Filmus, Harsha RANDOM 2018) concentrate in strips around a small number of approximate eigenvalues controlled by the poset's regularity. This gives a simple condition to identify architectures (e.g. the Grassmann) that exhibit fast (exponential) decay of eigenvalues, versus architectures like hypergraphs with slow (linear) decay -- a crucial distinction in applications to hardness of approximation and agreement testing such as the recent proof of the 2-2 Games Conjecture (Khot, Minzer, Safra FOCS 2018). We show these results lead to a tight variance-based characterization of edge-expansion on eposets generalizing (Bafna, Hopkins, Kaufman, and Lovett (SODA 2022)), and pay special attention to the case of the Grassmann where we show our results are tight for a natural set of sparsifications of the Grassmann graphs. We note for clarity that our results do not recover the characterization used in the proof of the 2-2 Games Conjecture which relies on $\ell_\infty$ rather than $\ell_2$-structure.

We construct an explicit family of 3-XOR instances hard for $\Omega(n)$-levels of the Sum-of-Squares (SoS) semi-definite programming hierarchy. Not only is this the first explicit construction to beat brute force search (beyond low-order improvements (Tulsiani 2021, Pratt 2021)), combined with standard gap amplification techniques it also matches the (optimal) hardness of random instances up to imperfect completeness (Grigoriev TCS 2001, Schoenebeck FOCS 2008). Our result is based on a new form of small-set high dimensional expansion (SS-HDX) inspired by recent breakthroughs in locally testable and quantum LDPC codes. Adapting the recent framework of Dinur, Filmus, Harsha, and Tulsiani (ITCS 2021) for SoS lower bounds from the Ramanujan complex to this setting, we show any (bounded-degree) SS-HDX can be transformed into a highly unsatisfiable 3-XOR instance that cannot be refuted by $\Omega(n)$-levels of SoS. We then show Leverrier and Z\'emor's (Arxiv 2022) recent qLDPC construction gives the desired explicit family of bounded-degree SS-HDX. Incidentally, this gives the strongest known form of bi-directional high dimensional expansion to date.

We study the Riemannian Langevin Algorithm for the problem of sampling from a distribution with density $\nu$ with respect to the natural measure on a manifold with metric $g$. We assume that the target density satisfies a log-Sobolev inequality with respect to the metric and prove that the manifold generalization of the Unadjusted Langevin Algorithm converges rapidly to $\nu$ for Hessian manifolds. This allows us to reduce the problem of sampling non-smooth (constrained) densities in ${\bf R}^n$ to sampling smooth densities over appropriate manifolds, while needing access only to the gradient of the log-density, and this, in turn, to sampling from the natural Brownian motion on the manifold. Our main analytic tools are (1) an extension of self-concordance to manifolds, and (2) a stochastic approach to bounding smoothness on manifolds. A special case of our approach is sampling isoperimetric densities restricted to polytopes by using the metric defined by the logarithmic barrier.

We consider the problem of implementing linearizable objects that support both read and read-modify-write (RMW) operations in message-passing systems with process crashes. Since in many systems read operations vastly outnumber RMW operations, we are interested in implementations that emphasize the efficiency of read operations. We present a parametrized algorithm for partially synchronous systems where processes have access to external clocks that are synchronized within $\epsilon$. With this algorithm, every read operation is local (intuitively, it does not trigger messages). If a read is not concurrent with a conflicting RMW, it is performed immediately with no waiting; furthermore, even with a concurrent conflicting RMW, a read experiences very little delay in the worst-case. For example, the algorithm's parameters can be set to ensure that every read takes $\epsilon$ time in the worst-case. To the best of our knowledge this is the first algorithm to achieve this bound in the partially synchronous systems that we assume here. Our parametrized algorithm generalizes the (non-parameterized) lease-based algorithm of Chandra et al. [6] where the worst-case time for reads is $3\delta$, where $\delta$ is the maximum message delay. The algorithm's parameters can be used to trade-off the worst-case times for read and RMW operations. They can also be used to take advantage of the fact that in many message-passing systems the delay of most messages is order of magnitudes smaller than the maximum message delay~$\delta$: for example, the parameters can be set so that, in "nice" periods where message delays are $\delta^* \ll \delta$, reads take at most $\epsilon$ time while RMWs take at most $3 \delta^*$ time.

Every graph with maximum degree $\Delta$ can be colored with $(\Delta+1)$ colors using a simple greedy algorithm. Remarkably, recent work has shown that one can find such a coloring even in the semi-streaming model. But, in reality, one almost never needs $(\Delta+1)$ colors to properly color a graph. Indeed, the celebrated \Brooks' theorem states that every (connected) graph beside cliques and odd cycles can be colored with $\Delta$ colors. Can we find a $\Delta$-coloring in the semi-streaming model as well? We settle this key question in the affirmative by designing a randomized semi-streaming algorithm that given any graph, with high probability, either correctly declares that the graph is not $\Delta$-colorable or outputs a $\Delta$-coloring of the graph. The proof of this result starts with a detour. We first (provably) identify the extent to which the previous approaches for streaming coloring fail for $\Delta$-coloring: for instance, all these approaches can handle streams with repeated edges and they can run in $o(n^2)$ time -- we prove that neither of these tasks is possible for $\Delta$-coloring. These impossibility results however pinpoint exactly what is missing from prior approaches when it comes to $\Delta$-coloring. We then build on these insights to design a semi-streaming algorithm that uses $(i)$ a novel sparse-recovery approach based on sparse-dense decompositions to (partially) recover the "problematic" subgraphs of the input -- the ones that form the basis of our impossibility results -- and $(ii)$ a new coloring approach for these subgraphs that allows for recoloring of other vertices in a controlled way without relying on local explorations or finding "augmenting paths" that are generally impossible for semi-streaming algorithms. We believe both these techniques can be of independent interest., Comment: Journal version in TheoretiCS. An extended abstract appeared in STOC 2022. 66 pages, 10 figures

In this paper, we give simple NP-hardness reductions for three popular video games. The first is Baba Is You, an award winning 2D block puzzle game with the key premise being the ability to rewrite the rules of the game. The second is Fez, a puzzle platformer whose main draw is the ability to swap between four different 2-dimensional views of the player's position. The final is Catherine, a 3-dimensional puzzle game where the player must climb a tower of rearrangeable blocks.

The concept of Generalized Inverse based Decoding (GID) is introduced, as an algebraic framework for the syndrome decoding problem (SDP) and low weight codeword problem (LWP). The framework has ground on two characterizations by generalized inverses (GIs), one for the null space of a matrix and the other for the solution space of a system of linear equations over a finite field. Generic GID solvers are proposed for SDP and LWP. It is shown that information set decoding (ISD) algorithms, such as Prange, Lee-Brickell, Leon, and Stern's algorithms, are particular cases of GID solvers. All of them search GIs or elements of the null space under various specific strategies. However, as the paper shows the ISD variants do not search through the entire space, while our solvers do even when they use just one Gaussian elimination. Apart from these, our GID framework clearly shows how each ISD algorithm, except for Prange's solution, can be used as an SDP or LWP solver. A tight reduction from our problems, viewed as optimization problems, to the MIN-SAT problem is also provided. Experimental results show a very good behavior of the GID solvers. The domain of easy weights can be reached by a very few iterations and even enlarged., Comment: 41 pages, 5 figures, 5 page abstract submitted to ISIT2022

We give a quantum algorithm for solving the Bounded Distance Decoding (BDD) problem with a subexponential approximation factor on a class of integer lattices. The quantum algorithm uses a well-known but challenging-to-use quantum state on lattices as a type of approximate quantum eigenvector to randomly self-reduce the BDD instance to a random BDD instance which is solvable classically. The running time of the quantum algorithm is polynomial for one range of approximation factors and subexponential time for a second range of approximation factors. The subclass of lattices we study has a natural description in terms of the lattice's periodicity and finite abelian group rank. This view makes for a clean quantum algorithm in terms of finite abelian groups, uses very relatively little from lattice theory, and suggests exploring approximation algorithms for lattice problems in parameters other than dimension alone. A talk on this paper sparked many lively discussions and resulted in a new classical algorithm matching part of our result. We leave it as a challenge to give a classcial algorithm matching the general case.

A major archetype of artificial intelligence is developing algorithms facilitating temporal efficiency and accuracy while boosting the generalization performance. Even with the latest developments in machine learning, a key limitation has been the inefficient feature extraction from the initial data, which is essential in performance optimization. Here, we introduce a feature extraction method inspired by sensory cortical networks in the brain. Dubbed as bioinspired cortex, the algorithm provides convergence to orthogonal features from streaming signals with superior computational efficiency while processing data in compressed form. We demonstrate the performance of the new algorithm using artificially created complex data by comparing it with the commonly used traditional clustering algorithms, such as Birch, GMM, and K-means. While the data processing time is significantly reduced, seconds versus hours, encoding distortions remain essentially the same in the new algorithm providing a basis for better generalization. Although we show herein the superior performance of the cortex model in clustering and vector quantization, it also provides potent implementation opportunities for machine learning fundamental components, such as reasoning, anomaly detection and classification in large scope applications, e.g., finance, cybersecurity, and healthcare., Comment: 17 pages, 6 Figures in Main Text, 5 Figures in Methods plus Appendix, and 54 references cited

The bamboo trimming problem considers $n$ bamboo with growth rates $h_1, h_2, \ldots, h_n$ satisfying $\sum_i h_i = 1$. During a given unit of time, each bamboo grows by $h_i$, and then the bamboo-trimming algorithm gets to trim one of the bamboo back down to height zero. The goal is to minimize the height of the tallest bamboo, also known as the backlog. The bamboo trimming problem is closely related to many scheduling problems, and can be viewed as a variation of the widely-studied fixed-rate cup game, but with constant-factor resource augmentation. Past work has given sophisticated pinwheel algorithms that achieve the optimal backlog of 2 in the bamboo trimming problem. It remained an open question, however, whether there exists a simple algorithm with the same guarantee -- recent work has devoted considerable theoretical and experimental effort to answering this question. Two algorithms, in particular, have appeared as natural candidates: the Reduce-Max algorithm (which always cuts the tallest bamboo) and the Reduce-Fastest$(x)$ algorithm (which cuts the fastest-growing bamboo out of those that have height at least $x$). Both algorithms are conjectured to achieve backlog 2. This paper improves the bounds for both Reduce-Fastest and Reduce-Max. Among other results, we show that the exact optimal backlog for Reduce-Fastest$(x)$ is $x + 1$ for all $x \ge 2$ (proving a conjecture of D'Emidio, Di Stefano, and Navarra in the case of $x = 2$), and we show that Reduce-Fastest$(1)$ does not achieve backlog 2 (disproving a conjecture of D'Emidio, Di Stefano, and Navarra). Finally, we show that there is a different algorithm, which we call the Deadline-Driven Strategy, that is both very simple and achieves the optimal backlog of 2. This resolves the question as to whether there exists a simple worst-case optimal algorithm for the bamboo trimming problem., Comment: 7 pages

In the sport of cricket, the side that wins the toss and has the first choice to bat or bowl can have an unfair or a critical advantage. The issue has been discussed by International Cricket Council committees, as well as several cricket experts. In this article, I outline a method to make the toss fair in cricket. The method is based on ideas from the academic fields of game theory and fair division.

Eternal Vertex Cover problem is a dynamic variant of the vertex cover problem. We have a two player game in which guards are placed on some vertices of a graph. In every move, one player (the attacker) attacks an edge. In response to the attack, the second player (defender) moves the guards along the edges of the graph in such a manner that at least one guard moves along the attacked edge. If such a movement is not possible, then the attacker wins. If the defender can defend the graph against an infinite sequence of attacks, then the defender wins. The minimum number of guards with which the defender has a winning strategy is called the Eternal Vertex Cover Number of the graph G. On general graphs, the computational problem of determining the minimum eternal vertex cover number is NP-hard and admits a 2-approximation algorithm and an exponential kernel. The complexity of the problem on bipartite graphs is open, as is the question of whether the problem admits a polynomial kernel. We settle both these questions by showing that Eternal Vertex Cover is NP-hard and does not admit a polynomial compression even on bipartite graphs of diameter six. We also show that the problem admits a polynomial time algorithm on the class of cobipartite graphs., Comment: 38 pages, 15 figures. Updated to remove a previously incorrect claim about the complexity of the problem on split graphs

An independent set in a graph is a set of pairwise non-adjacent vertices. Let $\alpha(G)$ denote the cardinality of a maximum independent set in the graph $G = (V, E)$. Gutman and Harary defined the independence polynomial of $G$ \[ I(G;x) = \sum_{k=0}^{\alpha(G)}{s_k}x^{k}={s_0}+{s_1}x+{s_2}x^{2}+...+{s_{\alpha(G)}}x^{\alpha(G)}, \] where $s_k$ denotes the number of independent sets of cardinality $k$ in the graph $G$. A comprehensive survey on the subject is due to Levit and Mandrescu, where some recursive formulas are allowing to calculate the independence polynomial. A direct implementation of these recursions does not bring about an efficient algorithm. Yosef, Mizrachi, and Kadrawi developed an efficient way for computing the independence polynomials of trees with $n$ vertices, such that a database containing all of the independence polynomials of all the trees with up to $n-1$ vertices is required. This approach is not suitable for big trees, as an extensive database is needed. On the other hand, using dynamic programming, it is possible to develop an efficient algorithm that prevents repeated calculations. In summary, our dynamic programming algorithm runs over a tree in linear time and does not depend on a database., Comment: 8 pages

The most common approaches for solving multistage stochastic programming problems in the research literature have been to either use value functions ("dynamic programming") or scenario trees ("stochastic programming") to approximate the impact of a decision now on the future. By contrast, common industry practice is to use a deterministic approximation of the future which is easier to understand and solve, but which is criticized for ignoring uncertainty. We show that a parameterized version of a deterministic optimization model can be an effective way of handling uncertainty without the complexity of either stochastic programming or dynamic programming. We present the idea of a parameterized deterministic optimization model, and in particular a deterministic lookahead model, as a powerful strategy for many complex stochastic decision problems. This approach can handle complex, high-dimensional state variables, and avoids the usual approximations associated with scenario trees or value function approximations. Instead, it introduces the offline challenge of designing and tuning the parameterization. We illustrate the idea by using a series of application settings, and demonstrate its use in a nonstationary energy storage problem with rolling forecasts., Comment: 3 figures

The effects of density and viscosity fluctuations on the total stress balance are identified and used to create a new mean velocity transformation for compressible boundary layers. This work is enabled by an extensive database of direct numerical simulations that incorporate wall-cooling, semi-local Reynolds numbers ranging from 800 to 34000, and Mach numbers up to 12. The role, significance and physical mechanisms connecting density and viscosity fluctuations to the momentum balance and to the viscous, turbulent and total stresses are presented,allowing the creation of generalized formulations. We identify the significant properties that thus-far have been neglected in the derivation of velocity transformations: (1) the Machinvariance of the near-wall momentum balance for the generalized total stress, and (2) the Mach-invariance of the relative contributions from the generalized viscous and Reynolds stresses to the total stress. The proposed velocity transformation integrates both properties into a single transformation equation and successfully demonstrates a collapsing of all currently considered compressible cases onto the incompressible law of the wall, within the bounds of reported slope and intercept for incompressible data. Based on the physics embedded in the two scaling properties, the success of the newly proposed transformation is attributed to considering the effects of the viscous stress and turbulent stresses as well as mean and fluctuating density viscosity in a single transformation form., Comment: 23 pages, 12 figures, Under consideration for Physical Review Fluids

Equation of state with quantum statistics corrections is derived for systems of the Fermi and Bose particles by using their van der Waals (vdW) and effective density-dependent Skyrme mean-field interactions. First few orders of these corrections over the small quantum statistics parameter, $\varepsilon \approx \hbar^3 n(mT)^{-3/2}g^{-1}$, where $n$ and $T$ are the particle number density and temperature, $m$ and $g$ the mass and degeneracy factor of particles, are analytically obtained. For interacting system of nucleon and $\alpha$ - particles, a small impurity of $\alpha$ - particles to a nucleon system at leading first order in both $\alpha $-particle and nucleon small parameters $\varepsilon$ does not change much the basic results for the symmetric nuclear matter in the quantum vdW consideration. Our approximate analytical results for the quantum vdW and Skyrme mean-field approaches are in a good agreement with accurate numerical calculations., Comment: 10 pages, 3 figures. arXiv admin note: substantial text overlap with arXiv:2012.09695