Polynomial Running Time Research Articles

Supervisory control under delayed observations of events and states

In discrete event systems, it is often convenient and possible to observe directly whether or not the system is in a subset of the state space, typically after some delay, even if some event occurrences leading to the current state were not observed. We model supervisory control with the delayed observations of events and states and investigate the existence of a supervisor to obtain a given desired language accordingly. An existence verifier with polynomial run time is presented.

Constructing and sampling partite, 3-uniform hypergraphs with given degree sequence.

Partite, 3-uniform hypergraphs are 3-uniform hypergraphs in which each hyperedge contains exactly one point from each of the 3 disjoint vertex classes. We consider the degree sequence problem of partite, 3-uniform hypergraphs, that is, to decide if such a hypergraph with prescribed degree sequences exists. We prove that this decision problem is NP-complete in general, and give a polynomial running time algorithm for third almost-regular degree sequences, that is, when each degree in one of the vertex classes is k or k - 1 for some fixed k, and there is no restriction for the other two vertex classes. We also consider the sampling problem, that is, to uniformly sample partite, 3-uniform hypergraphs with prescribed degree sequences. We propose a Parallel Tempering method, where the hypothetical energy of the hypergraphs measures the deviation from the prescribed degree sequence. The method has been implemented and tested on synthetic and real data. It can also be applied for χ2 testing of contingency tables. We have shown that this hypergraph-based χ2 test is more sensitive than the standard χ2 test. The extra sensitivity is especially advantageous on small data sets, where the proposed Parallel Tempering method shows promising performance.

Time-optimal multi-qubit gates: Complexity, efficient heuristic and gate-time bounds

Multi-qubit entangling interactions arise naturally in several quantum computing platforms and promise advantages over traditional two-qubit gates. In particular, a fixed multi-qubit Ising-type interaction together with single-qubit X-gates can be used to synthesize global ZZ-gates (GZZ gates). In this work, we first show that the synthesis of such quantum gates that are time-optimal is NP-hard. Second, we provide explicit constructions of special time-optimal multi-qubit gates. They have constant gate times and can be implemented with linearly many X-gate layers. Third, we develop a heuristic algorithm with polynomial runtime for synthesizing fast multi-qubit gates. Fourth, we derive lower and upper bounds on the optimal GZZ gate-time. Based on explicit constructions of GZZ gates and numerical studies, we conjecture that any GZZ gate can be executed in a time O(n) for n qubits. Our heuristic synthesis algorithm leads to GZZ gate-times with a similar scaling, which is optimal in this sense. We expect that our efficient synthesis of fast multi-qubit gates allows for faster and, hence, also more error-robust execution of quantum algorithms.

Tiling with Squares and Packing Dominos in Polynomial Time

A polyomino is a polygonal region with axis-parallel edges and corners of integral coordinates, which may have holes. In this paper, we consider planar tiling and packing problems with polyomino pieces and a polyomino container P . We give polynomial-time algorithms for deciding if P can be tiled with k × k squares for any fixed k which can be part of the input (that is, deciding if P is the union of a set of non-overlapping k × k squares) and for packing P with a maximum number of non-overlapping and axis-parallel 2 × 1 dominos, allowing rotations by 90°. As packing is more general than tiling, the latter algorithm can also be used to decide if P can be tiled by 2 × 1 dominos. These are classical problems with important applications in VLSI design, and the related problem of finding a maximum packing of 2 × 2 squares is known to be NP-hard [ 6 ]. For our three problems there are known pseudo-polynomial-time algorithms, that is, algorithms with running times polynomial in the area or perimeter of P . However, the standard, compact way to represent a polygon is by listing the coordinates of the corners in binary. We use this representation, and thus present the first polynomial-time algorithms for the problems. Concretely, we give a simple O(n log n )-time algorithm for tiling with squares, where n is the number of corners of P . We then give a more involved algorithm that reduces the problems of packing and tiling with dominos to finding a maximum and perfect matching in a graph with O ( n 3 ) vertices. This leads to algorithms with running times \(O(n^3 \frac{\log ^3 n}{\log ^2\log n})\) and \(O(n^3 \frac{\log ^2 n}{\log \log n})\) , respectively.

Quantum state preparation using tensor networks

Quantum state preparation is a vital routine in many quantum algorithms, including solution of linear systems of equations, Monte Carlo simulations, quantum sampling, and machine learning. However, to date, there is no established framework of encoding classical data into gate-based quantum devices. In this work, we propose a method for the encoding of vectors obtained by sampling analytical functions into quantum circuits that features polynomial runtime with respect to the number of qubits and provides accuracy, which is better than a state-of-the-art two-qubit gate fidelity. We employ hardware-efficient variational quantum circuits, which are simulated using tensor networks, and matrix product state representation of vectors. In order to tune variational gates, we utilize Riemannian optimization incorporating auto-gradient calculation. Besides, we propose a ‘cut once, measure twice’ method, which allows us to avoid barren plateaus during gates’ update, benchmarking it up to 100-qubit circuits. Remarkably, any vectors that feature low-rank structure—not limited by analytical functions—can be encoded using the presented approach. Our method can be easily implemented on modern quantum hardware, and facilitates the use of the hybrid-quantum computing architectures.

Polynomial-Time Constrained Message Passing for Exact MAP Inference on Discrete Models with Global Dependencies

Considering the worst-case scenario, the junction-tree algorithm remains the most general solution for exact MAP inference with polynomial run-time guarantees. Unfortunately, its main tractability assumption requires the treewidth of a corresponding MRF to be bounded, strongly limiting the range of admissible applications. In fact, many practical problems in the area of structured prediction require modeling global dependencies by either directly introducing global factors or enforcing global constraints on the prediction variables. However, this always results in a fully-connected graph, making exact inferences by means of this algorithm intractable. Previous works focusing on the problem of loss-augmented inference have demonstrated how efficient inference can be performed on models with specific global factors representing non-decomposable loss functions within the training regime of SSVMs. Making the observation that the same fundamental idea can be applied to solve a broader class of computational problems, in this paper, we adjust the framework for an efficient exact inference to allow much finer interactions between the energy of the core model and the sufficient statistics of the global terms. As a result, we greatly increase the range of admissible applications and strongly improve upon the theoretical guarantees of computational efficiency. We illustrate the applicability of our method in several use cases, including one that is not covered by the previous problem formulation. Furthermore, we propose a new graph transformation technique via node cloning, which ensures a polynomial run-time for solving our target problem. In particular, the overall computational complexity of our constrained message-passing algorithm depends only on form-independent quantities such as the treewidth of a corresponding graph (without global connections) and image size of the sufficient statistics of the global terms.

An Approximation Algorithm for k-Depot Split Delivery Vehicle Routing Problem

A multidepot capacitated vehicle routing problem aims to serve customers’ demands using a fleet of capacitated vehicles located in multiple depots, such that the total travel cost of the vehicles is minimized. We study a variant of this problem, the k-depot split delivery vehicle routing problem (or k-DSDVRP in short), for the situation where each customer’s demand can be served by more than one vehicle, and the total number of depots, denoted by [Formula: see text], is a fixed constant. This is a challenging problem with broad applications in the logistics industry, for which no constant ratio approximation algorithm is known. We develop a new approximation algorithm for the k-DSDVRP, ensuring an approximation ratio of [Formula: see text] and a polynomial running time for any fixed constant [Formula: see text]. To achieve this, we propose a novel solution framework based on a new relaxation of the problem, a cycle splitting procedure, and a vehicle assignment procedure. To further enhance its efficiency for practical usage, we adapt the newly developed approximation algorithm to a heuristic, which runs in polynomial time even when k is arbitrarily large. Experimental results show that this heuristic outperforms a commercial optimization solver and a standard vehicle routing heuristic. Moreover, our newly proposed solution framework can be applied to developing new constant ratio approximation algorithms for several other variants of the k-DSDVRP with [Formula: see text] being a fixed constant. History: Accepted by Erwin Pesch, Area Editor for Heuristic Search & Approximation Algorithms. Funding: This work was supported in part by the National Natural Science Foundation of China [Grants 71971177, 71725001, U1811462], Research Grants Council of Hong Kong SAR, China [Grant 15221619], and Guangdong Basic and Applied Basic Research Foundation [Grant 2023A1515030260]. Supplemental Material: The e-companion is available at https://doi.org/10.1287/ijoc.2021.0193 . The software that supports the findings of this study is available within the paper and its Supplemental Information ( https://pubsonline.informs.org/doi/suppl/10.1287/ijoc.2021.0193 ) as well as from the IJOC GitHub software repository ( https://github.com/INFORMSJoC/2021.0193 ). The complete IJOC Software and Data Repository is available at https://informsjoc.github.io/ .

Provably Efficient Reinforcement Learning with Linear Function Approximation

Modern reinforcement learning (RL) is commonly applied to practical problems with an enormous number of states, where function approximation must be deployed to approximate either the value function or the policy. The introduction of function approximation raises a fundamental set of challenges involving computational and statistical efficiency, especially given the need to manage the exploration/exploitation trade-off. As a result, a core RL question remains open: how can we design provably efficient RL algorithms that incorporate function approximation? This question persists even in a basic setting with linear dynamics and linear rewards, for which only linear function approximation is needed. This paper presents the first provable RL algorithm with both polynomial run time and polynomial sample complexity in this linear setting, without requiring a “simulator” or additional assumptions. Concretely, we prove that an optimistic modification of least-squares value iteration—a classical algorithm frequently studied in the linear setting—achieves [Formula: see text] regret, where d is the ambient dimension of feature space, H is the length of each episode, and T is the total number of steps. Importantly, such regret is independent of the number of states and actions. Funding: This work was supported by the Defense Advanced Research Projects Agency program on Lifelong Learning Machines.

Bottleneck Convex Subsets: Finding k Large Convex Sets in a Point Set

Chvátal and Klincsek (1980) gave an [Formula: see text]-time algorithm for the problem of finding a maximum-cardinality convex subset of an arbitrary given set [Formula: see text] of [Formula: see text] points in the plane. This paper examines a generalization of the problem, the Bottleneck Convex Subsets problem: given a set [Formula: see text] of [Formula: see text] points in the plane and a positive integer [Formula: see text], select [Formula: see text] pairwise disjoint convex subsets of [Formula: see text] such that the cardinality of the smallest subset is maximized. Equivalently, a solution maximizes the cardinality of [Formula: see text] mutually disjoint convex subsets of [Formula: see text] of equal cardinality. We give an algorithm that solves the problem exactly, with running time polynomial in [Formula: see text] when [Formula: see text] is fixed. We then show the problem to be NP-hard when [Formula: see text] is an arbitrary input parameter, even for points in general position. Finally, we give a fixed-parameter tractable algorithm parameterized in terms of the number of points strictly interior to the convex hull.

Probabilistic intuition holds for a class of small subgraph games

Consider the following two-player game on the edges of K n K_n , the complete graph with n n vertices: Starting with an empty graph G G on the vertex set of K n K_n , in each round the first player chooses b ∈ N b \in \mathbb {N} edges from K n K_n which have not previously been chosen, and the second player immediately and irrevocably picks one of these edges and adds it to G G . We show that for any graph H H with at least one edge, if b > c n 1 / m ( H ) b > c n^{1/m(H)} , where c = c ( H ) > 0 c = c(H) > 0 only depends on H H and m ( H ) m(H) is the usual density function, then the first player can ensure the resulting graph G G contains Ω ( n v ( H ) / b e ( H ) ) \Omega (n^{v(H)} / b^{e(H)}) copies of H H . The bound on b b is the best possible apart from the constant c c and shows that the density of the resulting graph for which it is possible to enforce the appearance of H H coincides with a threshold for the appearance in the Erdős-Rényi random graph. This resolves a conjecture by Bednarska-Bzdȩga, Hefetz, and Łuczak [J. Combin. Theory Ser. B 119 (2016), pp. 122–154] and provides a prominent class of games for which probabilistic intuition accurately predicts the outcome. The strategy of the first player is deterministic with polynomial running time, with the degree depending on the size of H H .

Tight FPT approximation for constrained k-center and k-supplier

In this work, we study a range of constrained versions of the k-supplier and k-center problems. In the classical (unconstrained) k-supplier problem, we are given a set of clients C in a metric space X, with distance function d(.,.). We are also given a set of feasible facility locations L⊆X. The goal is to open a set F of k facilities in L to minimize the maximum distance of any client to the closest open facility, i.e., minimize, cost(F,C)≡maxj∈C⁡{d(F,j)}, where d(F,j) is the distance of client j to the closest facility in F. The k-center problem is a special case of the k-supplier problem where L=C. We study various constrained versions of the k-supplier problem such as: capacitated, fault-tolerant, ℓ-diversity, etc. These problems fall under a broad framework of constrained clustering. A unified framework for constrained clustering was proposed by Ding and Xu [Algorithmica 2020] in the context of the k-median and k-means objectives. We extend this framework to the k-supplier and k-center objectives in this work. This unified framework allows us to obtain results simultaneously for the following constrained versions of the k-supplier problem: r-gather, r-capacity, balanced, chromatic, fault-tolerant, strongly private, ℓ-diversity, and fair k-supplier problems, with and without outliers. We design Fixed-Parameter Tractable (FPT) algorithms for these problems. FPT algorithms have polynomial running time if the parameter under consideration is a constant. This may be relevant even to a practitioner since the parameter k is a small number in many real clustering scenarios. We obtain the following results:•We give 3 and 2 approximation algorithms for the constrained k-supplier and k-center problems, respectively, with FPT running time kO(k)⋅nO(1), where n=|C∪L|. Moreover, these approximation guarantees are tight; that is, for any constant ε>0, no algorithm can achieve (3−ε) and (2−ε) approximation guarantees for the constrained k-supplier and k-center problems in FPT time, assuming FPT≠W[2].•We study the constrained clustering problem with outliers. Our algorithm gives 3 and 2 approximation guarantees for the constrained outlier k-supplier and k-center problems, respectively, with FPT running time (k+m)O(k)⋅nO(1), where n=|C∪L| and m is the number of outliers.•Our techniques generalise for distance function d(.,.)z. That is, for any positive real number z, if the cost of a client is defined by d(.,.)z instead of d(.,.), then our algorithm gives 3z and 2z approximation guarantees for the constrained k-supplier and k-center problems, respectively.

Some Basic Techniques Allowing Petri Net Synthesis: Complexity and Algorithmic Issues

In Petri net synthesis we ask whether a given transition system A can be implemented by a Petri net N. Depending on the level of accuracy, there are three ways how N can implement A: an embedding, the least accurate implementation, preserves only the diversity of states of A; a language simulation already preserves exactly the language of A; a realization, the most accurate implementation, realizes the behavior of A exactly. However, whatever the sought implementation, a corresponding net does not always exist. In this case, it was suggested to modify the input behavior – of course as little as possible. Since transition systems consist of states, events and edges, these components appear as a natural choice for modifications. In this paper we show that the task of converting an unimplementable transition system into an implementable one by removing as few states or events or edges as possible is NP-complete –regardless of what type of implementation we are aiming for; we also show that the corresponding parameterized problems are W[2]-hard, where the number of removed components is considered as the parameter; finally, we show there is no c-approximation algorithm (with a polynomial running time) for neither of these problems, for every constant c ≥ 1.

A Bifactor Approximation Algorithm for Cloudlet Placement in Edge Computing

Emerging applications with low-latency requirements such as real-time analytics, immersive media applications, and intelligent virtual assistants have rendered Edge Computing as a critical computing infrastructure. Existing studies have explored the cloudlet placement problem in a homogeneous scenario with different goals such as latency minimization, load balancing, energy efficiency, and placement cost minimization. However, placing cloudlets in a highly heterogeneous deployment scenario considering the next-generation 5G networks and IoT applications is still an open challenge. The novel requirements of these applications indicate that there is still a gap in ensuring low-latency service guarantees when deploying cloudlets. Furthermore, deploying cloudlets in a cost-effective manner and ensuring full coverage for all users in edge computing are other critical conflicting issues. In this article, we address these issues by designing a bifactor approximation algorithm to solve the heterogeneous cloudlet placement problem to guarantee a bounded latency and placement cost, while fully mapping user applications to appropriate cloudlets. We first formulate the problem as a multi-objective integer programming model and show that it is a computationally NP-hard problem. We then propose a bifactor approximation algorithm, ACP, to tackle its intractability. We investigate the effectiveness of ACP by performing extensive theoretical analysis and experiments on multiple deployment scenarios based on New York City OpenData. We prove that ACP provides a (2,4)-approximation ratio for the latency and the placement cost. The experimental results show that ACP obtains near-optimal results in a polynomial running time making it suitable for both short-term and long-term cloudlet placement in heterogeneous deployment scenarios.

Result diversification by multi-objective evolutionary algorithms with theoretical guarantees

Given a ground set of items, the result diversification problem aims to select a subset with high “quality” and “diversity” while satisfying some constraints. It arises in various real-world artificial intelligence applications, such as web-based search, document summarization and feature selection, and also has applications in other areas, e.g., computational geometry, databases, finance and operations research. Previous algorithms are mainly based on greedy or local search. In this paper, we propose to reformulate the result diversification problem as a bi-objective maximization problem, and solve it by a multi-objective evolutionary algorithm (EA), i.e., the GSEMO. We theoretically prove that the GSEMO can achieve the (asymptotically) optimal theoretical guarantees under both static and dynamic environments. For cardinality constraints, the GSEMO can achieve the optimal polynomial-time approximation ratio, 1/2. For more general matroid constraints, the GSEMO can achieve an asymptotically optimal polynomial-time approximation ratio, 1/2−ϵ/(4n), where ϵ>0 and n is the size of the ground set of items. Furthermore, when the objective function (i.e., a linear combination of quality and diversity) changes dynamically, the GSEMO can maintain this approximation ratio in polynomial running time, addressing the open question proposed by Borodin et al. [7]. This also theoretically shows the superiority of EAs over local search for solving dynamic optimization problems for the first time, and discloses the robustness of the mutation operator of EAs against dynamic changes. Experiments on the applications of web-based search, multi-label feature selection and document summarization show the superior performance of the GSEMO over the state-of-the-art algorithms (i.e., the greedy algorithm and local search) under both static and dynamic environments.

Automated Piping in an Airbus A320 Landing Gear Bay Using Graph-Based Design Languages

System design in an aircraft is still a costly, manual and iterative approach. One major cost driver of changes in system installation are design efforts for creating new pipes in an earlier stage and the costs accumulated during the in service life. To reduce these costs and the time to market, an automation approach with an integrated design optimization encoded in graph-based design languages and executable in a design compiler is proposed. To generate the pipe work automatically, a set of input data (e.g., start- and end-points of a pipe with tangents and fixing positions) is given by the user. It also contains, among others, the weightings for the optimization criteria (e.g., length of the pipe resp. the weight vs. the number of bends) to influence the evaluation of the generated pipes and thereby the final solution. As an initial step in the automatic pipe generation process, a route through the installation space is searched. Subsequently, the installation space is simplified and a respective minimal distance to each obstacle which a pipe should satisfy is added. Then for each pipe an initial solution is estimated and each pipe is optimized by a simulated annealing algorithm. At last, all given requirements are automatically verified. A carried out investigation indicates a polynomial runtime behaviour of the algorithm. The capabilities of the newly developed automated piping are demonstrated on the pipe work in an Airbus A320 landing gear bay.

Application of Recursive Algorithm on Shamir's Scheme Reconstruction for Cheating Detection and Identification

Information data protection is necessary to ward off and overcome various fraud attacks that may be encountered. A secret sharing scheme that implements cryptographic methods intends to maintain the security of confidential data by a group of trusted parties is the answer. In this paper, we choose the application of recursive algorithm on Shamir-based linear scheme as the primary method. In the secret reconstruction stage and since the beginning of the share distribution stage, these algorithms have been integrated by relying on a detection parameter to ensure that the secret value sought is valid. Although the obtained scheme will be much simpler because it utilizes the Vandermonde matrix structure, the security aspect of this scheme is not reduced. Indeed, it is supported by two detection parameters formulated from a recursive algorithm to detect cheating and identify the cheater(s). Therefore, this scheme is guaranteed to be unconditionally secure and has a high time efficiency (polynomial running time).

SimAnMo—A parallelized runtime model generator

In this article, we present the novel features of the recent version of SimAnMo, the Simulated Annealing Modeler. The tool creates models that correlate the size of one input parameter of an application to the corresponding runtime and thus SimAnMo allows predictions for larger input sizes. A focus lies on applications whose runtime grows exponentially in the input parameter size. Such programs are, for example, of high interest for cryptanalysis to analyze practical security of traditional and post-quantum secure schemes. However, SimAnMo also generates reliable models for the widespread case of polynomial runtime behavior and also for the important case of factorial runtime increase. SimAnMo's model generation is based on a parallelized simulated annealing procedure and heuristically minimizes the costs of a model. Those may rely on different quality metrics. Insights into SimAnMo's software design and its usage are provided. We demonstrate the quality of SimAnMo's models for different algorithms from various application fields. We show that our approach also works well on ARM architectures.

Fast Sampling and Counting k -SAT Solutions in the Local Lemma Regime

We give new algorithms based on Markov chains to sample and approximately count satisfying assignments to k -uniform CNF formulas where each variable appears at most d times. For any k and d satisfying kd < n o(1) and k ≥ 20 log k + 20 log d + 60, the new sampling algorithm runs in close to linear time, and the counting algorithm runs in close to quadratic time. Our approach is inspired by Moitra (JACM, 2019), which remarkably utilizes the Lovász local lemma in approximate counting. Our main technical contribution is to use the local lemma to bypass the connectivity barrier in traditional Markov chain approaches, which makes the well-developed MCMC method applicable on disconnected state spaces such as SAT solutions. The benefit of our approach is to avoid the enumeration of local structures and obtain fixed polynomial running times, even if k = ω (1) or d = ω (1).

P vs NP: P is Equal to NP: Desired Proof

Computations and computational complexity are fundamental for mathematics and all computer science, including web load time, cryptography (cryptocurrency mining), cybersecurity, artificial intelligence, game theory, multimedia processing, computational physics, biology (for instance, in protein structure prediction), chemistry, and the P vs. NP problem that has been singled out as one of the most challenging open problems in computer science and has great importance as this would essentially solve all the algorithmic problems that we have today if the problem is solved, but the existing complexity is deprecated and does not solve complex computations of tasks that appear in the new digital age as efficiently as it needs. Therefore, we need to realize a new complexity to solve these tasks more rapidly and easily. This paper presents proof of the equality of P and NP complexity classes when the NP problem is not harder to compute than to verify in polynomial time if we forget recursion that takes exponential running time and goes to regress only (every problem in NP can be solved in exponential time, and so it is recursive, this is a key concept that exists, but recursion does not solve the NP problems efficiently). The paper’s goal is to prove the existence of an algorithm solving the NP task in polynomial running time. We get the desired reduction of the exponential problem to the polynomial problem that takes O(log n) complexity.

Runtime Analyses of the Population-Based Univariate Estimation of Distribution Algorithms on LeadingOnes

We perform rigorous runtime analyses for the univariate marginal distribution algorithm (UMDA) and the population-based incremental learning (PBIL) Algorithm on LeadingOnes. For the UMDA, the currently known expected runtime on the function is {mathcal {O}}left( nlambda log lambda +n^2right) under an offspring population size lambda =Omega (log n) and a parent population size mu le lambda /(e(1+delta )) for any constant delta >0 (Dang and Lehre, GECCO 2015). There is no lower bound on the expected runtime under the same parameter settings. It also remains unknown whether the algorithm can still optimise the LeadingOnes function within a polynomial runtime when mu ge lambda /(e(1+delta )). In case of the PBIL, an expected runtime of {mathcal {O}}(n^{2+c}) holds for some constant c in (0,1) (Wu, Kolonko and Möhring, IEEE TEVC 2017). Despite being a generalisation of the UMDA, this upper bound is significantly asymptotically looser than the upper bound of {mathcal {O}}left( n^2right) of the UMDA for lambda =Omega (log n)cap {mathcal {O}}left( n/log nright). Furthermore, the required population size is very large, i.e., lambda =Omega (n^{1+c}). Our contributions are then threefold: (1) we show that the UMDA with mu =Omega (log n) and lambda le mu e^{1-varepsilon }/(1+delta ) for any constants varepsilon in (0,1) and 0<delta le e^{1-varepsilon }-1 requires an expected runtime of e^{Omega (mu )} on LeadingOnes, (2) an upper bound of {mathcal {O}}left( nlambda log lambda +n^2right) is shown for the PBIL, which improves the current bound {mathcal {O}}left( n^{2+c}right) by a significant factor of Theta (n^{c}), and (3) we for the first time consider the two algorithms on the LeadingOnes function in a noisy environment and obtain an expected runtime of {mathcal {O}}left( n^2right) for appropriate parameter settings. Our results emphasise that despite the independence assumption in the probabilistic models, the UMDA and the PBIL with fine-tuned parameter choices can still cope very well with variable interactions.