Document quality inspection

Methods, computer systems, and computer program products are provided for generating one or more condition sets from one or more documents. The method includes recognizing one or more paragraphs in each document having one or more listing and nested paragraphs and generating one or more paragraph trees wherein each node in the paragraph tree corresponds to a paragraph text in the document. The method further includes extracting one or more conditions as a logical formula from each paragraph text comprising a condition expression; and obtaining one or more condition sets written by a set of logical formulas from the one or more extracted conditions, according to a set of child nodes belonging to each common parent node in each of the paragraph trees; generating one condition set used for quality inspection, for each of the one or more condition sets written by the set of logical formulas.

BACKGROUND

The present principles relate to document quality inspection and, more specifically, to a technique for generating condition sets used for document quality inspection and for performing quality inspection using the condition sets.

Document quality inspection is an important task in reviewing the quality of a document relating to, for example, an existing or developing system from several different views in software development projects. However, such inspection usually tends to be a costly task, because the inspection is usually a highly labor-based task requiring quality-expert persons. A lot of document-artifacts are usually created in the projects. Accordingly, an inspection support system potentially dramatically reduces inspection-costs, such as labor-costs, and time.

SUMMARY

According to one aspect of the present principles, an embodiment of the present principles provides a computer-implemented method for generating one or more condition sets from one or more documents. The method comprises recognizing one or more paragraphs in each document having one or more listing and nested paragraphs and generating one or more paragraph trees, wherein each node in the paragraph tree corresponds to a paragraph text in the document and each edge in the paragraph tree corresponds to parent-child relation between the paragraphs in the document; extracting one or more conditions as a logical formula from each paragraph text comprising a condition expression; obtaining one or more condition sets written by a set of logical formulas from the one or more extracted conditions, according to a set of child nodes belonging to each common parent node in each of the paragraph trees; generating one condition set used for quality inspection, for each of the one or more condition sets written by the set of logical formulas.

According to another aspect of the present principles, a system comprising a computer readable storage medium storing a program of instructions executable by the computer system to perform one or more methods described herein may be provided.

According to another aspect of the present principles, a computer program product comprising a computer readable storage medium storing a program of instructions executable by the computer system to perform one or more methods described herein also may be provided.

DETAILED DESCRIPTION

With reference now toFIG. 1,FIG. 1illustrates an exemplified basic block diagram of a computer hardware used in an embodiment of the present principles.

A computer (101) may be, for example, but is not limited to, a desktop, a laptop, a notebook, a tablet or a server computer. The server computer may be, for example, but is not limited to, a workstation, a rack-mount type server, a blade type server, or a mainframe server and may run, for example, a hypervisor for creating and running one or more virtual machines. The computer (101) may comprise one or more CPUs (102) and a main memory (103) connected to a bus (104). The CPU (102) may be preferably based on a 32-bit or 64-bit architecture. The CPU (102) may be, for example, but is not limited to, the Power® series of International Business Machines Corporation; the Core i™ series, the Core 2™ series, the Atom™ series, the Xeon™ series, the Pentium® series, or the Celeron® series of Intel Corporation; or the Phenom™ series, the Athlon™ series, the Turion™ series, or Sempron™ of Advanced Micro Devices, Inc. (“Power” is registered trademark of International Business Machines Corporation in the United States, other countries, or both; “Core i”, “Core 2”, “Atom”, and “Xeon” are trademarks, and “Pentium” and “Celeron” are registered trademarks of Intel Corporation in the United States, other countries, or both; “Phenom”, “Athlon”, “Turion”, and “Sempron” are trademarks of Advanced Micro Devices, Inc. in the United States, other countries, or both).

A display (106), such as a Liquid Crystal Display (LCD), may be connected to the bus (104) via a display controller (105). The display (106) may be used to display, for management of the computer(s), information on a computer connected to a network via a communication line and information on software running on the computer using an appropriate graphics interface. A disk (108) such as a hard disk or a solid state drive, SSD, and a drive (109) such as a CD, a DVD, or a BD (Blu-ray disk) drive may be connected to the bus (104) via an SATA or IDE controller (107). Moreover, a keyboard (111) and a mouse (112) may be connected to the bus (104) via a keyboard-mouse controller (110) or USB bus (not shown).

An operating system, programs providing Windows®, UNIX® Mac OS®, Linux®, or a Java® processing environment, Java® applications, a Java® Virtual Machine (VM), and a Java® Just-In-Time (JIT) compiler, such as J2EE®, other programs, and any data may be stored in the disk (108) to be loadable to the main memory. (“Windows” is a registered trademark of Microsoft corporation in the United States, other countries, or both; “UNIX” is a registered trademark of the Open Group in the United States, other countries, or both; “Mac OS” is a registered trademark of Apple Inc. in the United States, other countries, or both; “Linux” is a registered trademark of Linus Torvalds in the United States, other countries, or both; and “Java” and “J2EE” are registered trademarks of Oracle America, Inc. in the United States, other countries, or both).

The drive (109) may be used to install a program, such as the computer program of an embodiment of the present principles, readable from a CD-ROM, a DVD-ROM, or a BD to the disk (108) or to load any data readable from a CD-ROM, a DVD-ROM, or a BD into the main memory (103) or the disk (108), if necessary.

A communication interface (114) may be based on, for example, but is not limited to, the Ethernet® protocol. The communication interface (114) may be connected to the bus (104) via a communication controller (113), physically connects the computer (101) to a communication line (115), and may provide a network interface layer to the TCP/IP communication protocol of a communication function of the operating system of the computer (101). In this case, the communication line (115) may be a wired LAN environment or a wireless LAN environment based on wireless LAN connectivity standards, for example, but is not limited to, IEEE® 802.11a/b/g/n (“IEEE” is a registered trademark of Institute of Electrical and Electronics Engineers, Inc. in the United States, other countries, or both).

Prior to explaining an embodiment of the present principles, examples of “listing and nested paragraphs” used in the embodiment of the present principles will be explained first below.

With reference now toFIG. 2,FIG. 2illustrates examples of description having one or more listing and nested paragraphs form in a document.

Let us suppose that the document has Descriptions 1 to 3 (201,202and203, respectively). Each of Descriptions 1 to 3 (201,202and203) has listing and nested paragraphs. The listing and nested paragraphs may have multi-level paragraph listing in the form of a nested structure. Thus, the listing and nested paragraphs may have a parent paragraph in each paragraph; each parent paragraph may have a list of one or more children paragraphs; and the same may apply also to the children paragraphs. The listing and nested paragraphs are used in a document, for example, but not limited to text documents; or spreadsheet or calc documents.

One of the most important inspection-views for documents such as software-related documents is whether or not all conditions for each process or function in system description, or input process output (IPO), are described in a uniform manner and in an exhaustively way. This is because omission or notation fluctuation of the conditions is directly connected to problems in a later implementation phase.

Some examples of the appropriate and inappropriate descriptions of the conditions in the document are explained using descriptions 1 to 3 (201,202and203, respectively).

In Description 1 (201), Paragraph “2.1.,” as a parent-level paragraph, has two sub-paragraphs “(1)” and “(2)” as child-level paragraphs having the same-rank level. Paragraph “2.1.” describes a process, “check parameter”. The sub-paragraph “(1)” describes one element in the condition set for the process, {“checking” and “OK”}. The sub-paragraph “(2)” describes another element in the condition set, {“checking” and “NG”}. Accordingly, the sub-paragraphs “(1)” and (2), which is the child paragraphs of the parent-level paragraph are in the same-rank level, cover the condition set of “{“checking” and “OK”} and {“checking” and “NG”}. Accordingly, it is concluded that the condition set is described appropriately in Description 1 (201).

In Description 1 (202), Paragraph “4.,” as a parent-level paragraph, has two sub-paragraphs “1.” and “2.” as child-level paragraphs having the same-rank level. The Paragraph “4.” Describes a process, “check parameter”. The sub-paragraph “1.” does not describe any condition set for the process but has a lower sub-paragraph as a grandchild paragraph “⋅” in which one element in the condition set, {“checking” and “NG”}, is described. The sub-paragraph “2.” describes another element in the condition set, {“checking” and “OK”}. Accordingly, the sub-paragraphs “1.” and “2” having the same-rank level do not cover the condition set of “{“checking” and “NG”} and {“checking” and “OK”}, but the different-rank level sub-paragraphs “⋅” and “2” cover the condition set of “{“checking” and “NG”} and {“checking” and “OK”}. Accordingly, it is concluded that the condition set is described inappropriately in Description 2 (202). Further, it is concluded that the improper sub-paragraphs is used in Description 2 (202). Further, it is apparent that the numerals used in the sub-paragraphs are inappropriate in view of the numeral used in the parent-level paragraph.

In Description 3 (203), Paragraph “5.,” as a parent-level paragraph, has the two sub-paragraphs “5.1.” and “5.2.” as child paragraphs having the same-rank level. The Paragraph “5.” Describes a process, “D-search-key existing check”. The sub-paragraph “5.1.” does not describes any condition set for the process but has a lower sub-paragraph “⋅” in which one element in the condition set, {“checking” and “NG”}, is described. The sub-paragraph “5.2.” does not describe another element in the condition set, such as {“checking” and “OK”}, and has a lower sub-paragraph as a grandchild paragraph. The lower sub-paragraph does not also describe another element in the condition set, such as {“checking” and “OK”}. Thus, another element in the condition set is neither described in the sub-paragraph nor its lower sub-paragraph. Accordingly, it is concluded that the condition set is inappropriately described in Description 3 (203).

In one embodiment of the present principles, the functions of detecting suspicious condition-related low-quality parts of the descriptions are provided. In the suspicious condition-related low-quality parts, for example, the following situations will be found: the conditions may not be described exhaustively; some extra conditions may be mentioned; or some conditions may be described in different ways in different places in the same kind of documents.

Hereinafter, an embodiment of the present principles will be described with reference toFIG. 3,FIGS. 4A to 4D,FIGS. 5 and 6,FIGS. 7A and 7B, andFIGS. 8 and 9mentioned below.

The idea of an embodiment of the present principles is on the basis of an assumption that if a condition set is described in child-paragraphs having the same-rank level, such condition set expresses related- (or may be exclusive) and independent- (or worth to be independently described) conditions with respect to one another. This means that if one element in the condition set is described, another or other elements in the condition set should be described in the description.

This can be reasonable and widely accepted assumption, because, in the usual listing and nested paragraphs usage, the low-level paragraphs describe detail information of the upper-level paragraph and paragraphs having the same-rank level describe independent (but may be similar or related with each other) information.

Also, in our inspection experiences for system descriptions in listing and nested paragraphs form written in any language such as English and Japanese, each exclusive condition often has been found to be described separately in the same-rank level child-paragraphs of a parent paragraph describing a process or function, and conversely, conditions described in the same-rank level child paragraphs of a parent paragraph have been almost certainly express related- (and exclusive-) conditions in the listing and nested paragraphs form.

With reference now toFIG. 3,FIG. 3illustrates an embodiment of an overall diagram for briefly explaining a process for generating one or more condition sets from one or more documents and performing quality inspection on one or more documents, using the one or more condition sets.

A system such as the computer (101) performs the steps described inFIG. 3. The system may be implemented as a single computer or plural computers.

The process basically is divided in two parts: one is for generating one or more conditions sets from one or more documents (see steps301to305): and another is for performing quality inspection on one or more documents, using the generated conditions sets (see steps306and307).

In step301, the system reads one or more documents from a storage, such as drive (109) or from a network storage. The document may have one or more listing and nested paragraphs. The paragraph may have one or more paragraph texts each of which comprises one or more condition expressions. The document may have descriptions relating to, for example but not limited to, an existing or developing system.

In step302, the system reads one document and then recognizes one or more paragraphs in the document, using a text-parser (311), such as FP parser, which can be used for recognizing a paragraph tree for each document. Any text-parser known in the art, such as FP parser, can be used for recognizing paragraphs.

The system associates each logical formula with a node in the paragraph tree to generate one or more paragraph trees from the recognized paragraphs. In the paragraph tree, each node in the paragraph tree corresponds to a paragraph text in the document, namely, the node corresponds to a paragraph text from which the logical formula was extracted. Each edge in the paragraph tree corresponds to parent-child relation between the paragraphs in the document. Any method known in the art can be used for generating the one or more paragraph trees.

In step303, the system extracts, from each paragraph text, one or more conditions as a logical formula, using a text-parser (312), such as GP parser, which can be used for extracting one or more conditions as a logical formula from each paragraph text in the paragraph tree. Any text-parser known in the art can be used for extracting the conditions. The GP parsers may be implemented as the same or different of the FP parsers. Any text-parser known in the art, such as GP parser, can be used for extracting one or more conditions from each paragraph text. The text-parser may be, for example, but not limited to, Boxer for English, and STREET-JP for Japanese. Also, such text-parser can be manually constructed by finding, based on observation of the one or more documents, a pattern from a part where a condition is described, extracting a condition from the found pattern and, then, combining the condition.

The logical formula can be expressed, for example, as a form of (A, C). The form (A, C) means that an item or parameter A has a value of C or satisfies constraint C. The followings are listed as an example of the logical formula: if A has C then . . . ”, “if A is C then . . . ”, and “if C set to A then . . . ”.

Further, if the form of (A, C) is expressed as (_, C), (_, C) means a condition saying the condition C itself holds or the constraint C is satisfied. The followings are listed as an example of the logical formula: “In the case of C”, and “If C then . . . ,”.

When a paragraph tree for each document D is expressed as T(D), each node in the T(D) contains a text of each paragraph in the document D and each edge in the T(D) expresses super/sub-relation on the paragraph in the document D.

The system extracts conditions as a logical formula, where primitive expression is of the form of (A, C), using the text-parser for text of each node of T(D) and then annotates the logical formula with the node to obtain a paragraph tree annotated with a condition set, τ(D). Hereinafter, the paragraph tree annotated with a condition set is referred to as condition set-annotated paragraph tree. Accordingly, the condition set-annotated paragraph tree, τ(D), for each document D is obtained.

In step304, the system obtains a set of paragraph nodes of each paragraph for all paragraphs of all documents. Further, the system obtains one or more condition sets written by a set of logical formulas from the one or more extracted conditions, according to a set of child nodes belonging to each common parent node in each of the paragraph trees.

The system obtains a set of child nodes belonging to a common parent node in the paragraph tree in which each logical formula is associated with a node and then gathers logical formula associated with each of the child nodes in each set of the child nodes to obtain the aforementioned one or more condition sets written by a set of logical formulas. Hereinafter, the set of child nodes belonging to a common parent node is also referred to as same-level-paragraph condition-set (SLP-cond-set).

When a set of paragraphs, τ(D), are used, the system obtains, from the set of paragraphs, τ(D), one or more condition sets written by a set of logical formulas.

The system may use condition extraction patterns (313) to extract the one or more conditions. The condition extraction patterns (313) define a specific tree pattern and are used for extracting conditions that should be considered at the same time.

In step305, the system generates one condition set used for quality inspection, for each of the one or more condition sets written by the set of logical formulas. The condition set used for quality inspection is the condition set which must be covered in a target document for quality inspection, which the document set is named as “must-cover-condition set” (MCCS).

The system generates MCCS, according to the following step (a) or steps (a) and (b).

Step (a): The system divides one or more elements in each condition set (a first condition set) written by a set of logical formulas into elements having a common item or parameter and other elements.

For example, each set of logical formulas mentioned below are divided into elements having a common item or parameter and other elements.

The set of logical formulas, {(A,a1),(A,a2),(_,c1),(_,c2)}, is divided into two parts, {(A,a1),(A,a2)}, {(_,c1),(_,c2)}. In this example, the division is carried out according to the common item “A” and “_”.

The set of logical formulas, {(A,a1)(B,b1), (B,b2), (_,c1)}, is divided into two parts, {(A,a1)B,b1),(B,b2)}, {(_,c1)}. In this example, the division is carried out according to the common item “B”.

When the step (a) is only carried out, a result set obtained in the step (a), namely the second condition set as MCCS, is stored into a storage (314) and can be used for performing quality inspection of a document, according to one of the present principles.

When both of the steps (a) and (b) are carried out, a result of step (a), namely the second condition set, is used in the step (b).

Step (b): The system translates a specific keyword which is an element in the second condition set obtained in the step (a) into a form of a logical formula.

For example, the second condition set, {(time, 9:00˜15:00), (time, otherwise}, is converted to {(time, 9:00˜15:00), (time, not(9:00˜15:00))} by translating a keyword, “otherwise” as “not(9:00˜15:00)”. The keyword which will be translated is registered in advance, because the keyword may be assumed by the observation of the one or more documents.

When both of the steps (a) and (b) are carried out, a result set obtained in the step (b), namely a third condition set as MCCS, is stored into a storage (314) and can be used for performing quality inspection of a document, according to one of the present principles.

The followings are other examples of MCCSs. Each MCCS represents exhaustive condition sets in which (A, C) can take.

In step306, the system reads one or more condition sets used for quality inspection, namely the MCCSs, from the storage (314) and judges whether a document in the one or more documents satisfies any one of the MCCSs or not.

The judgment may be performed by judging whether the paragraph tree in which each logical formula is associated with a node satisfies at least one of the one or more condition sets used for quality inspection.

In one embodiment, the judgment may be performed by judging whether the paragraph tree in which each logical formula is associated with a node has a node with which a logical formula corresponding to one condition comprised in one condition set used for quality inspection is associated; if the judgment is positive, searching for a parent node of the node with which a logical formula corresponding to the one condition is associated, using a check policy (315); and if the parent node is found, judging whether the parent node has child nodes with which each logical formula corresponding to each of the remaining one or more conditions comprised in the condition set which comprises the one condition is associated or not.

If the paragraph tree in which each logical formula is associated with a node does not have a child node with which a logical formula corresponding to one condition comprised in the one or more condition sets used for quality inspection is associated, a conclusion is made that the judged document does not satisfy the one or more condition sets used for quality inspection.

If the paragraph tree in which each logical formula is associated with a node does not have a child node with which a logical formula corresponding to one condition comprised in the one or more condition sets used for quality inspection is associated, a conclusion is made that the judged document does not satisfy the one or more condition sets used for quality inspection.

If the parent node have all child nodes with which each logical formula corresponding to each of the remaining one or more conditions comprised in the condition set which comprises the one condition is associated, a conclusion is made that the judged document satisfies the one or more condition sets used for quality inspection.

An exemplified embodiment of the judgment will be explained below.

The condition set-annotated paragraph tree, τ(D), obtained in step (b) was used to create a C(nd) for a set of conditions annotated to each node nd of τ(D).

For MCCS MϵMCCSs and each τ(D), the system judges whether τ(D) satisfies MCCS M under the check-policy (315), using the following procedure. The check policy (315) may be used to decide a search range in the condition set-annotated paragraph tree mentioned below and to specify a parent node as a base node from which a child node may be found. The check policy (315), cp, may be defined as, for example, but not limited to, cp=(cflag, reg) where cflag or condition flag refers to a Boolean flag and reg refers to a regular expression.

Step 1. For each paragraph tree, τ(D), the system finds node nd such that fϵC(nd) and f implies fi by using, for example, the Depth-first search.

Step 1-1: If there exists no such node in τ(D), it is concluded that τ(D) does not satisfy M.

Step 1-2: If such node nd exists in τ(D):

Step 1-2-1: The system finds the base node of quality inspection, bnode, such that bnode is a parent node of node nd and bnode matches the check policy.if such bnode does not exist, the system sets bnode to root node of τ(D). Here, bnode matches cp means cflagC(bnode)≠φ and reg matches text of bnode.

Step 1-2-2: The system finds xnode_i (i=1, . . . , n) such that each xnode_i is a child node of bnode and there exists x_iϵC(xnode_i) satisfying that x_i implies fi.Step 1-2-2-1: if such xnode_1, . . . , xnode_n exists, the system concludes that τ(D) satisfies M.Step 1-2-2-2: if such xnode_1, . . . , xnode_n does not exist, the system concludes that τ(D) does not satisfy M.

An embodiment of setting bnode will be explained inFIG. 5below.

In step306, the system concludes that the judged document does not have any inconsistent description if the judgment is positive. While the system concludes that the judged document has any inconsistent description, if the judgment is negative.

In step306, the system obtains, for each MCCS M, IC (M) which is mapping from MCCS M to a set of documents whose condition set-annotated paragraph trees do not satisfy a MCCS M.

In step307, the system prepares a report for the judged document, if the judgment is negative. The system may prepare a report of the description parts which fail to the judgment and the reasons of the failure, such as missing or extra conditions. These may be caused from notation fluctuations or bad paragraph-usage, but these themselves are right parts that may often cause problems in implementation phases and may be preferable to be reported by document quality inspection.

An exemplified embodiment of the preparation of the report will be explained below.

For each MCCS MϵMCCSs, the system carries out the following procedure.

The system calculates a set of documents DOC (M) such that DOC(M)=∪{IC(M′)|M∩M′≠φ and M′ϵMCCSs}. Here, DOC(M) is the set of the documents which may be inconsistent with regard to the condition description and inclusiveness (for example, some condition may lack, some condition description may be described in different ways).

In step308, the system outputs to a user the report (316) of documents DOC(M) or the detailed parts of the document in DOM(M).

FIGS. 4A to 4Dillustrate a flowchart for implementing an embodiment of the present principles.

In an explanation ofFIGS. 4A to 4D, the following abbreviations are used. “Docs”: documents; “MCCS”: a must-cover-condition set; “PT”: a paragraph tree; “TT”: a set of condition set-annotated paragraph tree, τ(D); “FP”: a parser for recognizing a paragraph tree for each document; “GP”: a parser for extracting, from each paragraph text, one or more conditions as a logical formula; and CP: check policy.

With reference now toFIG. 4A,FIG. 4Aillustrates an embodiment of an overall flowchart of a process for generating one or more condition sets from one or more documents and performing quality inspection on one or more documents, using the one or more condition sets.

In step401, the system starts the process mentioned above. The system prepares main (Docs, PP, CP).

In step402, the system assigns an empty set to PT in order to initialize PT. Further, the system assigns an empty set to TT in order to initialize TT.

In step403, the system judges whether Docs is empty or not. If the judgment is negative, the system proceeds to step404. If the judgment is positive, the system proceeds to step406.

In step404, the system obtains one document from Docs and then assigns the obtained document to D. Next, the system removes the obtained document from Docs, by using Docs−{D}, and then assigns Docs−{D} to Docs in order to update Docs.

In step405, the system recognizes a paragraph tree, using the FP, from the obtained document and then assigns the recognized paragraph tree to T(D). Next, the system extracts each document D from Docs and then converts the document D into the paragraph tree. After then, the system collects a set of PT∪{T(D)} and then assigns the collected PT∪{T(D)} to PT. The system repeats the steps403to405for each document in Docs (namely, until Docs becomes empty).

In step406, the system judges whether PT is empty or not. If the judgment is negative, the system proceeds to step407. If the judgment is positive, the system proceeds to step412.

In step407, the system obtains one element (namely, a paragraph tree) in PT and then assigns the obtained PT to T(D). Next, the system removes the obtained element from PT, by using PT−{T(D)}, and then assigns PT−{T(D)} to PT in order to update PT.

In step408, the system extracts all nodes in the paragraph tree and collects these extracted nodes in node set Ns.

In step409, the system judges whether Ns is empty or not. If the judgment is negative, the system proceeds to step410. If the judgment is positive, the system proceeds to step411.

In step410, the system obtains an element (namely, a node) N from Ns. Next, the system removes the obtained element from Ns by Ns−{N} and then assigns Ns−{N} to Ns. The system extracts one or more paragraph texts from the obtained element (N) and then assigns the obtained paragraph texts to txt. Next, the system extracts one or more conditions as a logical formula from the extracted paragraph texts and then assigns the extracted conditions to logicalExp. The system annotates the extracted conditions to the obtained node in the obtained paragraph tree. The system repeats the steps409and410for each element in Ns (namely, until Ns becomes empty).

In step411, here, all nodes in T(D) are annotated with conditions which are extracted from the node. The system assigns the condition annotated paragraph tree, T(D), to τ(D). Next, the system collects τ(D) by TT<−TT∪{τ(U)}, where TT is a set of τ(D)s.

In step412which corresponds to the step305ofFIG. 3, the system generates MCCSs from each paragraph graph. The detail of the step412will be explained usingFIG. 4B.

In step413which corresponds to the step306ofFIG. 3, the system judges whether a document in the one or more documents satisfies any one of the MCCSs or not. The detail of the step413will be explained usingFIG. 4C.

In step414which corresponds to the step307ofFIG. 3, the system prepares a report of the judged documents. The detail of the step414will be explained usingFIG. 4D.

In step415which corresponds to the step308ofFIG. 3, the system reports the judged document.

In step416, the system terminates the process mentioned above.

With reference now toFIG. 4B,FIG. 4Billustrates an embodiment of a flowchart of a process for generating MCCSs from each paragraph graph.

In step421, the system starts the process mentioned above. The system obtains TT generated in step411, using getMCCSs(TT).

In step422, the system copies TT to TT1. The system sets SLPcondSetSet to zero in order to initialize SLPcondSetSet. The SLPcondSetSet is used for storing the SLP-cond-set.

In step423, the system judges whether TT1 is empty or not. If the judgment is negative, the system proceeds to step424. If the judgment is positive, the system proceeds to step428.

In step424, the system obtains an element, namely τ(D), from TT1. Next, the system removes the obtained τ(D) from TT1 by TT1−{τ(D)} and then assigns TT1−{τ(D)} to TT1 in order to update TT1. The system obtains all nodes from the obtained τ(D), by using getAllNodes(τ(D)), and then assigns all of the obtained nodes to pset.

In step425, the system judges whether pset is empty or not. If the judgment is negative, the system proceeds to step426. If the judgment is positive, the system proceeds back to step423in order to repeat the steps423to425.

In step426, the system obtains an element (namely, a set of paragraph nodes for each paragraph) from pset and then assigns the obtained element to N. Next, the system removes the obtained element from pset and then assigns pset-N to pset. The system extracts all of a set of children nodes from the obtained element (N) and then assigns the obtained all of the set of children nodes to chset.

The step426corresponds to the process, which is described in the step304ofFIG. 3, for obtaining a set of paragraph nodes of each paragraph for all paragraphs of all documents.

In step427, the system obtains all conditions from chest, by using gelallConditions(chest), and then assigns all of the obtained conditions to SLP-cond-set. Next, the system collects SLP-cond-set by SLPcondSetSet<−SLPcondSetSet∪{SLP-cond-set}. The system repeats the steps425to427for each pset (namely, until pset becomes empty).

The step427corresponds to the process, which process is described in the step304ofFIG. 3, for obtaining the aforementioned one or more condition sets written by a set of logical formulas by obtaining a set of child nodes belonging to a common parent node in the paragraph tree in which each logical formula is associated with a node and gathering logical formula associated with each of the child nodes in each set of the child nodes.

In step428, the system sets MCCSs to zero in order to initialize MCCSs.

In step429, the system judges whether SLPcondSetSet is empty or not. If the judgment is negative, the system proceeds to step430. If the judgment is positive, the system proceeds to a final step436.

In step430, the system obtains an element, namely a first condition set, from SLPcondSetSet and then assigns the obtained element to SLP-conds Next, the system removes the obtained element from SLPcondSetSet by SLPcondSetSet−{SLP-conds} and then assigns SLPcondSetSet−{SLP-conds} to SLPcondSetSet in order to update SLPcondSetSet.

In step431, the system divides one or more elements in SLP-conds into elements having a common item or parameter, by using devideBySameItemParam(SLP-conds), to generate second condition set and then assigns the second condition set to SLP-cond-sets.

The step431corresponds to the process, which is described in the step305, step (a), ofFIG. 3, for dividing one or more elements in each condition set (the first condition set) written by a set of logical formulas into elements having a common item or parameter and other elements.

In step432, the system judges whether SLP-cond-sets is empty or not. If the judgment is negative, the system proceeds to step433. If the judgment is positive, the system proceeds back to the step429in order to repeat the steps429to431.

In step433, the system obtains an element (namely, a second condition set which is generated by dividing one or more elements in the first condition set) from SLP-cond-sets and then assigns the obtained element to aset. Next, the system removes the obtained element from SLP-cond-sets by SLP-cond-sets−{aset} and then assigns SLP-cond-sets−{aset} to SLP-cond-sets in order to update SLP-cond-sets.

In step434, the system translates a specific keyword which is an element of the SLP-cond-sets, namely the second condition set) into a form of a logical formula to generate a third condition set as MCCS, using translateAllOtherwiseIntoLogicalFormula(aset), and then assigns the generated third condition set to mccs.

The step434corresponds to the process, which is described in the step305, step (b), ofFIG. 3, for translates a specific keyword which is an element in the second condition set obtained in the step (a) into a form of a logical formula.

In step435, the system collects a set of MCCSs∪{mccs} and then assigns the collected MCCSs∪{mccs} to MCCSs. The system repeats the steps432to435for each SLP-cond-set (namely, until SLP-cond-sets becomes empty) to obtain MCCSs.

In step436, the system terminates the process mentioned above and proceeds to the step413ofFIG. 4A.

With reference now toFIG. 4C,FIG. 4Cillustrates an embodiment of a flowchart of a process for judging whether each document is consistent with each MCCS.

In step441, the system starts the process mentioned above. The system prepares getUncovereMaps(TT, MCCSs, CP).

In step442, the system prepares empty-map and copy the empty-map to IC.

In step443, the system judges whether TT is empty or not. If the judgment is negative, the system proceeds to step444. If the judgment is positive, the system proceeds to a final step461.

In step444, the system assigns MCCSs to MCCSs1. Next, the system obtains an element, namely τ(D), from TT. Next, the system removes the obtained τ(D) from TT by TT−{τ(D)} and then assigns TT−{τ(D)} to TT. The system obtains all nodes from the obtained τ(D), by using getAllNodes(τ(D)), and then all of the obtained nodes to pset.

In step445, the system judges whether MCCSs1 is empty or not. If the judgment is negative, the system proceeds to step446. If the judgment is positive, the system proceeds back to the step443and repeats the steps443to445.

In step446, the system obtains an element, namely MCCS, from MCCSs1 and then assigns the obtained element to M. Next, the system removes the obtained element from MCCSs1 by MCCSs1−{M} and then assigns MCCSs1−{M} to MCCSs1 in order to update MCCS s1.

In step447, the system copies M to Mcp1.

In step448, the system judges whether Mcp1 is empty or not. If the judgment is negative, the system proceeds to step449. If the judgment is positive, the system proceeds back to the step445and repeats the steps443to445or steps445to448.

In step449, the system obtains an element, namely MCCS, from Mcp1 and then assigns the obtained element to f. Next, the system removes the obtained element from Mcp1 by Mcp1−{f} and then assigns MCCSs1−{f} to Mcp1 in order to update Mcp1.

In step450which corresponds to the step306, Step 1, ofFIG. 3, the system finds node nd such that fϵC(n) and f implies fi by using, for example, the Depth-first search and then assigns the found nodes to nd

In step451, the system judges whether nd is empty or not. If the judgment is positive, the system proceeds to the step452. If the judgment is negative, the system proceeds to step453.

In step452which corresponds to the step306, Step 1-1, ofFIG. 3, the system concludes that τ(D) does not satisfy M, if there exists no such node in τ(D). IC [M−>τ(D)] is the map defined by IC[M−>τ(D)] (M1)=IC(M1) if M=/=M1 and IC[M−>τ(D)] (M1)=τ(D) if M=M1. The system assigns IC [M−>τ(D)] to IC.

In step453, which corresponds to the step306, Step 1-2-1, ofFIG. 3, the system finds the base node of quality inspection, bnode, such that bnode is a parent node of node nd and bnode matches the check policy.

In step454, the system judges whether bnode is null or not. If the judgment is positive, the system proceeds to step455below. If the judgment is negative, the system proceeds to step456below.

In step455, the system sets a root node in τ(D) as bnode because such bnode does not exists. Next, the system assigns the root node to bode.

In step456, the system copies M to Mcp2.

In step457, the system judges whether Mcp2 is empty or not. If the judgment is negative, the system proceeds to step458below. If the judgment is positive, the system proceeds back to step448and repeats the steps448to457. Further, if the judgment is positive, the system concludes that the system concludes that τ(D) satisfies M, because such xnode_1, . . . , xnode_n exists.

In step458, the system obtains an element, namely MCCS, from Mcp2 and then assigns the obtained element to f. Next, the system removes the obtained element from Mcp2 by Mcp2−{f} and then assigns Mcp2−{f} to Mcp2 in order to update Mcp2.

In step459, which corresponds to the step306, Step 1-2-2, the system finds xnode_i (i=1, . . . , n) such that each xnode_i is a child node of bnode and there exists x_iϵC(xnode_i) satisfying that x_i implies fi. Next, the system assigns the found xnode to xnode.

In step460, the system judges whether xnode is null or not. If the judgment is positive, the system proceeds back to step452and repeats the steps448to460. Further, if the judgment is positive, the system concludes that τ(D) does not satisfy M, because such xnode_1, . . . , xnode_n does not exist (see Step 1-2-2-2). If the judgment is negative, the system proceeds to step457. Further, if the judgment of step460is negative and the judgment of step457is positive, the system concludes that τ(D) satisfies M, because such xnode_1, . . . , xnode_n exists (see Step 1-2-2-1).

In step460, the system terminates the process mentioned above and proceeds to the step414ofFIG. 4A.

With reference now toFIG. 4D,FIG. 4Dillustrates an embodiment of a flowchart of a process for preparing a report of the judged documents.

In step471, the system starts the process mentioned above. The system prepares getReport(IC, MCCSs).

In step472, the system sets REPORT to zero in order to initialize REPORT. Further, the system copies MCCSs to MCCSs2.

In step473, the system judges whether MCCSs2 is empty or not. If the judgment is negative, the system proceeds to step474. If the judgment is positive, the system proceeds to a final step479.

In step474, the system obtains an element, namely MCCS, from MCCSs2 and then assigns the obtained element to M. Next, the system removes the obtained element from MCCSs2 by MCCSs2−{M} and then assigns MCCSs2−{M} to MCCSs2 in order to update MCCSs2.

In step475, which corresponds to step307ofFIG. 3, the system calculates a set of documents DOC (M) such that DOC(M)=∪{IC(M′)|M∩M′≠φ and M′ϵMCCSs} to prepare a report and then assigns the obtained DOC(M) to DOC(M).

In step476, the system judges whether DOC (M) is empty or not. If the judgment is negative, the system proceeds to step477. If the judgment is positive, the system proceeds back to the step473and repeats the steps473to476for each MCCS (namely, until MCCSs2 becomes empty).

In step477, the system obtains an element, namely a document, from DOC(M) and then assigns the obtained element to D. Next, the system removes the obtained element from DOC(M) by DOC(M)−{D} and then assigns DOC(M)−{D} to DOC(M) in order to update DOC(M).

In step478, the system prepares a set of (D, M) and then assigns (D, M) to REPORT.

In step479, the system terminates the process mentioned above and proceeds to the step415ofFIG. 4A.

With reference now toFIG. 5,FIG. 5illustrates embodiments of setting bnode which is used as a base node of quality inspection and judging whether a document satisfies the MCCS, using the condition set-annotated paragraph tree.

For MCCS M, M is set to ={f1,f2,f3}. The check policy, cp, is defined as cp={true, (*ing|peform|process)}. The condition flag in the cp is set to “true”. The regular expression in the cp is set to “(*ing|peform|process)”. The condition flag, “true”, means that the check policy matches node where some conditions are extracted. The regular expression, “(*ing|peform|process)”, means that the check policy matches a node containing a paragraph text that matches the regular expression.

For the condition set-annotated paragraph tree D1, τ(D1) (501), the process for setting bnode will be explained below.

The system finds the node nd (512) which has the logical formula f1 that implies f1. Next, the system can find the node (511) as a root note of τ(D1), using the check policy. Then, the system sets the node (511) as bnode.

After the system finds the bnode (511), the system judges whether τ(D1) satisfies M={f1,f2,f3}. The bnode (511), as the parent node, has the child node (515), which has the logical formula f2 that implies f2, and the grandchild node (514), which has the logical formula f3 that implies f3 and which is a child node of node (513). Therefore, the system judges that τ(D1) satisfies M={f1,f2,f3}. Accordingly, the system does not report a result to a user.

For the condition set-annotated paragraph tree D2, τ(D2) (521), the process for setting bnode will be explained below.

The system finds the node nd (536) which has the logical formula f1 that implies f1. Let us suppose that the node (535) has the text, “search process. Next, the system assumes that node (535) matches the check policy because the node (535) has the text, “search process”. Then, the system sets the node (535) as bnode.

After the system finds the bnode (535), the system judges whether τ(D2) satisfies M={f1,f2,f3}. The bnode (535), as the parent node, has neither the child node (533), which has the logical formula f2 that implies f2, nor the child node (534) which has the logical formula f3 that implies f3. Nodes (533) and (534) are child nodes of node (532) and grandchild nodes of node (531). Therefore, the system judges that τ(D2) does not satisfy M={f1,f2,f3}. Accordingly, the system reports to a user a result stating to the effect that the document comprising τ(D2) is inconsistent with regard to the condition description and inclusiveness or that (D2) in the document is inconsistent with regard to the condition description and inclusiveness.

With reference now toFIG. 6,FIG. 6illustrates embodiments of performing quality inspection, using condition sets according to one embodiment of the present principles.

Descriptions 1 to 3 (201,202and203, respectively) in the document are the same as those described inFIG. 2.

The system generates a condition set used for quality inspection, namely MCCS, from Descriptions 1 (201). Let us suppose that only one MCCS, M, is generated and M={(checking, NG), (checking, OK)}. This is because, in the other parts, there is only one condition in child paragraphs of the same parent.

The system judges whether each of Descriptions 1 to 3 (201,202and203, respectively) in the document satisfies MCCS M or not. In detail, the system judges whether, when there is a paragraph containing one condition, (checking, NG), there is a paragraph which contains another condition, (checking, OK) under the common parent paragraph satisfying the check policy. The following check policy is used: cp={true, (*ing|peform|process)}.

For Description 1 (201), the system generates the condition set-annotated paragraph tree (601) of Description 1 (201). The system finds the node (613) containing (checking, NG) as a child node, using the CP. Next, the system finds the node (612), using the CP, and sets the node (612) as a parent node of the child node (613). Node (612) is also the child node of node (611). After then, the system searches for a same-rank level child node which is a child node of the common parent node (612) and contains (checking, OK), using the CP. The system finds the node (614) which is a child node of the common parent node (612) and contains (checking, OK). Accordingly, the system concludes that the condition set-annotated paragraph tree (601) of Description 1 (201) satisfies MCCS M.

For Description 2 (202), the system generates the condition set-annotated paragraph tree (621) of Description 2 (202). The system finds the node (633) containing (checking, NG) as a child node, using the CP. Next, the system finds the node (632), using the CP, and sets the node (632) as a parent node of the child node (633). After then, the system searches for a same-rank level child node which is a child node of the common parent node (632) and contains (checking, OK), using the CP. However, the system cannot find a node which is a child node of the common parent node (632) and contains (checking, OK). Therefore, the system concludes that the condition set-annotated paragraph tree (621) of Description 2 (202) does not satisfy MCCS M. Accordingly, the system reports Description 2 (202) as an improper description and further may report to the effect that Description 2 (202) has an improper paragraph usage.

For Description 2 (202), the system further finds the node (634) containing (checking, OK) as a child node, using the CP. Next, the system finds the root node (631), using the CP, and sets the root node (631) as a parent node of the child node (634). After then, the system searches for a same-rank level child node which is a child node of the common parent node (631) and contains (checking, NG), using the CP. However, the system cannot find a node which is a child node of the common parent node (631) and contains (checking, NG). Therefore, the system concludes that the condition set-annotated paragraph tree (621) of Description 2 (202) does not satisfy MCCS M. Accordingly, the system reports Description 2 (202) as an improper description and further may report to the effect that Description 2 (202) has an improper paragraph usage.

For Description 3 (203), the system generates the condition set-annotated paragraph tree (641) of Description 3 (203). The system finds the node (653) containing (checking, NG) as a child node, using the CP. Next, the system finds the root node (651), using the CP, and sets the root node (651) as a parent node of the child node (653). The root node (651) is the parent node of nodes (652) and (654). Node (652) is the parent node of node (653), and node (654) is the parent node of node (655). After then, the system searches for a same-rank level child node which is a child node of the common parent node (651) and contains (checking, OK), using the CP. However, the system cannot find a node which is a child node of the common parent node (651) and contains (checking, OK). Therefore, the system concludes that the condition set-annotated paragraph tree (641) of Description 3 (203) does not satisfy MCCS M. Accordingly, the system reports Description 3 (203) as an improper description and further may report to the effect that Description 3 (203) does not have another case condition for normal case.

FIGS. 7A, 7B and 8illustrate an embodiment of performing quality inspection on documents, according to an embodiment of the present principles.

With reference now toFIG. 7A,FIG. 7Aillustrates three types of Documents on which an embodiment of quality inspection on the documents is performed according to an embodiment of the present principles.

Let us suppose that there are three types of Documents A to C (701,711and721, respectively) which describe function descriptions. Each of Documents A to C (701,711and721) has listing and nested paragraphs. In each of Documents A to C (701,711and721), the underlines are intentionally added for ease of explanation.

For a document quality inspection, the following check policy is used: cp=(cflag, reg=(*ing|perform|process)).

For Document A (701), the system generates a condition set which is located at the same level, “{(“checking”, “NG”)}{(“checking”, “OK”)}” (702). For Document B (711), the system generates a condition set which is located at the same level, “{(“checking”, “NG”)(“checking”, “OK”)}” (712). For Document C (721), the system generates a condition set which is located at the same level, {(“checking”, “NG”)} {(“checking”, “OK”)} (722).

The system generates the following MCCS: {(“checking”, “NG”)(“checking”, “OK”)}.

For Document A (701), the system generates a condition set-annotated paragraph tree from Document A (701) and then judges whether the condition set-annotated paragraph tree satisfies the MCCS or not. The system searches for (“checking”, “NG”) in the condition set-annotated paragraph tree. After the system finds a node containing (“checking”, “NG”), the system finds a parent node of the node containing (“checking”, “OK”). After then, the system searches for a same-rank level child node which is a child node of the common parent node and contains (checking, OK), using the CP. However, there is no node containing (“checking”, “OK”) under the paragraph 1. Accordingly, the system put a warning message.

For Document A (701), the system further searches for (“checking”, “OK”) in the condition set-annotated paragraph tree. After the system finds a node containing (“checking”, “OK”), the system finds a parent node of the node containing (“checking”, “OK”). After then, the system searches for a same-rank level child node which is a child node of the common parent node and contains (checking, NG), using the CP. However, there is no node containing (“checking”, “NG”) under the paragraph 1. Accordingly, the system reports a warning message for Document A (701).

For Document B (711), the system generates a condition set-annotated paragraph tree from Document B (711) and then judges whether the condition set-annotated paragraph tree satisfies the MCCS or not. The system searches for (“checking”, “NG”) in the condition set-annotated paragraph tree. After the system finds a node containing (“checking”, “NG”), the system finds a parent node of the node containing (“checking”, “OK”). After then, the system searches for a same-rank level child node which is a child node of the common parent node and contains (checking, OK), using the CP. There is the node containing (“checking”, “OK”) under the paragraph “1”. Therefore, the system can find the same-rank level child node. This means that the condition set-annotated paragraph tree satisfies the MCCS. Accordingly, there is no need to put warning message for Document B (711).

For Document C (721), the system generates a condition set-annotated paragraph tree from Document C (721) and then judges whether the condition set-annotated paragraph tree satisfies the MCCS or not. The system searches for (“checking”, “NG”) in the condition set-annotated paragraph tree. After the system finds a node containing (“checking”, “NG”), the system finds a parent node of the node containing (“checking”, “OK”). After then, the system searches for a same-rank level child node which is a child node of the common parent node and contains (checking, OK), using the CP. There is the node containing (“checking”, “OK”) on paragraph (2) under the paragraph “*check the value of print-out data”. Therefore, the system can find the same-rank level child node. This means that the condition set-annotated paragraph tree satisfies the MCCS. Accordingly, there is no need to put warning message for Document C (721).

Accordingly, the system reports Document A (701) as a candidate to be reviewed carefully.

A user who receives the report from the system can review Document A (701) and revise descriptions in Document A (701).

With reference now toFIG. 7B,FIG. 7Billustrates an embodiment of revising a document, based on a report output according to an embodiment of the present principles.

FIG. 7Billustrates Documents A (731) and B (771). Document A (731) relates to a cross description with sequential tasks and conditional branch. Document B (771) relates to a structured description with sequential tasks and conditional branch.

Document A (731) is the same as Document A (701) ofFIG. 7A. In Document A (731), the phrase, “checking is NG”, is described on the sub-paragraph (1) under the paragraph 1, and the phrase, “checking is OK”, is described on the paragraph 2. Therefore, exclusive conditions are described on different paragraph (1) and 2. Accordingly, it is concluded that Document A (731) was not described properly about exclusive conditions.

The task flow (751) of Document A (731) was generated (741) from Document A (731). The task flow (751) shows that there are four passes. However, the following two passes cannot be realized: Start-1-(1)-false-2-false-end, Start-1-(1)-true-2-true-End.

The decision table (752) of Document A (731) was generated (742). The decision table (752) shows that cases which are not realized were generated.

The test cases (753) were generated (743) by transforming the decision table (752). The test cases (753) show that unnecessary cases were generated.

Accordingly, it is understood that quality and productivity relating to Document A (731) go down.

The user reviewed Document A (731) and generated (761) Document B (771). In Document B (771), the phrase, “checking is NG”, is described on the sub-paragraph (1) under the paragraph 1, and the phrase, “checking is OK”, is described on the sub-paragraph (2) under the paragraph 1. Therefore, exclusive conditions are described on the same-rank level child paragraph. Accordingly, Document B (771) was described properly about exclusive conditions.

The task flow (791) of Document B (771) was generated (781) from Document B (771). The task flow (791) shows that there are two passes and all of the passes can be realized.

The decision table (792) of Document B (771) was generated (782). The decision table (792) shows that cases which are not realized were not generated.

The test cases (793) were generated (783) by transforming the decision table (792). The test cases (793) show that unnecessary cases are not generated.

Accordingly, it is understood that quality and productivity relating to Document B (771) go up.

With reference now toFIG. 8,FIG. 8illustrates an embodiment of three types of descriptions on which an embodiment of quality inspection is performed according to an embodiment of the present principles.

Let us suppose that there are three types of Descriptions X to Z (801,811and821, respectively) in a document, which Descriptions describe function descriptions. Each of Descriptions X to Z (801,811and821) has listing and nested paragraphs.

For a document quality inspection, the following check policy is used: cp=(cflag, reg=(*ing|perform|process)).

For Description X (801), the system generates a condition set which is located at the same level, “{(costDB.buying-price, 100K$less than), (costDB.buying-price, 300K$greater than equal), (costDB.buying-price), not(100K$less than)not(300K$greater than equal)}” (802). For Description Y (811), the system generates a condition set which is located at the same level, “{(costDB.buying-price, 100K$less than), (costDB.buying-price, not(100K$less than)}” (812). For Description Z (821), the system generates a condition set which is located at the same level, {(costDB.buying-price, 100K$less than)} (822).

For Description X (801), the system generates a condition set-annotated paragraph tree from Description X (801) and then judges whether the condition set-annotated paragraph tree satisfies the MCCS or not. The system concludes that the condition set-annotated paragraph tree coves M1 and also M2. Accordingly, there is no need to put warning message for Description X (801).

For Description Y (811), the system generates a condition set-annotated paragraph tree from Description Y (811) and then judges whether the condition set-annotated paragraph tree satisfies the MCCS or not. The system concludes that the condition set-annotated paragraph tree coves M2 and also M1. Accordingly, there is no need to put warning message for Description Y (811).

For Description Z (821), the system generates a condition set-annotated paragraph tree from Description Z (821) and then judges whether the condition set-annotated paragraph tree satisfies the MCCS or not. The system concludes that the condition set-annotated paragraph tree coves neither M1 nor M2. Accordingly, the system put a warning message. For example, for M1, “(costDB.buying-price, 300K$greater than equal), (costDB.buying-price), not(100K$less than)not(300K$greater than equal)” is output as a difference; and, for M2, “(costDB.buying-price, not(100K$less than)” is output as a difference.

Accordingly, the system reports Description Z (821) as a candidate to be reviewed carefully.

A user who receives the report from the system can review Description Z (821) and revise descriptions in Description Z (821).

In a case of Description Z (821), a description of a default case lacks.

With reference now toFIG. 9,FIG. 9illustrates an embodiment of an overall functional block diagram of a computer system hardware used in accordance with the embodiment of the flowcharts described inFIG. 3andFIGS. 4A to 4D.

The system (901) may correspond to the computer (101) described inFIG. 1.

The system (901) comprises a section of inputting document (911), a section of recognizing paragraphs (912), a section of extracting conditions (913), a section of obtaining condition sets (914), a section of generating condition set used for QI (915), a judging section (916) and a reporting section (917).

The section of inputting document (911) may perform step301described inFIG. 3.

The section of recognizing paragraphs (912) may recognize one or more paragraphs in each document having one or more listing and nested paragraphs and generate one or more paragraph trees.

The section of recognizing paragraphs (912) may perform step302described inFIG. 3.

The section of extracting conditions (913) may extract one or more conditions as a logical formula from each paragraph text comprising a condition expression.

The section of extracting conditions (913) may perform step303described inFIG. 3.

The section of obtaining condition sets (914) may obtain one or more condition sets written by a set of logical formulas from the one or more extracted conditions, according to a set of child nodes belonging to each common parent node in each of the paragraph trees.

The section of obtaining condition sets (914) may perform step304described inFIG. 3.

The section of generating condition set used for QI (915) may generate one condition set used for quality inspection, for each of the one or more condition sets written by the set of logical formulas.

The section of generating condition set used for QI (915) may perform step305described inFIG. 3.

The judging section (916) may judge whether a document in the one or more documents (991) satisfies any one of the one or more condition sets used for quality inspection or not. The judging section (916) may conclude that the judged document does not have any inconsistent description, if the judgment is positive. The judging section (916) may conclude that the judged document has any inconsistent description, if the judgment is negative.

The judging section (916) may perform step306described inFIG. 3.

The reporting section (917) may report the judged document, if the judgment carried out by the judging section (916) is negative.

The reporting section (917) may perform steps307and308described inFIG. 3.

EXAMPLES

The system generates ten MCCSs listed below from 33 target documents, according to an embodiment of the present principles.

2. {(_, the project exists in the transform project file), (_, no transform target)(_, the project exists in the integrate project file)}

10. {(_, all configurations have been created), (_, all configurations have not been created)}

The reports were output after quality inspection of the 33 target documents mentioned above, according to an embodiment of the present principles. The report includes twelve documents and descriptions containing quality problems relating to condition coverage or expression consistency. Ten documents among twelve documents actually contained quality problems that should be reported as a result of the quality inspection, while two documents did not contain quality problems that should be reported as a result of the quality inspection.

The following Reports 1 to 3 are examples which were reported by the system.

Report 1: There are documents (or descriptions) containing the condition (checking, OK), but not containing (checking, NG); description parts for MCCS1: Eight documents related to this problem.

Report 2: There are documents (or descriptions) containing the condition (return code, 5), but not containing (return code, 4): description parts for MCCSs 3 and 4; Two documents are related to this problem (Notes by the inventors of the present invention: these parts actually should be reported by manual quality inspection for documents.).

Report 3: There are documents (or descriptions) containing the condition (_,selected line block=6), but not containing (_, selected line block=0): descriptions for MCCSs 7 and 8; Two documents related to this problem (Notes by the inventors of the present invention: it was found by manually reviewing these documents that these parts are actually no problem (namely, wrong reporting)).

Aspects of the present principles are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the present principles. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer readable program instructions.

By the expression “a/one” should be understood as “at least one”.

By the expression “comprise(s)/comprising a/one” should be understood as “comprise(s)/comprising at least one”.

By the expression “comprise(s)/comprising” should be understood as “comprise(s)/comprising at least”.

By the expression “/” should be understood as “and/or”.