Constant Strings Research Articles

Quadratic Word Equations with Length Constraints, Counter Systems, and Presburger Arithmetic with Divisibility

Word equations are a crucial element in the theoretical foundation of constraint solving over strings. A word equation relates two words over string variables and constants. Its solution amounts to a function mapping variables to constant strings that equate the left and right hand sides of the equation. While the problem of solving word equations is decidable, the decidability of the problem of solving a word equation with a length constraint (i.e., a constraint relating the lengths of words in the word equation) has remained a long-standing open problem. We focus on the subclass of quadratic word equations, i.e., in which each variable occurs at most twice. We first show that the length abstractions of solutions to quadratic word equations are in general not Presburger-definable. We then describe a class of counter systems with Presburger transition relations which capture the length abstraction of a quadratic word equation with regular constraints. We provide an encoding of the effect of a simple loop of the counter systems in the existential theory of Presburger Arithmetic with divisibility (PAD). Since PAD is decidable (NP-hard and is in NEXP), we obtain a decision procedure for quadratic words equations with length constraints for which the associated counter system is flat (i.e., all nodes belong to at most one cycle). In particular, we show a decidability result (in fact, also an NP algorithm with a PAD oracle) for a recently proposed NP-complete fragment of word equations called regular-oriented word equations, when augmented with length constraints. We extend this decidability result (in fact, with a complexity upper bound of PSPACE with a PAD oracle) in the presence of regular constraints.

What is decidable about string constraints with the ReplaceAll function

The theory of strings with concatenation has been widely argued as the basis of constraint solving for verifying string-manipulating programs. However, this theory is far from adequate for expressing many string constraints that are also needed in practice; for example, the use of regular constraints (pattern matching against a regular expression), and the string-replace function (replacing either the first occurrence or all occurrences of a ``pattern'' string constant/variable/regular expression by a ``replacement'' string constant/variable), among many others. Both regular constraints and the string-replace function are crucial for such applications as analysis of JavaScript (or more generally HTML5 applications) against cross-site scripting (XSS) vulnerabilities, which motivates us to consider a richer class of string constraints. The importance of the string-replace function (especially the replace-all facility) is increasingly recognised, which can be witnessed by the incorporation of the function in the input languages of several string constraint solvers. Recently, it was shown that any theory of strings containing the string-replace function (even the most restricted version where pattern/replacement strings are both constant strings) becomes undecidable if we do not impose some kind of straight-line (aka acyclicity) restriction on the formulas. Despite this, the straight-line restriction is still practically sensible since this condition is typically met by string constraints that are generated by symbolic execution. In this paper, we provide the first systematic study of straight-line string constraints with the string-replace function and the regular constraints as the basic operations. We show that a large class of such constraints (i.e. when only a constant string or a regular expression is permitted in the pattern) is decidable. We note that the string-replace function, even under this restriction, is sufficiently powerful for expressing the concatenation operator and much more (e.g. extensions of regular expressions with string variables). This gives us the most expressive decidable logic containing concatenation, replace, and regular constraints under the same umbrella. Our decision procedure for the straight-line fragment follows an automata-theoretic approach, and is modular in the sense that the string-replace terms are removed one by one to generate more and more regular constraints, which can then be discharged by the state-of-the-art string constraint solvers. We also show that this fragment is, in a way, a maximal decidable subclass of the straight-line fragment with string-replace and regular constraints. To this end, we show undecidability results for the following two extensions: (1) variables are permitted in the pattern parameter of the replace function, (2) length constraints are permitted.

Locating Need-to-Externalize Constant Strings for Software Internationalization with Generalized String-Taint Analysis

Nowadays, a software product usually faces a global market. To meet the requirements of different local users, the software product must be internationalized. In an internationalized software product, user-visible hard-coded constant strings are externalized to resource files so that local versions can be generated by translating the resource files. In many cases, a software product is not internationalized at the beginning of the software development process. To internationalize an existing product, the developers must locate the user-visible constant strings that should be externalized. This locating process is tedious and error-prone due to 1) the large number of both user-visible and non-user-visible constant strings and 2) the complex data flows from constant strings to the Graphical User Interface (GUI). In this paper, we propose an automatic approach to locating need-to-externalize constant strings in the source code of a software product. Given a list of precollected API methods that output values of their string argument variables to the GUI and the source code of the software product under analysis, our approach traces from the invocation sites (within the source code) of these methods back to the need-to-externalize constant strings using generalized string-taint analysis. In our empirical evaluation, we used our approach to locate need-to-externalize constant strings in the uninternationalized versions of seven real-world open source software products. The results of our evaluation demonstrate that our approach is able to effectively locate need-to-externalize constant strings in uninternationalized software products. Furthermore, to help developers understand why a constant string requires translation and properly translate the need-to-externalize strings, we provide visual representation of the string dependencies related to the need-to-externalize strings.

Ebbie: automated analysis and storage of small RNA cloning data using a dynamic web server

BackgroundDNA sequencing is used ubiquitously: from deciphering genomes[1] to determining the primary sequence of small RNAs (smRNAs) [2-5]. The cloning of smRNAs is currently the most conventional method to determine the actual sequence of these important regulators of gene expression. Typical smRNA cloning projects involve the sequencing of hundreds to thousands of smRNA clones that are delimited at their 5' and 3' ends by fixed sequence regions. These primers result from the biochemical protocol used to isolate and convert the smRNA into clonable PCR products. Recently we completed a smRNA cloning project involving tobacco plants, where analysis was required for ~700 smRNA sequences[6]. Finding no easily accessible research tool to enter and analyze smRNA sequences we developed Ebbie to assist us with our study.ResultsEbbie is a semi-automated smRNA cloning data processing algorithm, which initially searches for any substring within a DNA sequencing text file, which is flanked by two constant strings. The substring, also termed smRNA or insert, is stored in a MySQL and BlastN database. These inserts are then compared using BlastN to locally installed databases allowing the rapid comparison of the insert to both the growing smRNA database and to other static sequence databases. Our laboratory used Ebbie to analyze scores of DNA sequencing data originating from an smRNA cloning project[6]. Through its built-in instant analysis of all inserts using BlastN, we were able to quickly identify 33 groups of smRNAs from ~700 database entries. This clustering allowed the easy identification of novel and highly expressed clusters of smRNAs. Ebbie is available under GNU GPL and currently implemented on ConclusionEbbie was designed for medium sized smRNA cloning projects with about 1,000 database entries [6-8].Ebbie can be used for any type of sequence analysis where two constant primer regions flank a sequence of interest. The reliable storage of inserts, and their annotation in a MySQL database, BlastN[9] comparison of new inserts to dynamic and static databases make it a powerful new tool in any laboratory using DNA sequencing. Ebbie also prevents manual mistakes during the excision process and speeds up annotation and data-entry. Once the server is installed locally, its access can be restricted to protect sensitive new DNA sequencing data. Ebbie was primarily designed for smRNA cloning projects, but can be applied to a variety of RNA and DNA cloning projects[2,3,10,11].

Web Application Slicing in Presence of Dynamic Code Generation

The computation of program slices on Web applications may be useful during debugging, when the amount of code to be inspected can be reduced, and during understanding, since the search for a given functionality can be better focused. The system dependence graph is an appropriate data structure for slice computation, in that it explicitly represents all dependences that have to be taken into account in slice determination. Construction of the system dependence graph for Web applications is complicated by the presence of dynamically generated code. In fact, a Web application builds the HTML code to be transmitted to the browser at run time. Knowledge of such code is essential for slicing. In this paper an algorithm for the static approximation of the dynamically generated HTML code is proposed. The concatenations of constant strings and variables are propagated according to special purpose flow equations, allowing the estimation of the generated code and the refinement of the system dependence graph.

Inductive inference of unbounded unions of pattern languages from positive data

A pattern is a string consisting of constant symbols and variables. The language of a pattern is the set of constant strings obtained by substituting nonempty constant strings for variables in the pattern. In this paper we consider the inductive inference of unbounded unions of pattern languages from positive data. For any fixed k, the class of unions of at most k pattern languages is already shown to be inferable from positive data. The class of unbounded unions is not inferable, because any pattern with at least one variable defines an infinite language and any constant string defines a singleton set consisting of itself, and therefore, the class of unions becomes super-finite, that is, it contains all the finite languages and at least one infinite language. In this paper, we consider several restrictions on patterns to investigate the inferability of unbounded unions of their languages from positive data. A proper pattern contains at least one variable. A regular pattern contains at most one occurrence of every variable. Although the class of unbounded unions of proper pattern languages is not super-finite, it is shown not to be inferable from positive data, even if patterns are restricted to be regular or one-variable. When regular patterns are restricted to be of the form “ xwy”, where x and y are variables and w is a constant string, the class of unbounded unions is shown to be inferable from positive data. When regular patterns do not contain more than l consecutive occurrences of constant symbols, for some fixed l, the class of unbounded unions is shown to be inferable from positive data. Extended pattern languages, where substitutions of the empty string for some variables are allowed, are also considered from the viewpoint of relationship to the inferability of unbounded unions of non-extended pattern languages.

On three-dimensional constant curvature strings

Abstract I consider a string theory with target space three-dimensional Euclidean space whose action, besides the standard area term, contains another one proportional to the volume enclosed by the surface. The associated variational problem yields as solutions constant mean curvature surfaces. The equation of motion can be rewritten as a zero curvature condition for a SU (2) connection, thus implying the existence of an infinite set of conserved nonlocal charges. I also show how a description of the Gauss map of the surface in terms of SU (2) spinors allows for yet a different description of this result by means of a Gross-Neveu spinorial model coupled to 2-D gravity.

A note on the two-variable pattern-finding problem

A pattern is a finite string of constant and variable symbols. A pattern p represents a language L(p) of all finite strings of constant symbols that can be generated from p by substituting a constant string for each variable in p. The k-variable pattern-finding problem, k ≥ 1, is to find, for a given set S of finite constant strings, a longest pattern p of k variables such that L(p) contains S. A polynomial-time algorithm for the one-variable pattern-finding problem has been found by Angluin using the data structure called pattern automata. A straightforward generalization of this algorithm to the two-variable case involves a sub-problem of finding common paths of pattern automata. It is proved that this subproblem in the generalized algorithm is NP-hard.

PROM programmer

This chapter covers C constants in detail. The syntax and common use for the decimal, binary, hexadecimal, and octal radix in C is fully explained. Both signed and unsigned constant examples are shown for whole numbers, along with their advantages and disadvantages with a RISC processor.The reader will learn the uses and implementation of floating-point numbers in C for embedded applications. Fixed-point number formats and their advantages are covered as an alternative to floating point.Constant characters, constant strings, and the special C method to deal with non-printable characters are all a part of this chapter.Examples and exercises are for the popular PIC®; microcontroller manufactured by Microchip.