Abstract:
A system and method for identifying and valuing software is realized by use of a logical structures-to-functions (LSF) model with steps for creating LSF sequences and storing them in a data storage medium for querying. Number and types of lowest abstract functional components and order of flow of logical data processing of each computer program algorithm of the computer program are identified. Components of each algorithm are coded into a sequence of characters for preserving information of the order of flow of data processing and number and types of components. The sequence is stored in a data storage medium. The data storage medium is queried to compare the sequence of characters, for its respective computer program algorithm, to general population sequences, of other computer program algorithms, to find similarities and differences in structural and functional data processing.

Description:
BACKGROUND OF THE INVENTION 
       [0001]    1. Field of the Invention 
         [0002]    The present invention relates to computer software, intellectual property, and systems and methods for identifying and valuing a computer software program relative to general population computer software programs, especially in efforts of prior art searches of computer software inventions. 
         [0003]    2. Description of Prior Art 
         [0004]    The use of simple character sequences to code lowest abstract functional components of a larger, complex system has been appreciated for years by widespread applications in fields such as chemistry, biology, and genetics. For example, genetics is built upon a coding scheme of identifying four nucleobases (adenine, guanine, cytosine, and thymine) as major components of nucleotides of deoxyribonucleic acid (DNA). These are the familiar “base pairs” of DNA that are used to identify and associate structural DNA components to the functionality of proteins. Chemistry sorts out molecular compounds and observes chemical reactions by the structures and functions of elements of the periodic table. Biology further capitalizes on the coding schemes of chemistry and genetics to help understand the organic and inorganic roles of molecular compounds in the formation and functioning of life. The commonality and great utility of simple coding schemes to separate and categorize lowest abstract functional components is apparent. This further allows scientists, engineers, medical practitioners, patent attorneys, patent examiners, law-makers, students, educators, and more to search through and adequately distinguish the structural and functional similarities and differences between these elements and compounds. While these coding practices arise from natural properties inherent to these elements and compounds, the computer sciences exists with relatively less natural intervention in its existence. 
         [0005]    The computer sciences is mostly a construct of human intervention. While the operation of computer hardware and software are limited by the laws of physics, people have played the larger role in deciding how computer technology has evolved. This has resulted in a wide array of standard and non-standards for such things like hardware specifications, software programming languages, network connectivity, and more. Regardless of the diverse and subjective uses of computer technology, all software programming is linked by the mathematical rules of logic. Computer programs can be presented by algorithms to show the bare structural and functional roles of the software program, regardless of the computer programming language. In fact, computer programs are routinely presented as logical flowcharts, especially in environments of production teams and intellectual property technology disclosures. Unfortunately, flowcharts are as diverse and subjective in their use as the vast landscape of programming languages and a lack of standards for creating and reporting by flowchart has resulted in a thicket of nearly incomparable documentation of software program algorithms. Even worse, the rise in popular use of unstructured breaks of flowchart diagramming has allowed software patent applicants to practice a drafting method akin to allowing one to disclose as they please. These unstructured breaks are difficult to maneuver around so that a full comprehension of the true software algorithm being presented can be achieved. Consequently, unstructured flowcharts routinely conceal the true number and types of components of a software program algorithm which further gives the advantage to applicants to create a false illusion that their invention is more simple or vastly different from the prior art when often it is very similar, more complex, or the exact same invention. 
       ADVANTAGES 
       [0006]    The software patent debate is well documented by information technology and law journals, U.S. courts, public opinion articles, and other publications. Any future substantial change to the legality of software patents, however, is uncertain. Therefore, a new focus of academic and technological efforts should be to improve the current system as is. 
         [0007]    Important court rulings concerning the filing of software patents include In re Hayes and In re Sherwood establishing that adequate description writing of software inventions do not require full listing of code sources as long as the functions of the software are fully disclosed. This has left the door wide open for patent drafters to leisurely explore and use flowchart diagramming of software inventions. A serious issue not addressed by the courts in regards to this type of disclosure is standard formatting of flowcharting of logical computational structures. It is common knowledge among average programmers that there is a stark difference between structured and unstructured programming. Current research has found that a known set of weak software patents, identified as the most-litigated software patents from January 2000 to February 2009, was found to be plagued with 71.3% unstructured flowcharts for 258 flowcharts identified among 57 software patents. This is statistically significant compared to only 23.1% unstructured flowcharts for 195 flowcharts from 59 general population software patents. It is indicated from these results that the low quality of these most-litigated software patents that often lost their cases is related to the low quality of software flowchart disclosure. 
         [0008]    One of the most serious problems with unstructured flowcharts is that it does not represent a one-to-one relation between the flowchart and source code. This is problematic for several reasons including the failure to represent a unique software algorithm, misleading functional processing, concealment and subjective removal of logical functional structures, and other factors. For the most part, any software algorithm can be taken and unstructured to such a point that what once was the same or very similar to the prior art is now extremely unfamiliar as it has been construed to be very different in form and function. In summary, the courts allowing patent drafters to disclose software algorithms by unstructured flowchart diagrams is akin to giving them a license to “disclose as they please.” Consequently, there is a strong need for a system and method for identifying and valuing software patents by effective identification of logical software structures as lowest abstract functional components and further identification of unstructured break points in the order of flow of data processing. The present invention is the only known technology that can perform all these tasks. 
       SUMMARY 
       [0009]    The present invention is a system and method for identifying and valuing a computer software program. Each algorithm of the program is identified and coded by a sequence of characters. The sequence is called a logical structures-to-functions (LSF) sequence as it is based on a logical structures-to-functions (LSF) model. To uniquely identify software program algorithms, there are eleven rules for coding a LSF sequence. The rules are accomplished in a general execution of steps of a method. Number and types of lowest abstract functional components and order of flow of logical data processing of each computer program algorithm of the computer program are identified. Components of each algorithm are coded into a sequence of characters for preserving information of the order of flow of data processing and number and types of components. The sequence is stored in a data storage medium. The data storage medium is queried to compare the sequence of characters, for its respective computer program algorithm, to general population sequences, of other computer program algorithms, to find similarities and differences in structural and functional data processing. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0010]      FIG. 1  is an algorithm for a method of creating an LSF sequence by use of the LSF model. 
           [0011]      FIG. 2  is an algorithm for a method that is called by the algorithm of  FIG. 1 . 
           [0012]      FIG. 3  presents a computer hardware and software configuration used for storing, accessing, and querying data for a collection of LSF sequences. 
           [0013]      FIG. 4  is a list of the LSF model rules. 
           [0014]      FIG. 5  is a list of sample queries. 
           [0015]    The following list briefly identifies elements of  FIG. 1 ,  FIG. 2 ,  FIG. 3 ,  FIG. 4 , and  FIG. 5  by element numbering correlated to brief descriptions of these elements. 
       
    
    
     ELEMENT NUMBERS AND DESCRIPTIONS 
     Element Number Element Description 
       [0016]      
         [0000]    
       
         
               
               
             
           
               
                   
               
               
                 Element Number 
                 Element Description 
               
               
                   
               
             
             
               
                 101 
                 client computer 
               
               
                 103 
                 TCP/IP network 
               
               
                 105 
                 web server 
               
               
                 107 
                 HTML page 
               
               
                 109 
                 script page 
               
               
                 111 
                 web-to-database middleware 
               
               
                 113 
                 server computer 
               
               
                 115 
                 database connectivity middleware 
               
               
                 117 
                 DBMS server 
               
               
                 119 
                 database 
               
               
                 121 
                 DBMS computer 
               
               
                 123 
                 sequence structure for getting source code 
               
               
                 125 
                 sequence structure for identifying first structure 
               
               
                 127 
                 decision structure for asking if sequence structure 
               
               
                 129 
                 sequence structure for coding sequence structure 
               
               
                 131 
                 decision structure for asking if decision structure 
               
               
                 133 
                 sequence structure for coding decision structure 
               
               
                 135 
                 decision structure for asking if there is a nested 
               
               
                   
                 structure in decision structure 
               
               
                 137 
                 sequence structure calling method for nested structure 
               
               
                 139 
                 decision structure asking if repetition structure 
               
               
                 141 
                 sequence structure for coding repetition structure 
               
               
                 143 
                 decision structure asking if there is a nested structure 
               
               
                   
                 in repetition structure 
               
               
                 145 
                 sequence structure for coding unknown structure 
               
               
                 147 
                 decision structure asking if structure has an 
               
               
                   
                 unstructured break in data processing 
               
               
                 149 
                 sequence structure for coding unstructured break in 
               
               
                   
                 data processing 
               
               
                 151 
                 decision component of repetition structure asking if 
               
               
                   
                 there is another structure of the source code 
               
               
                 153 
                 sequence structure storing the final LSF sequence 
               
               
                 155 
                 list of LSF model rules 
               
               
                 157 
                 list of sample queries 
               
               
                   
               
             
          
         
       
     
       DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
       [0017]    The detailed description for  FIG. 1 ,  FIG. 2 ,  FIG. 3 ,  FIG. 4 , and  FIG. 5  and all elements identified within, is as follows. 
         [0018]      FIG. 1  presents an algorithm for using the rules of the LSF model to find the LSF sequence of an algorithm of a software program. The source code of a computer software program algorithm is processed by a sequence structure for getting source code  123 . A sequence structure for identifying first structure  125  reads the source code for the first lowest abstract functional component of the software program algorithm being processed. A decision structure for asking if sequence structure  127  processes the first component (logical structure) identified previously and if the first structure is a sequence structure, it is coded by a sequence structure for coding sequence structure  129  for being a sequence structure. If it is not a sequence structure it is processed by a decision structure for asking if decision structure  131  and if the first structure is a decision structure, it is coded by a sequence structure for coding decision structure  133  for being a decision structure. It is then processed by a decision structure for asking if there is a nested structure in decision structure  135 . If there is a nested structure, it is further processed by a sequence structure calling method for nested structure  137 . If it is not a decision structure it is processed by a decision structure for asking if repetition structure  139  and if the first structure is a repetition structure, it is coded by a sequence structure for coding repetition structure  141  for being a repetition structure. 
         [0019]    It is then processed by a decision structure asking if there is a nested structure in repetition structure  143 . If there is a nested structure, it is further processed by sequence structure calling method for nested structure  137 . If it is not a repetition structure it is processed by a sequence structure for coding unknown structure  145  for being an unknown structure. Further processing following all of these previously mentioned structures occurs by a decision structure asking if structure has an unstructured break in data processing  147 . If there is an unstructured break in this part of the source code it is identified by a sequence structure for coding unstructured break in data processing  149 . This can include an entry, exit, or both of unstructured data flow at this point. After this, further processing occurs by a decision component of repetition structure asking if there is another structure of the source code  151 . If there are more lowest abstract functional components (logical structures) of the source code to be analyzed for completing the LSF sequence by LSF modeling, the processing will return to decision structure for asking if sequence structure  127 . Processing continues for each logical structure of the source code until the last structure is processed and reaches decision component of repetition structure asking if there is another structure of the source code  151 . Since it is the last structure, processing will go to a sequence structure storing the final LSF sequence  153  which then stores the LSF sequence in a data storage medium. This will most likely be a database though other containers like flat file systems and spreadsheets could also be used for storage. The querying capabilities of these other systems, however, would most likely not be as powerful as a database and therefore a database as a data storage medium is preferred. 
         [0020]      FIG. 2  presents an algorithm for sequence structure calling method for nested structure  137  called by the algorithm of  FIG. 1 . The algorithm of  FIG. 2  is composed of part of the algorithm of  FIG. 1 . Decision structure for asking if sequence structure  127  processes the structure passed to it through the method call and if the structure is a sequence structure, it is coded by sequence structure for coding sequence structure  129  for being a sequence structure. If it is not a sequence structure it is processed by decision structure for asking if decision structure  131  and if the structure is a decision structure, it is coded by sequence structure for coding decision structure  133  for being a decision structure. It is then processed by decision structure for asking if there is a nested structure in decision structure  135 . If there is a nested structure, it is further processed by sequence structure calling method for nested structure  137 . If it is not a decision structure it is processed by decision structure asking if repetition structure  139  and if the structure is a repetition structure, it is coded by sequence structure for coding repetition structure  141  for being a repetition structure. It is then processed by decision structure asking if there is a nested structure in repetition structure  143 . If there is a nested structure, it is further processed by sequence structure calling method for nested structure  137 . If it is not a repetition structure it is processed by sequence structure for coding unknown structure  145  for being an unknown structure. Further processing following all of these previously mentioned structures occurs by decision structure asking if structure has an unstructured break in data processing  147 . If there is an unstructured break in this part of the source code it is identified by sequence structure for coding unstructured break in data processing  149 . Using the data processing of the algorithms of  FIG. 1  and  FIG. 2 , multiple nested structures can be adequately identified and coded into the LSF sequence. 
         [0021]      FIG. 3  presents a computer hardware and software configuration used for storing, accessing, and querying data for a collection of LSF sequences. A user can access LSF sequence data through connection to a web server  105  over a TCP/IP network  103  by interfacing with a client computer  101 . Web server  105  is part of a server computer  113  that accepts a script page  109  containing processed queries submitted by the user and sends them through a web-to-database middleware  111 . A database connectivity middleware  115  further takes the data from web-to-database middleware  111  and processes it from server computer  113  to a DBMS computer  121  can use. A DBMS server  117  of DBMS computer  121  further processes the query so that the required data can be attained from a database  119  that holds the LSF sequence data. This data is returned from database  119  to DBMS server  117  which is then further processed by database connectivity middleware  115  to bring it back through web-to-database middleware  111 . A HTML page  107  is then produced to move the queried data to web server  105  so that the data can be transferred across TCP/IP network  103  and reported to the user via client computer  101 . 
         [0022]      FIG. 4  holds content of a list of the LSF model rules  155 . Eleven rules outline a method for coding all the logical structures, the lowest abstract functional components, of a software program algorithm into characters that can be stored as an LSF sequence. Though there are several possibilities for how these rules could have been crafted for character sequencing, this list presents a set that meets the best balance between standardization and flexibility. Any deviation from the list could be compromising that balance and would not be accomplishing the creation of a true LSF sequence. 
         [0023]      FIG. 5  holds content of a list of sample queries  157 . The content is composed of SQL queries used to access a database storing LSF sequences. While there are several ways to query a database and several ways to pull data from a data storage medium, these samples present a few ways it can be accomplished. Specifically, these queries are capable of identifying LSF sequences composed of same or similar types of lowest abstract functional components along with number of components and order of flow of logical data processing. 
       Conclusion 
       [0024]    The present invention draws upon proven models of the natural sciences to create an artificial “genetic code” for software program algorithms. The advantages are comparable to the successes of coding schemes used in chemistry, biology, and genetics. By identifying only the lowest abstract functional components (logical structures) with their respective order of flow of logical data processing by a simple sequence of characters, software program algorithm data storage can be reduced often by more than 90%. Furthermore, a collection of software program algorithms can be quantitatively, effectively, and quickly compared for same or similar inherent structures and functions. Just as a gene bank provides quick identification, an LSF bank would save a countless number of hours for scientists, engineers, students, educators, patent examiners, and more that may often need to rely on extensive qualitative searches of software programs—usually a direct result of failure by patent drafters to provide meaningful software algorithm flowcharts that can accurately describe the true number and types of lowest abstract functional components and order of flow of logical data processing. 
         [0025]    For example, the LSF sequence for  FIG. 1  of the current invention is “S-S-R[D(D(D(S)[S-D(N)[S]])[S-D(N)[S]])[S]-D(N)[S]-D]-S.” Because the source code for the algorithm of  FIG. 1  could easily be more than 100 lines of code in any programming language, the simplicity of the LSF sequence is encouraging. It can he quickly determined that this algorithm contains one repetition structure (with one inherent decision component), ten sequence structures, six decision structures, and three null structures. This simple and concise character information of the sequence can be used to create a one-to-one flowchart diagramming the essential lowest abstract functional components and order of flow of logical data processing of the software program algorithm. Furthermore, comparing this sequence to a database of thousands of LSF sequences can identify relevant prior art within seconds. If there are several LSF sequences that match similar or exact to the tested LSF sequence, this indicates a poor value to the tested sequence. If, however, there are virtually no similar sequences in regards to number and types of logical components and order of flow of data processing, this indicates a strong value to the tested sequence and therefore an added strong value to the software program that holds this algorithm. 
         [0026]    Though hardware and software configuration for accessing an LSF database is proposed by remote client connection to the database, the database could likewise be accessed by other methods such as a company intranet or direct interfacing to the database server. The method proposed is considered to most suitable for the potential use of the LSF database by persons all around the World. Users could easily connect to the LSF database and submit a source code for quick and automated creation of its unique LSF sequence. This sequence could then be stored in the LSF database and compared to all other sequences for quick and effective identification of prior art. 
         [0027]    The ability of the LSF model to ensure one-to-one relations of inventions to their disclosure of software program algorithm, to allow proper identification of software, and to be a quick and effective method for valuing software is not achievable by any other known technology. The rules for the LSF model are encouraged as the best balance between standardization and flexibility for a method of coding any kind of sequence of characters for the present invention; however, there are other models that could be used. Accordingly, the scope of the current invention should be judged only by the content of the claims and their legal equivalents.