The rapid growth of Internet of Things (IoT) devices has enhanced convenience but introduced significant security risks. Due to limited visibility into device internals, black-box fuzzing has become the primary method for IoT vulnerability detection. However, it is often difficult to recognize the triggered states, which limits the ability to explore different regions of the state space and, as a result, hinders the discovery of vulnerabilities. Additionally, it lacks feedback, preventing the fuzzer from refining its test inputs based on the results and reducing its effectiveness in discovering vulnerabilities. To address these challenges, we propose SSFuzz, an automated black-box fuzzing framework leveraging large language models (LLMs) to extract state nodes from interaction messages, enabling a state-guided approach. Additionally, we design a cross-device feedback-sharing mechanism based on source code similarities, aiming to make more effective use of the limited feedback available. Evaluated against five leading tools on 18 IoT devices, SSFuzz identified 38 previously undisclosed vulnerabilities, significantly outperforming existing methods. SSFuzz discovered 38 previously unknown vulnerabilities, significantly outperforming Snipuzz (five vulnerabilities) and IoTHunter (one vulnerability).

Emotions play a vital role in connecting and sharing with others. However, individuals with emotional disorders face challenges in expressing their emotions, affecting their social lives. Current artificial intelligence tools support this problem by enabling the development of methods that recognize emotions from electroencephalographic (EEG) signals. However, the high variability across individuals poses challenges in developing emotion recognition methods that generalize well across different subjects. Previous studies have addressed this issue using domain adversarial neural networks (DANN), in which differences in EEG among individuals are minimized. Although DANN has shown a potential to reduce domain variance, previous studies have little explored the inclusion of layer-specific components to further advance towards that goal. This study addressed this limitation by incorporating bipartite (BP) graphs in a DANN architecture to reduce variability further. We evaluated our model on five benchmark datasets for emotion recognition (SEED, SEED-IV, SEED-V, SEED-FRA, and SEED-GER) comprising a total of 62 individuals. Our model yielded an accuracy of 82.1%, 77.3%, 85.8%, 90.7%, and 87.6% for the SEED-V, SEED-IV, SEED, SEED-FRA, and SEED-GER datasets, respectively. Notably, these accuracies are either higher or comparable to the current state-of-the-art models. Furthermore, our model identified that the frontal, temporal, and parietal EEG channels are crucial for detecting emotions evoked by audiovisual stimuli.

Let$G(V,\,E)$be a digraph (directed graph) with$n$nodes and$e$arcs. Digraph$G^{\ast}=(V,E^{\ast})$) is the reflexive, transitive closure if$v\rightarrow u\, \epsilon\, E^{\ast}$iff there is a path from$v$to$u$in$G$. Efficient storage of$G^{\ast}$is important for supporting reachability queries which are not only common in graph databases, but also serve as fundamental operations used in many graph algorithms. A lot of strategies have been proposed based on the graph labeling, by which each node is assigned with certain labels such that the reachability of any two nodes through a path can be determined by their labels. Among them are interval labeling, chain decomposition, 2-hop labeling, and path-trees, as well as partial index based methods. However, due to the very large size of many real world graphs, the computational cost and size of labels using existing methods would prove too expensive to be practical. In this paper, we propose a new approach to deduct and decompose a graph into a series of spanning trees and transform a query$q$to a series of subqueries each evaluated against a spanning tree. Using the so-called tree labeling, each subquery needs only O(1) time. More importantly, the number of such subqueries is$\ll_{n}$. Thus,$q$can be evaluated very efficiently. We demonstrate both analytically and empirically the efficiency and effectiveness of our method. While the query time of our method is orders of magnitude better than almost all the existing strategies, its indexing time and index sizes are comparable to them.

In this paper, we discuss an efficient and effective index mechanism for the string matching with k differences, by which we will find all the substrings of a target string y of length n that align with a pattern string x of length m with not more than k insertions, deletions, and mismatches. A typical application is the searching of a DNA database, where the size of a genome sequence in the database is much larger than that of a pattern. For example, n is often on the order of millions or billions while m is just a hundred or a thousand. The main idea of our method is to transform y to a BWT-array as an index, denoted as BWT ( y ), and search x against it. The time complexity of our method is bounded by O( k · | T |), where T is a tree structure dynamically generated during a search of BWT ( y ). The average value of | T | is bounded by O(|Σ| 2 k ), where Σ is an alphabet from which we take symbols to make up target and pattern strings. This time complexity is better than previous strategies when k ≤ O(log |Σ| n ). The general working process consists of two steps. In the first step, x is decomposed into a series of l small subpatterns, and BWT ( y ) is utilized to speedup the process to figure out all the occurrences of such subpatterns with ⌊ k/l ⌋ differences. In the second step, all the found occurrences in the first step will be rechecked to see whether they really match x , but with k differences. Extensive experiments have been conducted, which show that our method for this problem is promising.

Given a directed edge labeled graph G , to check whether vertex v is reachable from vertex u under a label set S is to know if there is a path from u to v whose edge labels across the path are a subset of S . Such a query is referred to as a label-constrained reachability ( LCR ) query. In this article, we present a new approach to store a compressed transitive closure of G in the form of intervals over spanning trees (forests). The basic idea is to associate each vertex v with two sequences of some other vertices: one is used to check reachability from v to any other vertex, by using intervals, while the other is used to check reachability to v from any other vertex. We will show that such sequences are in general much shorter than the number of vertices in G. Extensive experiments have been conducted, which demonstrates that our method is much better than all the previous methods for this problem in all the important aspects, including index construction times, index sizes, and query times.

By the ordered tree inclusion we will check whether a pattern tree P can be included in a target tree T, where the order of siblings in both Pand T matters. This problem has many applications in practice, such as retrieval of documents, data mining, and RNA structure matching. In this paper, we propose an efficient algorithm for this problem. Its time complexity is bounded by O(|T| · min{hP; |leaves(P)|}), with O(|T| + |P|) space being used, where hP(hT) represents the height of P (resp., T) and leaves (P) stands for the set of the leaves of P. Up to now the best algorithm for this problem needs Θ(|T| · |leaves(P)|) time and O(|P| + |T|) space. Extensive experiments have been done, which show that the new algorithm can perform much better than the existing ones in practice.

In this paper, we discuss an efficient and effective index mechanism to do the string matching with k mismatches, by which we will find all the substrings in a target string s having at most k positions different from a pattern string r. The main idea is to transform s to a BWT-array as index, denoted as BWT(s), and search r against it. During the process, the precomputed mismatch information of r will be utilized to speed up the BWT(s)'s navigation. In this way, the time complexity can be reduced to O(kn' + n + mlogm), where m = |r|, n = |s|, and n' is the number of leaf nodes of a tree structure, called a mismatching tree, produced during a search of BWT(s). Extensive experiments have been conducted, which show that our method for this problem is promising.

Let G(V, E) be a digraph (directed graph) with n nodes and e edges. Digraph G* = (V, E*) is the reflexive, transitive closure if (v, u) ∈ E* iff there is a path from v to u in G. Efficient storage of G* is important for supporting reachability queries which are not only common on graph databases, but also serve as fundamental operations used in many graph algorithms. A lot of strategies have been suggested based on the graph labeling, by which each node is assigned with certain labels such that the reachability of any two nodes through a path can be determined by their labels. Among them are interval labelling, chain decomposition, and 2-hop labeling. However, due to the very large size of many real world graphs, the computational cost and size of labels using existing methods would prove too expensive to be practical. In this paper, we propose a new approach to decompose a graph into a series of spanning trees which may share common edges, to transform a reachability query over a graph into a set of queries over trees. We demonstrate both analytically and empirically the efficiency and effectiveness of our method.

Given a directed graph G, to check whether a node v is reachable from another node u through a path is often required. In a database system, such an operation is called a recursion computation or reachability checking and not efficiently supported. The reason for this is that the space to store the whole transitive closure of G is prohibitively high. In this paper, we address this issue and propose an 0(n2+ bnradic(b)) time algorithm to decompose a directed acyclic graph (DAG) into a minimized set of disjoint chains to facilitate reachability checking, where n is the number of the nodes and b is the DAG's width, defined to be the size of a largest node subset U of the DAG such that for every pair of nodes u, v isin U, there does not exist a path from u to v or from v to u. Using this algorithm, we are able to label a graph in 0(be) time and store all the labels in O(bn) space with O(logb) reachability checking time, where e is the number of the edges of the DAG. The method can also be extended to handle cyclic directed graphs. Experiments have been performed, showing that our method is promising.

Tree encoding is a very useful mechanism to check ancestor-descendant relationships of the nodes in a tree structure, by which each node is associated with a pair of integers that can be used to characterize the reachability. Recently, this method is extended to directed graphs (digraph for short) G by associating each node in G with a pair sequence. However, no approach is reported to minimize such pair sequences. In this paper, we address this issue and propose an efficient algorithm that is always able to generate minimized pair sequences. The algorithm runs in O(bmiddote + bmiddotnmiddotradicb) time and O(bmiddot n), where n and e are the numbers of the nodes and edges of a DAG, respectively; and b is the DAG's width.

Advanced database application areas, such as computer aided design, office automation, digital libraries, data-mining, as well as hypertext and multimedia systems, need to handle complex data structures with set-valued attributes, which can be represented as bit strings, called signatures. A set of signatures can be stored in a file, called a signature file. In this paper, we propose a new method to organize a signature file into a tree structure, called a signature tree, to speed up the signature file scanning and query evaluation. In addition, the average time complexity of searching a signature tree is analyzed and how to maintain a signature tree on disk is discussed. We also conducted experiments, which show that the approach of signature trees provides a promising index structure

Advanced database application areas, such as computer aided design, office automation, digital libraries, data-mining as well as hypertext and multimedia systems need to handle complex data structures with set-valued attributes, which can be represented as bit strings, called signatures. A set of signatures can be stored in a file, called a signature file. In this paper, we propose a new method to organize a signature file into a tree structure, called a signature tree, to speed up the signature file scanning and query evaluation.

We propose a new algorithm for computing recursive closures. The main idea behind this algorithm is tree labeling and graph decomposition, based on which the transitive closure of a directed graph can be computed in O(e/spl middot/d/sub max//spl middot/d/sub out/) time and in O(n/spl middot/d/sub max//spl middot/d/sub out/) space, where n is the number of the nodes of the graph, e is the numbers of the edges, d/sub max/ is the maximal indegree of the nodes, and d/sub out/ is the average outdegree of the nodes. Especially, this method can be used to efficiently compute recursive relationships of a directed graph in a relational environment.

Grahne et al. have presented a graph algorithm for evaluating a subset of recursive queries. This method consists of two phases. In the first phase, the method transforms a linear binary-chain program into a set of equations over expressions containing predicate symbols. In the second phase, a graph is constructed from the equations and the answers are produced by traversing the relevant paths. In this paper, we describe a new algorithm which requires less time than Grahne's. The key idea of the improvement is to reduce the search space that will be traversed when a query is invoked. Furthermore, we speed up the evaluation of cyclic data by generating most answers directly in terms of the answers already found and the associated "path information" instead of traversing the corresponding paths as usual. In this way, our algorithm achieves a linear time complexity for both acyclic and cyclic data.

In this paper, a new technique is developed to support the query relaxation in biological databases. Query relaxation is required due to the fact that queries tend not to be expressed exactly by the users, especially in scientific databases such as biological databases, in which complex domain knowledge is heavily involved. To treat this problem, we propose the concept of the so-called fuzzy equivalence classes to capture important kinds of domain knowledge that is used to relax queries. This concept is further integrated with the canonical techniques for pattern searching such as the position tree and automaton theory. As a result, fuzzy queries produced through relaxation can be efficiently evaluated. This method has been successfully utilized in a practical biological database - the GPCRDB.

As a subset of SGML, XML (Extensible Markup Language) is becoming a dominant standard for representing data in the World Wide Web and therefore the efficient treatment of XML data is important for information transfer over a network. One way towards this goal is to integrate database technology into document management and bring the very nature of database systems into this area, such as query processing, efficient management of secondary storage, version and update control, etc. We propose a new method to map DTDs (Document Type Definition) into object-oriented schemas. In this way, any complicated DTD structure can be treated uniformly. That is, using the concepts of classification/generalization and aggregation of the object-oriented model, any complex nested and recursive structure in a DTD as well as multiple appearance of element types can be represented. These issues can not be addressed if we map a DTD into a relational schema.

To eliminate semantic conflicts among the heterogeneous databases involved in a cooperation, a set of correspondence assertions for declaring their semantic relationships have to be constructed by DBAs or by users. Normally, four set relationships between object classes: equivalence, inclusion, intersection, and exclusion will be defined to provide knowledge about correspondences that exist among the local schemas. In this paper, we would like to introduce a new assertion, the so-called derivation assertion, to accommodate more heterogeneities, which can not be treated by the existing methodologies. As an example, consider two local object-oriented schemas: S/sub 1/ and S/sub 2/ and assume that S/sub 1/ contains two classes: parent and brother, and S/sub 2/ contains a class: uncle. A derivation assertion of the form: S/sub l/(parent, brother)/spl rarr/S/sub 2/(uncle) can specify their corresponding semantic relationship clearly, which can not be established otherwise. We claim that this kind of assertions is necessary for the following reason. Imagine a query concerning uncle, submitted to the integrated schema from S/sub 1/ and S/sub 2/. If the above assertion is not specified, the query evaluation will not take schema S/sub 1/ into account and thus the answers to the query can not be correctly computed in the sense of cooperations.

We present a query system that has been implemented in a practical biological database-GPCRDB. Distinguishing features of this system include: smart query relaxation and smooth integration of navigation with conventional language based query functions. Query relaxation is required due to the fact that queries are not always effective (in other words, expected results are frequently not achieved), particularly in scientific databases like biological databases, in which complex domain knowledge is heavily used. On the other hand, navigation capability is desired as complex data sets are involved, especially in a WWW based environment where multiple hyperlinks are often employed. For efficient implementation, the "fuzzy equivalence class" concept has been applied that captures an important type of domain knowledge.

GPCRDB (G-Protein Coupled Receptors DataBase) is an advanced data management system for G-protein coupled receptors (GPCRs). It collects various data related to all aspects of GPCRs in a variety of forms: HTML pages, formatted source data files, 3D structures, ordinary database tables, etc. The GPCRDB query system is designed to facilitate academic and industrial users in the areas of pharmacology and/or biology to search for information in an integrated, easy-to-operate environment. Currently, the query system is operable on the World Wide Web at.

LSIR

In this paper, we consider the query evaluation problem in relational multidatabases and develop a method for generating optimal plans for queries submitted to such a system. Two aspects will be discussed: join tree balance and node allocation. For the first problem, we extend the approach for balancing a join tree proposed by Du et al, so that more balanced join trees can be obtained, when, we present the concepts of dynamic time tables and constrained topological order to do the node allocation so that both the current load states of local database systems and load changes during the join operations can be handled. In this way, the deficiency of Evrendilek's method can be removed.

Summary form only given. As the first step of database integration, a participating local database schema should be transformed into an abstract one to remove data model conflicts. For our project, the object-oriented schema is chosen to represent the integrated information and a semi-automatic method is developed to transform relational schemas into OO schemas. The main idea behind this method is to define two kinds of logics: a relational database logic L/sub db/ and an object-oriented logic L/sub o/ to formalize the corresponding data models. L/sub db/ is used to model a database structure as well as its state, while L/sub o/ is utilized for an object-oriented database. Then, based on these formalisms, a set of Horn-clause-like rules is constructed to perform meta-level reasoning for translating a formalism into another.

We consider the query evaluation problem in multidatabases and develop an algorithm for generating optimal plans for queries submitted to an integrated schema. We try to extend the basic transformation step used in the method proposed by (Du et al., 1994) and construct a dynamic time table to support a query optimization process. In this way, not only the join tree balance, but also the node allocation can be achieved according to both communication costs and load measurements. In addition, the queuing analysis has been utilized to estimate the response times of local database systems.

This article considers the efficient bottom-up query evaluation for stratified databases. We investigate the applicability of magic-set method to stratified databases containing negative body literals and show that culprit cycles cause unstratification. Based on the analysis, we present a labeling algorithm to distinguish the context for constructing magic sets, which is simpler and more efficient than the algorithms proposed by Balbin et al. [J. Logic Programming, 295–344 (1991)]. © 1997 John Wiley & Sons, Inc.

In this article, we present an optimal bottom-up evaluation method for handling both linear and nonlinear recursion. Based on the well-known magic-set method, we develop a technique: labeling to record the cyclic paths during the execution of the first phase of the magic-set method and suspending the computation for the cyclic data in the second phase to avoid the redundant evaluation. Then we postpone this computation to an iteration process (the third phase) which evaluates the remaining answers only along each cyclic path. In this way, we can guarantee the completeness. In addition, for a large class of programs we further optimize our method by elaborating the iteration process and generating most answers for each cyclic path directly from the intermediate results instead of evaluating them by performing algebraic operations (after some of the answers for the first cyclic path are produced). Because the cost of generating an answer is much less than that of evaluating an answer, this optimization is significant. © 1996 John Wiley & Sons, Inc.

Grahne et al. have presented a graph algorithm for a subset of recursive queries. This method consists of two phases. In the first phase, the method transforms a linear binary-chain program into a set of equations over expressions containing predicate symbols. In the second phase, a graph is constructed from the equations and the answers are produced by traversing the relevant paths. Here we describe a new algorithm which requires less time than the algorithm of Grahne et al. The key idea of the improvement is to reduce the search space that will be traversed when a query is invoked. Further, we speed up the evaluation of cyclic data by generating most answers directly in terms of the answers already found and the associated “path information” instead of traversing the corresponding paths as usual. In this way, our algorithm achieves a linear time complexity for both cyclic and non-cyclic data.

A labeling algorithm for stratified databases is presented. The algorithm that is performed prior to the magic-set algorithm can be used to distinguish the context for constructing magic sets. It is shown that the culprit cycles cause the destratification of a database. Based on this analysis, three subprocedures are developed to remove the different kinds of culprit cycles. The negnumber procedure numbers the different occurrences of a negative literal in a rule. The dynlabel procedure gives each negative body literal a dynamic subscript when it appears in a recursive rule. The label procedure labels each body literal p when there exists a sequence of paths connecting it to a negative body literal-q in the same rule, or a sequence of paths with at least one path being negative connecting it to a positive body literal q in the same rule and there is an arc of the form N/spl rarr/r in the sideways information-passing strategy (SIPS) such that q/spl isin/N and p=r.>

C.C. Han and C.H. Lee (1988) presented a path consistency algorithm. A new algorithm is described for path consistency, and it is shown that the algorithm requires less time and space than Han and Lee's. The key idea of the algorithms is the arranging of the edges which are checked in the first part of Han and Lee's algorithm and the interlacing of the second part of the algorithm in the first part by using the symmetry of the triangle.>