The Sardinas-Patterson's test for codes has contributed many effective testing algorithms to the development of theory of codes, formal languages, etc. However, we will show that a modification of this test proposed in this paper can deduce more effective testing algorithms for codes. As a consequence, we establish a quadratic algorithm that, given as input a regular language X defined by a tuple (ϕ, M, B), where ϕ : A * → M is a monoid morphism saturating X, M is a finite monoid, B ⊆ M, X = ϕ −1 (B), decides in time complexity O(n 2 ) whether X is a code, where n = Card(M ). Specially, n can be chosen as the finite index of X. A quadratic algorithm for testing of ⋄-codes is also established. )
164
N.D. Han et al. / Quadratic Algorithms for Testing of Codes and ⋄-Codesare established using automata [1,13] and some algorithms of Sardinas-Patterson type are described for specifying unambiguous degrees of languages [9,10]. Due to these important contributions to theory of codes, we have investigated the original algorithm deduced from Sardinas-Patterson's test and found that its time complexity can be more reduced. This provides a new approach to improving of algorithms for codes. Algorithms of that type for the case of regular (also called rational or recognizable) codes and ⋄-codes will be demonstrated in this paper.In general, Sardinas-Patterson's test gives a procedure, but in case of recognizable languages the test provides us an algorithm. For finite languages, Rodeh [15] proposed an O(nm) time complexity algorithm, where n is the number of codewords and m is their total length. In case the input language is given by a finite automaton, McCloskey [13] introduced an O(n 2 ) time complexity algorithm, where n is the sum of the numbers of states and transitions in the automaton. In this paper, we present a modification of Sardinas-Patterson's test, which shows that the number of steps required to determine the set of all residuals combined with a given regular language X, can be decreased to n steps instead of 2 n steps of Sardinas-Patterson one, with n is the index of the syntactic congruence of X. Then, based on the new test we establish a quadratic algorithm that, given as input a regular language X defined by a tuple (ϕ, M, B), where ϕ : A * → M is a monoid morphism saturating X, M is a finite monoid, B ⊆ M, X = ϕ −1 (B), decides in O(n 2 ) time whether X is a code, n = Card(M ). The method of this algorithm can be extended for ⋄-codes considered in Section 6.2. As a very basic result, we can build a deterministic automaton from a given finite monoid M which saturates X with the size (for all vertices and arcs of its graph) of this automaton is about n 2 , where n = Card(M ). From this automaton, if we use the method of McCloskey [13] then the time complexity of the testing algorithm gained is O((n 2 ) 2 ) or O(n 4 ). This shows the advantage of our algorithm. By claims increasing time by time to investigation into new coding systems in both aspects: theory and application, especially in cryptography, in [1...
